Projet 5.4: Etude de l’impact des erreurs de célérité sur ...afhy.fr/images/pdf/Rapports/Projet54_Sujet1_SVP_Erreur_Lhomme... · Ce projet est très stimulant car les erreurs

1 Projet 5.4: Tiphaine LHOMME, Gabin SOGORB, Emmanuelle SUEL, Emeline VEIT

Projet 5.4: Etude de l’impact des erreurs de célérité sur un lot de données multifaisceaux

Octobre 2014- Février 2015

Tiphaine Lhomme Gabin Sogorb

Emmanuelle Suel Emeline Veit


Remerciements Nous souhaitions remercier Mr Moitié pour sa présence constante et toute l'aide apportée dans de nombreux domaines et en particulier celui des mathématiques. Merci à Mme Debèse de nous avoir permis de travailler sur un sujet aussi intéressant que celui des erreurs de célérité et de nous avoir épaulé dans l'utilisation du logiciel Caris-Hips. Merci à Mr Simon de nous avoir une nouvelle fois permis d’aller acquérir des données en rade de Brest. Nous voulions remercier le reste du corps professoral de la branche Hydrographie qui de près ou de loin a suivi ce projet. Merci enfin à nos camarades et amis de nous avoir permis d’utiliser leurs lots de données.


Introduction Ce projet a pour but de traiter une problématique scientifique spécifique à un aspect de l'Hydrographie ou de l'Océanographie. Ainsi, certains groupes travaillent sur des sujets orientés vers le positionnement et d'autres sur des thématiques océanographiques. Dans notre cas, nous avons choisi un sujet en lien avec l'hydrographie et plus particulièrement en lien avec les problèmes induits par les erreurs de célérité. Plus spécifiquement, le but de notre projet est de quantifier l'erreur de célérité sur une zone donnée en fonction de la profondeur de cette zone et de corriger les données en simulant un nouveau profil de célérité qui serait plus proche de célérité réelle sur la zone. Il s’agit également d’étudier l’influence des masses d’eau qui se déplacent lors d’un levé. Le but de ce projet est avant tout de limiter les effets de redressement que nous pouvons observer sur les faisceaux extrêmes. C'est en rabattant ces extrémités de faisceau que nous pourrons limiter l'impact de l'erreur de célérité sur la zone de travail. Pour ce faire plusieurs étapes sont nécessaires. Il faut d'abord appréhender ce qu'est une erreur de célérité et passer par une étape de compréhension théorique du phénomène. Ensuite il faut posséder toutes les données nécessaires à la réalisation d'un algorithme permettant de minimiser les effets des erreurs de célérité rencontrées. Enfin il faut créer l'algorithme en question qui dans un premier temps calcule l’erreur de profondeur et dans un second temps corrige le profil de célérité. En ce qui concerne la deuxième partie, il faut définir des modèles de célérité de une à n couches et les tester pour trouver le plus adapté. Avant de généraliser à des profils de célérité plus compliqués en fonction du nombre de couches que nous considérons dans la colonne d'eau de la zone sur laquelle nous travaillons.


Sommaire

Introduction ............................................................................................................................ 3

I- Définition du projet et stratégie établie ................................................................... 5 A. Enjeux et limites du projet ................................................................................................ 5 B. Recherches préliminaires et bibliographie ....................................................................... 6 C. Stratégie initiale mise en place ......................................................................................... 7

II- Acquisition des données et problèmes rencontrés ................................................. 8 A. Problèmes rencontrés sur notre lot de données .............................................................. 8 B. Données utilisées .............................................................................................................. 9 C. Redéfinition de nos objectifs en fonction de données obtenues .................................. 11

III- Exploitation et exportation des données acquises .......................................... 11 A. Programme Python de récupération des données ......................................................... 11 B. Modification des profils de célérité sous Caris-HIPS ...................................................... 12

IV- ALGORITHME .......................................................................................................... 16 A. Principe de l'algorithme .................................................................................................. 16 B. Données simulées ........................................................................................................... 16 C. Données réelles .............................................................................................................. 25 D. Méthode des moindres carrés ........................................................................................ 27

Conclusion ............................................................................................................................ 30


I- Définition du projet et stratégie établie

A. Enjeux et limites du projet Le but de notre projet est de quantifier l'erreur de célérité en fonction de la profondeur sur une zone et des masses d’eau présentes. Ensuite nous pouvons essayer de recréer un profil de célérité plus proche de la réalité ce qui permettrait de minimiser les erreurs de célérité présentes sur la zone de travail. Une des limites du projet est le nombre de couches à considérer dans la réalisation de notre profil de célérité. Au départ il est nécessaire de commencer par des profils simples découpant la colonne d’eau en une ou deux couches. Puis si le temps le permet et l'algorithme fonctionne nous tenterons de généraliser à un nombre de couches plus élevé. Le choix de la zone de travail est également très important pour ce projet dont le thème principal est la célérité. C'est pour cette raison que les données utilisées sont issues de l'embouchure de l'Elorn comme nous pouvons le voir sur la figure n°1. Ainsi nous bénéficions d'un contexte favorable à l'apparition d'erreurs de célérité dues aux mélanges des eaux salées en provenance de la mer et douce en provenance de l'Elorn. Ce projet est très stimulant car les erreurs de célérité sont très délicates à traiter. Si l'on ne fait pas de profils de célérité de manière extrêmement régulière dans ce type de zone nous pouvons vite être submergés par des erreurs pouvant aller jusqu’à la dizaine de centimètres. C'est dans ce cadre qu'une quantification de cette erreur en fonction de la profondeur afin d'en réduire les effets intervient.


Figure 1: Zone générale de levé dans l'Elorn

B. Recherches préliminaires et bibliographie Nous avons commencé par effectuer des recherches sur le sujet pour savoir

ce qui avait déjà été fait. Nous avons principalement centré nos recherches sur les algorithmes existants. Nous avons principalement étudié le rapport de fin d’étude d’un ancien élève de l’ENSTA écrit par Monsieur Le Moigne en 2011 [1].

Nous avons organisé notre recherche bibliographie grâce au logiciel Zotero. Ce logiciel nous a permis de synthétiser nos recherches et d'en donner l'accès à tous les membres du groupe ainsi qu'à Mme Debèse, notre referrante pour ce projet. Ce logiciel nous a servi d'intermédiaire pour créer la bibliographie finale de ce rapport. De plus, il peut être utilisé afin de regrouper les articles et ouvrages en fonction de mots clés que nous lui précisons. Il sait également regrouper les fichiers qu'il possède en fonction des thèmes traités. Par la suite nous avons fait le tri dans notre bibliothèque de documents rassemblés en premier lieu afin de ne garder que l'essentiel, c'est à dire les documents qui nous ont réellement servis lors de ce projet.


C. Stratégie initiale mise en place Nous avons commencé par schématiser l’algorithme lui-même sur la figure n°2 ci-dessous:

Figure 2: Schématisation de l'algorithme


La deuxième étape consistait à définir les zones de levé en fonction des données dont nous aurions besoin. Nous avons prévu d’effectuer des lignes les plus perpendiculaires possible pour nous permettre de tester plus simplement notre algorithme. Nous avons décidé de faire des levés sur deux zones différentes. La zone n°1 doit se situer en pleine mer et sur fond plat afin de ne pas être sujette à de trop fortes erreurs de célérité et nous servir de référence. Sur ces données nous pourrons effectivement mener des tests en modifiant la célérité grâce au logiciel de traitement de données Caris-HIPS et observer les conséquences de ces modifications. La seconde zone doit en revanche être été soumise à des erreurs de célérité beaucoup plus importante. Nous avons donc choisi de la placer dans l’Elorn, là où les masses d’eau provenant du fleuve et de la mer se rencontrent. Ce sont ces données qui seront utilisées pour tester notre algorithme car le mélange d'eaux douces et d'eaux salées fosse fortement les profils de célérité car ils ne sont valables que quelques instants. Or un levé peut durer de quelques minutes à plusieurs heures. De plus, nous avons cherché une zone avec un fond plat mais également une pente pour nous permettre d’étudier l’influence de la bathymétrie et de tester le fonctionnement de notre algorithme sur des zones de relief. Le projet de fin d'étude réalisé par Mr Le Moigne [1] nous a permis en partie d'imaginer la structure de l'algorithme envisagé tel qu'il est présenté en figure n°2.

II- Acquisition des données et problèmes rencontrés

A. Problèmes rencontrés sur notre lot de données Lors de notre première sortie en mer au mois d'Octobre 2014 nous avons utilisé le sondeur Kongsberg EM2040C, cependant nous n'avons pas pu utiliser le logiciel d'acquisition SiS car il n’était pas encore installé sur la Panopée. Nous avons obtenu des fichiers au format .xtf ce qui ne nous a pas permis de récupérer toutes les données que nous désirions. Pour cette raison, nous avons dû faire une deuxième sortie en mer. Malheureusement la météo était mauvaise ce jour là pour le travail que nous devions réaliser. Nous nous sommes aperçus lors du traitement des données qu’elles présentaient des oscillations régulières représentatives d’une erreur systématique, visible sur la figure n°3.


Figure 3: Visualisation des ondulations sur une ligne de notre lot de données

Nous nous sommes rendu compte que d’autres groupes étaient confrontés au même problème que nous. Nous avons tenté d'implémenter dans le logiciel Caris-HIPS les données de marée du jour du levé. Cela nous a permis de voir que l'erreur ne venait pas du système GPS. Lorsque nous nous sommes s’intéressés au pilonnement nous avons observé une corrélation entre les oscillations et le pilonnement comme on peut le voir sur la figure n°3

Cette erreur correspond à un retard entre le sondeur multi faisceau et la centrale

inertielle. La solution pour traiter le problème est donc de rejouer les données tout en cherchant par dichotomie la valeur de ce retard en ms. D'après les indications de Mme Debèse ce retard est inférieur à 10 ms. Cependant les données des groupes travaillant sur les deux autres sujets donnés par Mme Debèse présentaient une erreur beaucoup moins importante car ils ont bénéficié d'une météo plus clémente durant leur levé. Nous avons fait le choix de travailler sur les données du groupe n°3 afin d'avancer sur notre projet.

B. Données utilisées En raison des problèmes mentionnés dans le paragraphe précédent les

données utilisées sont finalement celles du groupe 3, composé de Romain Dufour, Vincent Gourmelen, Marie Tallarmin et Caroline Velay. Ces données proviennent également de la zone encerclée sur la figure n°1. L'algorithme qui sera développé sera testé cette zone. La première étape consiste à quantifier l'erreur de célérité en fonction de la profondeur. Sur la figure n°4 nous pouvons voir le tracé des lignes effectuées par le groupe 3. Ces lignes sont en particulier centrées sur la présence de deux épaves.


Figure 4: Modèle numérique de terrain de la zone étudiée. Modèle réalisé à 1m de résolution. Avec la méthode

Swath angle du logiciel Caris-HIPS

Ces données sont intéressantes pour nous car ce groupe a constaté sur la

zone une erreur de célérité "classique" due au mélange entre eau douce et eau salée, caractéristique dans l'embouchure de l'Elorn. Cela nous permettra de tester notre algorithme sur des erreurs réelles rencontrées sur le terrain en plus des erreurs que nous générerons aléatoirement. Cependant le fond n'est pas suffisamment plat. En effet les dénivelés sont de l'ordre du mètre, ce qui ne correspond pas tout à fait aux données réelles nécessaires pour satisfaire notre stratégie initiale qui était de tester dans un premier temps notre algorithme sur un fond supposé plat. Ainsi nous avons décidé de travailler avec le lot de données du groupe n°2, composé de Vignyl Djine et Valère Leblic. Ce lot est composé d’une seule ligne comme nous pouvons le voir sur la figure n°5 présenté ci-dessous. Nous l’utiliserons donc pour tester les différents profils de célérité sous CARIS car elle présente des zones de fond plat. En revanche il ne pourra pas être utilisé par l’algorithme. Cette décision a été prise de façon tardive car nous avons longtemps tenté d'utiliser les données issues du groupe n°3.


Figure 5: Modèle numérique de terrain du groupe n°2. Modèle réalisé à 1m de résolution. Avec la méthode

Swath angle du logiciel Caris-HIPS

C. Redéfinition de nos objectifs en fonction de données obtenues

Nous ne pourrons donc pas utiliser les données que nous souhaitions, ainsi nous avons dû redéfinir les objectifs que nous nous étions fixés. Nous avons des données qui nous permettront de tester notre algorithme mais nous n’avons pas de fond suffisamment plat pour étudier l’influence de la présence de relief par comparaison. Cependant nous pourrons tester différents profils de célérité sur une seule ligne grâce au logiciel CARIS. Nous ne pourrons pas non plus comparer l’influence des différentes masses d’eau car nous ne possédons pas de données valables en pleine mer. De plus, notre lot de données ne présente pas de ligne perpendiculaire ce qui peut s’avérer problématique au vu de la conception de l’algorithme vu en figure n°2.

III- Exploitation et exportation des données acquises

A. Programme Python de récupération des données

Après avoir traité nos données sous CARIS nous les avons exportées afin de mettre dans un seul fichier texte les données suivantes:

-Northing (mètre) -Easting (mètre) -Profondeur sondée (mètre) -Numéro de cycle (ping) -Numéro de faisceau (beam) -Angle du faisceau (degré) -Temps de trajet (seconde) -Attitudes (degré) -Célérité de surface (mètre/seconde)


Comme nous ne pouvons pas obtenir toutes les données nécessaires pour le projet via la fonction d'export de Caris, nous devons utiliser des lignes de commandes dans la console de commande Windows afin de récupérer d'autres valeurs telles que les attitudes ou encore la célérité de surface enregistrée. Les commandes utilisées sont les suivantes, citées dans le rapport de Mr Le Moigne [1]:

- printfRange (extraction du temps de trajet et de l’angle d’incidence) - printfHeave (extraction du pillonement) - printfRoll (extraction du roulis) - printfPitch (extraction du tangage) - printfSSP (extraction de la célérité de surface)

Afin de récupérer toutes les données acquises en mer nous avons créé un programme dans le langage Python qui reçoit en entrée les fichiers obtenus via les lignes de commandes printXXXX ci-dessus et l'exportation de Caris. Ce fichier donne en sortie une liste comprenant toutes les données qui nous intéressent pour la réalisation de notre projet et un fichier texte équivalent. Le squelette du programme Python est fourni en Annexe I de ce rapport. Il a fallu exécuter ce programme pour toutes les lignes de données, ce qui constitue un travail un peu fastidieux. Un point intéressant serait donc d'automatiser la procédure pour que le programme Python traite toutes les lignes d'un seul coup. De même, en ce qui concerne les exportations réalisées grâce aux lignes de commandes, en pratique nous devons faire ces exports à la main, là ou un programme court au format shell pourrait automatiser la procédure. Dans le but de réaliser ce programme en langage Python nous avons eu recourt au Dictionnaire Hydrographique [2] qui nous a aidé dans la compréhension de différents termes et ainsi de ne pas confondre des termes tels que faisceaux, cycles et fauchées. De plus l'ouvrage de Mme Debèse [5] fût également très utile pour travailler sur ce vocabulaire spécifique à l'Hydrographie.

B. Modification des profils de célérité sous Caris-HIPS Afin de voir l'impact des erreurs de célérité sur les données acquises sur le terrain nous avons décidé d’appliquer différents profils de célérité aux données que nous avons empruntées au groupe n°2. Cela permet d’observer et de quantifier les conséquences d’une erreur de célérité et à terme d'introduire les profils de célérité générés par notre algorithme dans le logiciel Caris-HIPS afin d'observer les données ainsi corrigées. Nous avons créé nos nouveaux profils de célérité grâce à un programme Matlab qui se trouve en Annexe II. Nous avons simulé quatre profils représentés sur la figure n°6.


Figure 6: Profils de célérité générés sous Matlab

Pour charger ces profils dans CARIS et modifier les données nous avons dû utiliser la version 8.1.9. En effet, les versions auxquelles nous avions accès au début du projet ne réussissaient pas à recalculer les nouvelles données, la figure n°7 montre un exemple des modèles de terrain que nous obtenions. Lors de ce projet nous avons plusieurs fois des problèmes avec le logiciel Caris HIPS, afin de comprendre pourquoi le logiciel ne marchait pas toujours et dans le but de trouver une solution nous avons utilisé le fichier d'aide de Caris [3].

Figure 7 : Visualisation du bug de la version Caris-Hips 8.1

En utilisant la nouvelle version nous avons pu modifier notre profil de célérité. Si l’on abaisse le profil de célérité nous nous attendons à voir le fond remonter. Le profil de célérité utilisé lors du levé se trouve en annexe III. Nous avons commencé par tester un profil constant à 1495m/s. Nous obtenons les résultats suivants :


Nous effectuons exactement la même opération avec le profil à deux

couches. Dans ce cas là le résultat obtenu est aberrant : .

Nous obtenons donc des valeurs positives au nadir (figure n°8).

Figure 8: Modèle numérique obtenu en appliquant le profil de célérité à deux couches

Cette erreur ne provenait d’une mauvaise configuration du bateau ou d’une

erreur dans la structure des profils de célérité. Cependant lors du chargement du nouveau profil nous prenions en compte la célérité au niveau du sondeur (SSP) (figure n°9)

Figure 9: Menu de chargement d’un profil de célérité


Cependant la SSP est plus importante que la vitesse de la première couche,

nous passons de 1510m/s environ à 1502m/s. Cette différence trop importante ressemble à un comportement de réflexion sur la couche de vitesse trop faible, situé en dessous du sondeur, par rapport à la vitesse considérée par le sondeur. Nous remarquons que ce problème n’est pas apparu avec le profil constant, ce que nous n’arrivons pas à expliquer.

Nous avons donc appliqué nos profils sans l’option utilisant la SSP et nous obtenons les résultats regroupés dans le tableau ci-dessous :

Réel 1495m/s 1502 m/s 2 couches 3couches

Profondeur minimale (m)

9.92 8.27 8.30 8.26 8.29

Profondeur minimale (m)

17.73 15.84 15.92 15.94 15.83

Ces valeurs correspondent à ce que nous attendions. En effet lorsque nous

diminuons la célérité, le fond remonte excepté pour le modèle deux couches, cela est peut être dû à la définition du profil. Nous avons ensuite calculé la différence de profondeur théorique entre les deux profils constants pour vérifier la cohérence de nos résultats. Nous nous sommes placé au fond pour ce calcul :

En fixant v=1495 m/s, nous avons d=15.84m et donc t=0.0106s Si nous augmentons la célérité de 7m/s pour atteindre 1502m/s, la distance

parcourue en plus est d=t × 7=0.0742m

La différence théorique entre les deux modèles est de 7.5cm et la différence obtenue entre les deux modèles numériques sous CARIS est de 8cm. L’application des profils sous CARIS donne donc des modèles cohérents.

Ainsi une erreur de quelques mètres par seconde entraîne un biais de quelques centimètres sur la bathymétrie sur un fond d’une vingtaine de mètres. Dans le cas d’un fond plus profond, cette erreur serait plus importante. L’impact de l’erreur de célérité dépend du but pour lequel sera fait un levé. Pour la navigation, par exemple, lorsque l’erreur deviendra importante, le fond devrait être suffisament important pour qu’une erreur de l’ordre de quelques dizaines de centimètres soit négligeable.


IV- ALGORITHME

A. Principe de l'algorithme

L'algorithme que nous souhaitons mettre en place dans le but de minimiser l'erreur de célérité vise à se servir des faisceaux centraux d'une ligne pour corriger les faisceaux extrêmes d'une ligne proche. Nous savons que les faisceaux centraux ne sont quasiment pas sujets aux erreurs de célérité tandis que les faisceaux extrêmes sont ceux sur lesquels nous observons une erreur de célérité maximale. C'est pour cette raison que nous avons choisi de nous focaliser sur la correction des faisceaux extrêmes qui doivent être ramenés à une profondeur correcte en premier lieu. Pour ce faire, l'algorithme mis en place permet de définir une zone dans laquelle les faisceaux sont considérés comme "bons", ce sont les faisceaux centraux des lignes étudiés. De même nous définissons des données dites "à corriger" qui sont les faisceaux extrêmes des lignes que nous avons à notre disposition. Il faut souligner que les limites sont définies de manière arbitraire. En effet, nous savons quels faisceaux sont les plus touchés et les moins touchés, cependant nous avons dû faire un choix pour garder un nombre de données cohérents. Nous ne pouvions pas considérer un nombre trop grand de faisceaux corrects.

B. Données simulées

1. Création de données

Dans un premier temps nous avons choisi de nous placer dans un cas simple afin d’établir un premier algorithme de correction des données bruitées. Nous avons simulé deux fauchées perpendiculaires l’une à l’autre (voir figures n°10 et n°11), sur fond plat, de 200 cycles. Nous avons choisi un angle d’ouverture de 130°, avec un pas de 1° : nous avons donc 131 faisceaux ("beams") pour chaque cycle.


Figure 10: Simulation de deux fauchées sur fond plat pour des caps différents

Figure 11: Simulation de deux fauchées perpendiculaires sur fond plat

Nous avons choisi de simuler un profil de célérité sur deux couches comme nous pouvons le voir sur la figure n°12.

Figure 12: Schématisation du problème pour deux couches de célérité sur fond plat

Avec la loi de Snell-Descartes nous obtenons :

Nous avons également les longueurs et :

z(m)

x(m) y(m)

y(m)

x(m)

α 2


et

De plus, d’après la figure : et

Sur la figure n°13 nous pouvons observer les données simulées bruitées (en bleu) et les données simulées réelles (toutes situées à 20m de profondeur car nous sommes en fond plat. Afin que les erreurs soient visibles sur la figure nous avons accentué les différences de célérité entre les deux couches, nous avons choisi une différence de 25m/s. A cinq mètres de profondeur nous pouvons visualiser les points situés à l’interface des deux couches de célérité. Nous avons au maximum une différence de 1.07m

Figure 13: Impact de l'erreur de célérité sur un cycle

Nous avons arbitrairement choisi les points à corriger des faisceaux extrêmes de la première fauchée et les points de la deuxième fauchée nous permettant de les corriger. La correction d’un point faussé se fait en moyennant les valeurs de ses points voisins. Ces points voisins sont les points situés dans un carré de largueur fixé en début du programme et centré sur le point à corriger.


L’algorithme de correction va donc corriger chaque point considéré trop dévié comme on peut le voir sur la figure n°14 ci-dessous :

Figure 14: Déplacement de la zone de sélection des points à corriger

Le point à corriger en rouge appartient à la fauchée bleu, les points gris à la verte. Le rectangle se déplace tout d’abord le long d’un cycle (flèche 1) sur les faisceaux extrêmes puis il change de cycle (flèche 2). Nous avons choisi de corriger l’ensemble des faisceaux de la fauchée afin d’avoir une matrice des erreurs sur tous les points et vérifier ainsi la cohérence des résultats. Les faisceaux centraux sont censés être les moins bruités. Sur la figure n°15 ci-dessous nous pouvons observer les deux fauchées et le rectangle de correction (en jaune) se déplaçant sur les points à corriger (en bleus) :

Points considérés

comme bons de la deuxième

fauchée

Points à corriger de la première fauchée


Figure 15: Fauchées avec le rectangle de correction

La matrice des erreurs, ε, est la différence entre les profondeurs biaisées et

les profondeurs corrigées.

2. Quantification des erreurs de célérité

Avec un angle de 90° : Sur la figure n°16 nous pouvons observer les deux fauchées : les points bleus correspondent aux faisceaux à corriger de la fauchée verte et les points rouges correspondent aux faisceaux de la fauchée transverse permettant la correction des faisceaux erronés. Nous pouvons observer en jaune les deux rectangles qui sélectionnent les données à corriger.

Figure 16: Visualisation des fauchées pour un angle de 90°


Figure 17 : Données corrigées et erronées d'une fauchée

Les points bleus de la figure n°17 représentent les faisceaux corrigés. Ces faisceaux ont été corrigés aux points considérés comme bons de la fauchées transverse. Nous pouvons remarquer que ces points corrigés ne sont pas situés à 20 m de profondeur comme ils auraient dû l’être si la correction avait été parfaite. En effet, il n’y a que les faisceaux du nadir de la fauchée transverse qui ne pas déviés. Or ici, la correction utilise des points proches de ceux au nadir, ils sont donc légèrement déviés. Néanmoins, ils possèdent une erreur de célérité inférieure à 12 cm, nous les avons donc considérés comme suffisamment bons pour les utiliser comme correcteurs.

La figure n°18 présente les données erronées et corrigées d’un cycle. Nous constatons que les faisceaux erronés ont été ramenés à la profondeur souhaitée.

Figure 18: Faisceaux erronés et corrigés pour un cycle pour un angle de 90° entre les fauchées


Figure 19 : Quantification des erreurs de célérité pour un cycle

La figure n°19 représente la quantification des erreurs de célérité pour un cycle : ce sont les différences entre les faisceaux erronés et les faisceaux corrigés. Nous pouvons observer que plus nous nous éloignons du nadir, plus l’erreur de célérité est importante ce qui est cohérent avec les hypothèses de simulation. Nous obtenons une erreur maximale de 1,07m. Dans toute cette partie nous nous sommes placés dans un cas « parfait » avec des fauchées orthogonales afin de vérifier le bon fonctionnement de l’algorithme.

Dans ce qui précède nous avons considéré que les faisceaux proches du nadir de la fauchée à corriger n’étaient pas déviés, afin de vérifier notre hypothèse nous avons réalisé une simulation sur la correction de tous les faisceaux.

La figure n°20 présente à nouveau les données corrigées et erronées d’un

cycle ainsi que la quantification des erreurs de célérités lorsque nous corrigeons tous les faisceaux de la fauchée à corriger :

Figure 20: Correction de tous les faisceaux


Nous constatons que nous avons une différence de 2cm pour un faisceau

situé à 15 faisceaux du nadir. Cette erreur assez importante peut s’expliquer par la différence de célérité entre les deux couches de 25m/s, ce qui est assez conséquent et que nous ne retrouverons pas sur nos données réelles.

C’est pourquoi, considérant que la différence de célérité entre les couches sera plus minimes et pour gagner en temps de calculs, lors de l’application de l’algorithme à nos données réelles nous ne corrigerons pas tous les faisceaux.

Afin de connaître l’impact du choix de la largeur de faisceaux considérés comme bons de la fauchée orthogonale (que nous avons pris à 30 dans la partie précédente), nous réalisons plusieurs simulations permettant d’observer ces différences.

Le tableau ci-dessous présente les différences de profondeur entre un

faisceau extrême situé au nadir de la fauchée orthogonale et un faisceau situé à 5 faisceaux du nadir de la fauchée orthogonale pour différentes largeurs de faisceaux considérés comme bons sur la fauchée orthogonale :

Largeur de 70 bons faisceaux



Différence 0.010m 0.007m 0.001m

Nous pouvons constater que plus la largeur de faisceaux considérés bons est

large, plus la différence est grande. Cependant cette différence reste tout de même très faible (de l’ordre du cm) ce qui confirme le choix assez approximatif de la largeur des faisceaux considérés comme bons.

Avec un angle de 70° : Nous allons maintenant nous intéresser à un cas avec des fauchées non-

orthogonales comme les cas réels que nous avons. Nous définissons donc un angle de 70° entre les deux fauchées. La figure n°21 présente les deux fauchées : en rouge celle permettant la correction des faisceaux déviés de la verte.



Figure 22: Faisceaux erronés et corrigés pour un angle de 70° entre les fauchées

La figure n°22 présente les beams erronées et corrigées d’un cycle.

Figure 23: Quantification de l'erreur de célérité pour un cycle donné


La figure n°23 représente la quantification des erreurs de célérité pour un cycle pour un angle de 70°. Nous constatons cette fois, sur les figures n°22 et n°23 que la correction n’est pas symétrique par rapport au faisceau central : en effet les fauchées n’étant pas orthogonales seule une partie des faisceaux considérés comme bons de la fauchée transverse intersectent les faisceaux à corriger.

C. Données réelles

Nous appliquons maintenant ce code à nos données réelles. Nous nous plaçons à l’intersection de deux fauchées, sur la zone la plus plate possible : cette dernière correspond à l’intersection entre deux fauchées issues des données du groupe de Monsieur Gourmelen. Nous avons également réduit nos lignes à l’intersection afin de réduire les temps de calculs. Comme on peut le voir sur la figure n°24 nous ne sommes pas en fond plat : il y a des différences de bathymétrie allant jusqu’au mètre.

Figure 24: Visualisation des deux fauchées sur CARIS

Ce fond aléatoire permet d’expliquer les valeurs de la figure n°25 représentant les différences entre les faisceaux erronés et corrigés. En effet, les plus grosses différences ne se situent pas forcément au niveau des faisceaux les plus éloignés du nadir comme c’était le cas avec nos données simulées.



Afin de connaître l’impact de la largeur de la zone de sélection nous avons

lancé plusieurs simulations avec différentes largeur du carré de sélection : Sur la figure n°26 nous pouvons observer les faisceaux corrigés et les faisceaux initiaux pour un cycle donné pour une largeur de 0.5m:

Figure 26: Visualisation des données initiales et corrigées d'un cycle


La figure n°27 présente les faisceaux corrigés et les faisceaux initiaux pour un cycle donné pour des largeurs de 0.2m, 0.5m et 1m :

Figure 27: Zoom sur les faisceaux extrêmes du cycle de données corrigées et initiales pour des largeurs de

zones de sélection de 0.2, 0.5 et 1m

Nous constatons que plus la largeur de la zone de sélection est grande

correction a lissé les données. Avec une zone de sélection supérieure à 0,5m de largeur, les données sont trop lissées et de vrais détails sur le fond ont été perdus. ll aurait pu être intéressant de changer la forme de la zone de sélection en fonction de de la topographie de la zone (par exemple un cercle, ou un rectangle allongé sur une pente …).

D. Méthode des moindres carrés

Nous allons utiliser la matrice des erreurs ε afin de déterminer la célérité de la deuxième couche et la profondeur de la première. Pour modéliser ce problèmes les cours de Monsieur Legris [4] nous ont aidé.

Figure 28: Schématisation du problème pour deux couches de célérité

Loi de Snell Descartes à l’interface entre les couches de célérité et :

donc

α 2


Nous posons

Nous cherchons à exprimer l’écart de profondeur en fonction de et de :

Et

Nous posons et tend vers 0 donc nous effectuons un

développement limité au premier ordre :

donc

et

avec le temps d’aller-retour du faisceau. Ainsi


Sous forme matricielle l’équation devient :

Nous avons donc appliqué cette méthode des moindres carrés à nos données simulées. Nous obtenons pour le 118ème cycle, par exemple une différence de célérité entre les deux couches de 78m/s soit une célérité de 1478m/s et une profondeur de première couche Zc = 17.3m : ces valeurs sont aberrantes par rapport à nos données d’entrées.

En effet, lorsque nous calculons le conditionnement de la matrice M= [A B],

nous obtenons un conditionnement de l’ordre de 106 : cela signifie que nos matrices sont très corrélées expliquant les résultats de la méthode des moindres carrés.

Nos hypothèses de bases, telles que le fond plat, sont peut-être trop réductrices. Il aurait été intéressant de réaliser une simulation avec un fond penché.

Nous avons donc décidé de ne pas appliquer ces valeurs à nos données réelles.


Conclusion L'étude des erreurs de célérité fût très intéressante car nous y serons confronté quelque soit le poste que nous occuperons dans le futur. Nous avons déjà pu voir à travers nos stages de deuxième année que dès qu'il s'agit d'acquérir des données bathymétriques sur le terrain il faut être très vigilant quand aux erreurs de célérité que l'on peut rencontrer. Cela est vrai en pleine mer mais encore plus dans des situations géographiques particulières telles que les embouchures de fleuve ou tout autre milieu présentant un mélange d'eau douce et d'eau salée. Ce projet nous a permis de nous replonger à la fois dans le langage de code Python mais également dans l'utilisation du logiciel de traitement de données bathymétriques Caris-HIPS. Ce fût très appréciable car ce sont deux aspects que nous n'avons par forcément l'occasion de travailler lors des autres UV de cette troisième année de notre cursus. De plus, nous nous sommes perfectionnées dans l'utilisation du logiciel Matlab et dans l'utilisation de méthodes dites des moindres carrés. Au cours des séances de projet nous avons été confronté à des imprévus et certaines difficultés importante qui nous ont fortement ralentis et nous ont forcés à remettre en cause nos plans. En effet, une stratégie avait été élaborée afin de répondre au sujet proposé. Cependant des difficultés dans l'acquisition des données, puis dans le traitement de ces dernières nous ont forcées à revoir nos objectifs et à travailler avec les données acquises par d’autres groupes de projet aux objectifs totalement différents des nôtres. Ainsi, nous avons dû utiliser des données en partie inadaptées à ce que nous souhaitions mettre en place, en particulier en ce qui concerne des données sur fond plat et en pleine mer. Une routine de traitement des fichiers de données acquises sur le terrain a été écrite en Python afin de centraliser toutes les informations dont nous avions besoin pour la réalisation de notre algorithme de quantification et de correction des erreurs de célérité. Cet algorithme a été codé dans le langage de programmation Matlab permettant de trouver le profil de célérité le plus adapté aux données que l'on souhaite corriger en fonction des données considérées comme correctes à proximité. Une méthode des moindres carrés vient alors en complément de cet algorithme afin de décomposer en plusieurs couches nos profils de célérité ainsi calculés. Si le projet avait duré plus longtemps nous aurions envisagé de modifier notre code de façon à adapter l'algorithme pour qu'il fonctionne sur un fond pentu dont la pente aurait pu être modifiée. Cale nous aurait permis d'envisager d'autres approches quand à la quantification et la correction des erreurs de célérité présentes.


Nous avons pu constater à quel point les problématiques de quantification et de correction des erreurs de célérité sont à la fois complexes et d'actualités comme peuvent en témoigner le projet de fin d'études [1]. Au terme de notre projet nous n’avons pas réussi à calculer l’erreur de célérité. La définition de notre algorithme n’était pas suffisamment adaptée au problème. Ainsi les inconnues de notre modélisation, l’épaisseur de la première couche d’eau et la différence de célérité entre les deux couches, étaient trop corrélées. Nous avons appris grâce à ce sujet à rechercher les sources de nos erreurs, à essayer de les corriger et dans le cas où nous n’en étions pas capable, nous les avons analysées pour en trouver la cause et en tirer des conclusions.


Liste des figures Figure 13: Zone générale de levé dans l'Elorn

Figure 14: Schématisation de l'algorithme

Figure 15: Visualisation des ondulations sur une ligne de notre lot de données

Figure 16: Modèle numérique de terrain de la zone étudiée. Modèle réalisé à 1m de résolution. Avec la méthode Swath angle du logiciel Caris-HIPS

Figure 17: Modèle numérique de terrain du groupe n°2. Modèle réalisé à 1m de résolution. Avec la méthode Swath angle du logiciel Caris-HIPS

Figure 18: Profils de célérité générés sous Matlab

Figure 19 : Visualisation du bug de la version Caris-Hips 8.1

Figure 20: Modèle numérique obtenu en appliquant le profil de célérité à deux couches

Figure 21: Menu de chargement d’un profil de célérité

Figure 22: Simulation de deux fauchées sur fond plat pour des caps différents

Figure 23: Simulation de deux fauchées perpendiculaires sur fond plat

Figure 12: Schématisation du problème pour deux couches de célérité sur fond plat

Figure 13: Impact de l'erreur de célérité sur un cycle

Figure 14: Déplacement de la zone de sélection des points à corriger

Figure 15: Fauchées avec le rectangle de correction


Figure 17 : Données corrigées et erronées d'une fauchée

Figure 18: Faisceaux erronés et corrigés pour un cycle pour un angle de 90° entre les fauchées

Figure 19 : Quantification des erreurs de célérité pour un cycle

Figure 20: Correction de tous les faisceaux


Figure 22: Faisceaux erronés et corrigés pour un angle de 70° entre les fauchées


Figure 24: Visualisation des deux fauchées sur CARIS


Figure 26: Visualisation des données initiales et corrigées d'un cycle

Figure 27: Zoom sur les faisceaux extrêmes du cycle de données corrigées et initiales pour des largeurs de zones de sélection de 0.2, 0.5 et 1m

Figure 28: Schématisation du problème pour deux couches de célérité


Bibliographie

. [1] Pierre-Yves Le Moigne. PFE. Technical report, 2011.

. [2] S 32 Dictionnaire Hydrographique. Monaco, 5ème Edition, 1994.

. [3] CARIS HIPS and SIPS 8.1 User Guide, August 2013

. [4] Michel Legris, Systèmes sonars de bathymétrie et d’imagerie

. [5] Nathalie DEBESE, Bathymétrie: Sondeurs, traitement des données, modèles numérique de terrain. TECHNOSUP, Ellipses Edition, 2013. 408 Pages.


ANNEXE I: Programme Python d'exportation des données

# -*- coding: utf-8 -*- """ Created on Fri Oct 17 09:58:21 2014 @author: suelem """ from datetime import datetime #LotFichierAtt=[FicRoll,FicPitch,FicHeave] #stockage des valeurs intéressantes de SSP dans une ligne fichierSSP = open("Ligne1SSP.txt") SSP=[] for line in fichierSSP: tab=line.split() if len(tab) >= 6 and tab[5]=="00000000": dateBrute = tab[2] date=datetime.strptime(dateBrute, '%H:%M:%S.%f') ping = int(tab[0]) cel=float(tab[3]) SSP.append([ping,date,cel]) # Les donnees attitudes sont prises toutes les 10ms FicRoll=open("Ligne1Roll.txt") FicPitch=open("Ligne1Pitch.txt") FicHeave=open("Ligne1Heave.txt") ATT=[] for line in FicRoll: tab=line.split() if len(tab) >= 6 and tab[5]=="Accepted": dateBrute = tab[2] date=datetime.strptime(dateBrute, '%H:%M:%S.%f') att=float(tab[3]) temp=[date,att] ATT.append(temp) i = 0 for line in FicPitch: tab=line.split() if len(tab) >= 6 and tab[5]=="Accepted": # dateBrute = tab[2] att=float(tab[3]) ATT[i].append(att) i += 1 j = 0 for line in FicHeave: tab=line.split() if len(tab) >= 6 and tab[5]=="Accepted": # dateBrute = tab[2] att=float(tab[3]) ATT[j].append(att) j += 1


#stokage donnees range (temps de reception) FicRange=open("Ligne1Range.txt") RANGE=[] dateBrute = -1 for line in FicRange: tab=line.split() if len(tab)>= 7 and tab[5]=="(2014-280": #pb: pas automatique ms je n'arrive pas à dire tab[6]="xx:xx:xx,xxx"?# dateBrute=tab[6][:-1]# pour enlever la derniere case date=datetime.strptime(dateBrute, '%H:%M:%S.%f') if len(tab) >= 7 and tab[6]=="Accepted": temp=[date, float(tab[2])] RANGE.append(temp) #print RANGE[0] # donnees exportees depuis CARIS CARIS=[] FicCaris= open("export_carris.txt") for line in FicCaris: tab=line.split() north=float(tab[0]) east=float(tab[1]) depth=float(tab[2]) ping=int(tab[3]) beam=int(tab[4]) CARIS.append([north,east,depth,ping,beam]) # Réunion des donnees caris et SSP N=len(CARIS) M=len(SSP) j = 0 for i in range(N): while j<M and SSP[j][0] < CARIS[i][3]: j += 1 if j < M: temps=SSP[j][1] ssp=SSP[j][2] CARIS[i].extend([temps,ssp])# qd on ajoute une liste à une liste non vide on utilise extend #réunion CARIS et RANGE K=len(RANGE) j = 0 for i in range(N): while RANGE[j][0] < CARIS[i][5]: j += 1 temps=RANGE[j][1] CARIS[i].append(temps) #réunion CARIS et ATT L=len(ATT) # si date(att)<date(caris)<date(att)+1 caris.append(roll, pitch,heave a la premiere date) j = 0 for i in range(N): while ATT[j][0]>CARIS[i][5]: j += 1 if ATT[j][0]<CARIS[i][5]<ATT[j+1][0]: att1=ATT[j][1] att2=ATT[j][2]


att3=ATT[j][3] CARIS[i].extend([att1,att2,att3]) print CARIS[0] # écriture dans un fichier txt fileout=open("ligne1final.txt","w") for i in range(N): fileout.write(str(CARIS[i][0])+";"+str(CARIS[i][1])+";"+str(CARIS[i][2])+";"+str(CARIS[i][3])+";"+str(CARIS[i][4])+";"+str(CARIS[i][5])+";"+str(CARIS[i][7])+";"+str(CARIS[i][8])+";"+str(CARIS[i][9])+";"+str(CARIS[i][10])+";"+str(CARIS[i][11])+";"+"\n")


Annexe II: Création de profils de célérité

Nous avons écrit le script Matlab ci-dessus pour éditer de nouveaux profils de célérité dans un format texte. %%%Création de profils de célérité %%% clear all close all clc

Vsurf=1495; % 1ere valeur de celerite Vsurf2=1502; pente1=0.5; % partie de la celerité modelisée comme une droite pente2=+0.2; pente3=-0.5;

%Chargement d'un profil existant

P=load('profil.txt'); P=[P(1:end-11,1) P(1:end-11,2)];% colonne 1: profondeur en m;

colonne 2: celerite en m/s

%Constant 1495 P2=[ P(:,1) Vsurf.*ones(length(P),1) ];

%Deux couches Droite=Vsurf2+P(1:ceil(end/2),1)*pente1; Constante=Droite(end)*ones(floor(length(P)/2),1);

P3=[ P(:,1) [Droite;Constante] ];

%Trois couches Droite1=Vsurf+P(1:ceil(end/3),1)*pente3; Droite2=Droite1(end)+(P(ceil(end/3):ceil(2*end/3),1)-

P(ceil(end/3),1))*pente2; Constante2=Droite2(end)*ones(ceil(length(P)/3)-2,1);

P4=[ P(:,1) [Droite1;Droite2;Constante2]];

%Constant 1502 P5=[ P(:,1) Vsurf2.*ones(length(P),1) ];

% Visualisation des profils figure

plot(P2(:,2),P2(:,1),'r') hold on plot(P3(:,2),P3(:,1),'m') hold on plot(P4(:,2),P4(:,1),'g') hold on plot(P5(:,2),P5(:,1)) xlabel('Célérité (m/s)', 'FontSize', 14) ylabel('Profondeur (m)','FontSize', 14) title('Profils de célérité','FontSize', 16, 'FontWeight', 'bold')


legend('Constant à 1495m/s','2 couches','3 couches','Constant à

1502m/s') set(gca,'YDir','reverse') hold off

f=fopen('Constant_1495.txt','w'); fprintf(f,'%g %g\n',P2'); fclose(f);

f=fopen('2Couches.txt','w'); fprintf(f,'%g %g\n',P3'); fclose(f);

f=fopen('3Couches.txt','w'); fprintf(f,'%g %g\n',P4'); fclose(f);

f=fopen('Constant_1502.txt','w'); fprintf(f,'%g %g\n',P5'); fclose(f);


Annexe III : Profil de célérité obtenu lors du levé

Sur la figure n°…, le profil de célérité mesuré à l’aide d’une sonde de célérité, Valeport miniSVP, est représenté.

Figure 29: Profil de célérité

Les premières valeurs sont bien plus élevées que les valeurs que nous avons

fixées pour nos profils simulés.


Annexe IV :Code Matlab

A. Création des données simulées clear all; close all; clc;

%% creation des fauchees c0=1400; %célérité dans la couche 1 c1=1425; %célérité dans la couche 2

%initialisation des variables Ltot=[];

X1=[];X2=[];Z1=[] ;X0=[];X00=[];X22=[] ;X11=[];Z11=[];Y11=[];t=[];ALP

HA2=[]; ALPHA=[]; n=200; %nombre de cycles

for cycle=1:1:n X1=[];X2=[];Z1=[];X0=[];

for alph = -65:1:65 Zc=5; %Profondeur de la couche limite Ztot=20; %Profondeur totale

%angle entre la verticale et le faisceau dévié de la deuxième

couche alpha2 = asind((c0/c1)*sind(alph));

L1=Zc/cosd(alph); L2=(Ztot-Zc)/cosd(alpha2);

%stockage des temps tc0=L1/c0; tc1=L2/c1; tt=(tc0+tc1); t=[t tt];

x2=Zc*tand(alph); X2=[X2 x2]; %coordonnees des points du changement de celerite

x0=x2+(Ztot-Zc)*tand(alpha2); X0=[X0 x0];% valeur de x pour celerite vraie

x1=x2+L2*sind(alph); X1=[X1 x1]; % valeur de x faisceau dévié avec fausse celerite

z1=cosd(alph)*(L2+L1); Z1=[Z1 z1];% valeur de z faisceau dévié avec fausse celerite

ALPHA=[ALPHA alph]; ALPHA2=[ALPHA2 alpha2]; end y1=ones(length(X1),1)+1*cycle; X00=[X00 X0'];X22=[X22 X2'];X11=[X11 X1'];Z11=[Z11

Z1'];Y11=[Y11 y1]; end


%% Création de la fauchée transverse X11T=X11; Y11T=Y11; Z11T=Z11; aa=70; %angle de rotation

%matrice de rotation

R= [cosd(aa) -sind(aa) 0 ; sind(aa) cosd(aa) 0 ; 0 0 1];

%rotation des fauchees transverses s=size(X11T); Tot=zeros(s(1)*s(2),3); Tot2=zeros(s(1)*s(2),5); k=0; for j=1:s(2) for i=1:s(1) k=k+1; Tot(k,:)=R*[X11T(i,j) Y11T(i,j) Z11T(i,j)]'; X11T(i,j)=Tot(k,1)+100; Y11T(i,j)=Tot(k,2)+100; Z11T(i,j)=Tot(k,3); Tot2(k,:)= [X11T(i,j) Y11T(i,j) Z11T(i,j) 0 i]; end end

%% bruitage des données de la fauchée à corriger X11=X11+rand(1)*0.05; Y11=Y11+rand(1)*0.05; Z11=Z11+rand(1)*0.05;

PING=n;

% limite des faisceaux déviés: on prend les 35 les plus éloignés du

nadir de chaque côté debut=35;fin=96; %définition des bons faisceaux de la fauchée transverse borne_gauche=30; %les bons faisceaux sont entre 31 et 99 borne_droite=100;

B. Fonction permettant d’obtenir des matrices ordonnées à partir

des fichiers textes

function [ CYCLE X11 Y11 Z11 ALPHA BEAM T C0 TAILLE ] = reshaper(

ligne1 ) cycle=ligne1(:,4); cycletotal=max(cycle);

X11=zeros(400,cycletotal); Y11=zeros(400,cycletotal); Z11=zeros(400,cycletotal);

alpha=ligne1(:,7);%angle_faisceau ALPHA=zeros(400,cycletotal);

t=ligne1(:,8);%temps_trajet


T=zeros(400,cycletotal);

c0=ligne1(:,6);%celerite_surface C0=zeros(400,cycletotal);

beam=ligne1(:,5);% numéro du faisceau BEAM=zeros(400,cycletotal); TAILLE=zeros(1,cycletotal);

%reshape des différentes variables: for i=1:1:length(ligne1(:,1)) X11(ligne1(i,5),ligne1(i,4))=ligne1(i,1); %ligne 5 les beams,

ligne 4 les cycles Y11(ligne1(i,5),ligne1(i,4))=ligne1(i,2); Z11(ligne1(i,5),ligne1(i,4))=ligne1(i,3); ALPHA(ligne1(i,5),ligne1(i,4))=ligne1(i,5); C0(ligne1(i,5),ligne1(i,4))=ligne1(i,6); CYCLE=length(X11(1,:)); T(ligne1(i,5),ligne1(i,4))=ligne1(i,8); end

end

C. Importation des données réelles clear all; close all; clc;

%% load lignes ligne1=load('ligne6_586_986.txt'); [PING X11 Y11 Z11 alpha beam t c0 TAILLE]=reshaper(ligne1);

%% load crossline Tot2=load('ligne11_debut_221.txt'); [PINGT X11T Y11T Z11T alphaT beamT tT c0T TAILLET]=reshaper(Tot2); %% load lignes ligne1=load('ligne6_586_986.txt'); [PING X11 Y11 Z11 alpha beam t c0 TAILLE]=reshaper(ligne1);

%% load crossline Tot2=load('ligne11_debut_221.txt'); [PINGT X11T Y11T Z11T alphaT beamT tT c0T TAILLET]=reshaper(Tot2);

% limite des faisceaux déviés: on prend les 35 les plus éloignés du

nadir de chaque côté debut=100;fin=300; %définition des bons faisceaux de la fauchée transverse borne_gauche=100; %les bons faisceaux sont entre 101 et 299 borne_droite=300;

D. Corps de l’algorithme %% correction des erreurs Z11_corrige=Z11; %matrice qui contiendra les données corrigées

for cycle=1:1:PING; %on varie sur les 200 cycles


%selection des beams à corriger de la ligne, création de vecteurs X_mauvais_gauche=X11(1:1:debut-1,:); X_mauvais_droite=X11(fin+1:1:length(X11(:,1)),:); Y_mauvais_gauche=Y11(1:1:debut-1,:); Y_mauvais_droite=Y11(fin+1:1:length(Y11(:,1)),:); Z_mauvais_gauche=Z11(1:1:debut-1,:); Z_mauvais_droite=Z11(fin+1:1:length(Z11(:,1)),:);

%definition de la taille du rectangle de sélection rect_larg_X=5 ; rect_larg_Y=5;

for i=1:1:debut-1

Z_indice=[];Z_indiced=[];Z_sauve_g=[];Z_sauve_d=[];

%rectangle beams de gauche rect_y_plusg=Y_mauvais_gauche(i,cycle)+ rect_larg_Y/2; rect_y_moinsg=Y_mauvais_gauche(i,cycle)- rect_larg_Y/2; rect_x_plusg=X_mauvais_gauche(i,cycle)+ rect_larg_X/2; rect_x_moinsg=X_mauvais_gauche(i,cycle)- rect_larg_X/2; %rectangle beams de droite rect_y_plusd=Y_mauvais_droite(i,cycle)+ rect_larg_Y/2; rect_y_moinsd=Y_mauvais_droite(i,cycle)- rect_larg_Y/2; rect_x_plusd=X_mauvais_droite(i,cycle)+ rect_larg_X/2; rect_x_moinsd=X_mauvais_droite(i,cycle)- rect_larg_X/2;

%sélection des bons faisceaux de la fauchée transverse situés

le rectangle de sélection indice=find(rect_x_moinsg<Tot2(:,1) & Tot2(:,1)<rect_x_plusg

& Tot2(:,5)>borne_gauche & Tot2(:,5)<borne_droite &

Tot2(:,2)>rect_y_moinsg & Tot2(:,2)<rect_y_plusg); indiced=find(rect_x_moinsd<Tot2(:,1) & Tot2(:,1)<rect_x_plusd

& Tot2(:,5)>borne_gauche & Tot2(:,5)<borne_droite &

Tot2(:,2)>rect_y_moinsd & Tot2(:,2)<rect_y_plusd);

% sélection des profondeurs des points de la fauchée

transverse situés dans les rectangles %indices de gauche for j=1:length(indice) Z_indice=[ Z_indice Tot2(indice(j),3)]; end %indices de droite for j=1:length(indiced) Z_indiced=[ Z_indiced Tot2(indiced(j),3)]; end

%obtention de la profondeur corrigée par moyennage des des

profondeurs de la fauchée transverse Z_mauvais_gauche_corrige=mean(Z_indice); Z11_corrige(i,cycle)=Z_mauvais_gauche_corrige; Z_mauvais_droite_corrige=mean(Z_indiced); Z11_corrige(i+fin,cycle)=Z_mauvais_droite_corrige; end end

%% matrice des erreurs epsilon=Z11_corrige-Z11; epsilon(isnan(epsilon))=0; %on enlève les nan


%% moindres carrés Xtotal=[];un=[];x=[];dc=[]; alpha=reshape(ALPHA,s(1),s(2)); c0=c0*ones(s(1),s(2)); t=reshape(t,s(1),s(2));

for cycle=1:n A=t(:,cycle).*cosd(alpha(:,cycle)).*(tand(alpha(:,cycle))).^2; B=-((tand(alpha(:,cycle))).^2)./c0(:,cycle); M=[A B]; X=M(:,:)\(epsilon(:,cycle)); Xtotal=[Xtotal X]; End

dc=Xtotal(1,:); %erreur de célérité Zc=Xtotal(2,:)./dc; %profondeur de la première couche

%matrice de conditionnement cond_M=cond(M'*M)

%% Figures %visualisation des fauchées figure for k=1:length(X11(1,:)) plot(X11(:,k),Y11(:,k),'+g') %fauchée à corriger en vert hold on end hold on for k=1:length(X11T(1,:)) hold on plot(X11T(:,k),Y11T(:,k),'*r') %fauchée transverse en rouge end hold on for k=1:length(X_mauvais_droite(1,:)) hold on plot(X_mauvais_droite(:,k),Y_mauvais_droite(:,k),'*b') %faisceaux

droits à corriger en bleu end hold on for k=1:length(X_mauvais_gauche(1,:)) hold on plot(X_mauvais_gauche(:,k),Y_mauvais_gauche(:,k),'*b') %faisceaux

gauches à corriger en bleu end hold on %rectangle droit de sélection en jaune plot(rect_x_moinsd,rect_y_moinsd,'y*',rect_x_moinsd,rect_y_plusd,'y*'

,rect_x_plusd,rect_y_moinsd,'y*',rect_x_plusd,rect_y_plusd,'y*') hold on %rectangle gauche de sélection en jaune plot(rect_x_moinsg,rect_y_moinsg,'y*',rect_x_moinsg,rect_y_plusg,'y*'

,rect_x_plusg,rect_y_moinsg,'y*',rect_x_plusg,rect_y_plusg,'y*') hold on for i=1:1:length(indice) plot(Tot2(indice(i),1),Tot2(indice(i),2),'co') hold on end hold on for i=1:1:length(indiced) plot(Tot2(indiced(i),1),Tot2(indiced(i),2),'co') hold on end


xlabel('X(m)') ylabel('Y(m)') title('Fauchées avec zone de sélection des points à corriger' )

%figures en 3d figure for k=1:length(X11(1,:)) hold on plot3(X11(:,k),Y11(:,k),-Z11(:,k),'og') % fauchée à corriger end hold on for k=1:length(X11(1,:)) hold on plot3(X11(:,k),Y11(:,k),-Z11_corrige(:,k),'+b') %faisceaux

corrigés en bleu end hold on for k=1:length(X11(1,:)) hold on plot3(X11T(:,k),Y11T(:,k),-Z11T(:,k),'+r') %fauchée transverse end xlabel('x(m)') ylabel('y(m)') zlabel('z(m)') hold on %rectangle droit de sélection plot3(rect_x_moinsd,rect_y_moinsd,20,'y*',rect_x_moinsd,rect_y_plusd,

20,'y*',rect_x_plusd,rect_y_moinsd,20,'y*',rect_x_plusd,rect_y_plusd,

20,'y*') hold on %rectangle gauche de sélection plot3(rect_x_moinsg,rect_y_moinsg,20,'y*',rect_x_moinsg,rect_y_plusg,

20,'y*',rect_x_plusg,rect_y_moinsg,20,'y*',rect_x_plusg,rect_y_plusg,

20,'y*')

%visualisation des points initiaux et des points corrigés pour un

cycle figure

k=118; plot(X11(:,k),-Z11(:,k),'*g') hold on plot(X11(:,k),-Z11_corrige(:,k),'ob') xlabel('x(m)') ylabel('z(m)')

% plot de Epsilon pour un cycle figure plot(epsilon(:,118),'+') xlabel('numero du beam') ylabel('erreur (m)')

Documents

Projet 5.4: Etude de l’impact des erreurs de célérité sur ...afhy.fr/images/pdf/Rapports/Projet54_Sujet1_SVP_Erreur_Lhomme... · Ce projet est très stimulant car les erreurs