Você está na página 1de 334

UNIVERSITE ABDELMALEK ESSAADI

Faculté des Sciences et Techniques de Tanger


Département Génie Electrique

Mémoire de DESA
UFR : Automatique et Traitement de l’information

Préparé par : Encadré par :


Mlle Imane BENALLOU M. Abdellah AZMANI

Soutenu le 05 Décembre 2006 devant le jury:

Pr. M. ER-RIANI FSTT Président


Pr. A AZMAN FSTT Encadrant
Pr.B.AMAMI FSTT Examinateur
Pr. M.JBILOU FSTT Examinateur

Année 2004 - 2006


A ma mère,
à mon père
et à mon frère,
avec tout mon coeur

1
REMERCIEMENTS

J’adresse un grand merci à M. Abdellah AZMANI pour son


aide efficace et le suivi de mes recherches.

Je remercie également tous mes professeurs, et plus

spécialement M. B. AMAMI, pour leur soutien durant ces deux


années d’études en DESA Automatique et Traitement de
l’Information.

Je ne saurai oublier ma petite famille : ma mère, mon père,


mon frère de m’avoir moralement soutenue tout au long de ma
carrière. Je les remercie du fond du cœur.

2
TABLE DES MATIERES

LISTE DES ALGORITHMES ...................................................................................... 4

INTRODUCTION...................................................................................................... 5
MODELISATION BOND GRAPH .............................................................................. 6
I. Représentation des transferts de puissance .................................................................... 6
II. Variables mises en jeu.................................................................................................... 7
III. Les éléments bond-graphs .............................................................................................. 8
IV. Notion de causalité ....................................................................................................... 12
V. Propriétés causales d’un Bond-Graph .......................................................................... 15
VI. Matrice de transfert ...................................................................................................... 18

CAUSALITE ET INFORMATIONS CAUSALES .......................................................... 21

I. Affectation de la causalité ............................................................................................ 21


II. Informations causales ................................................................................................... 28

ANALYSE ET CONCEPTION INFORMATIQUE ........................................................ 37


I. Conception de l’application ......................................................................................... 37
II. Schéma de fonctionnement .......................................................................................... 48

IMPLEMENTATION INFORMATIQUE .................................................................... 49


I. Outils et technologies ................................................................................................... 49
II. Aperçu de l’application ................................................................................................ 55

CONCLUSION ........................................................................................................ 61

BIBLIOGRAPHIE ................................................................................................... 62

ANNEXES ............................................................................................................. 64

3
LISTE DES ALGORITHMES

Algorithme 2.1 : affectation de la causalité aux sources......................................................... 22

Algorithme 2.2 : affectation de la causalité aux éléments C................................................... 24

Algorithme 2.3 : affectation de la causalité aux éléments I .................................................... 24

Algorithme 2.4 : affectation de la causalité aux jonctions 1 ................................................... 25

Algorithme 2.5 : affectation de la causalité aux jonctions 0 ................................................... 25

Algorithme 2.6 : affectation de la causalité aux éléments R................................................... 26

Algorithme 2.7 : recherche des chemins directs .................................................................... 30

Algorithme 2.8 : recherche des chemins indirects ................................................................. 32

Algorithme 2.9 : recherche des boucles causales.................................................................... 33

Algorithme 2.10 : calcul du gain d’un chemin direct.............................................................. 34

Algorithme 2.11 : calcul du gain d’un chemin indirect .......................................................... 35

Algorithme 2.12 : calcul du gain d’une boucle causale ......................................................... 35

Algorithme 2.13 : recherche des chemins disjoints................................................................. 36

Algorithme 2.14 : recherche des boucles disjointes................................................................ 36

Algorithme 2.15 : calcul de la fonction de transfert................................................................ 36

4
INTRODUCTION

La modélisation suscite un grand intérêt de la part des chercheurs, des ingénieurs et des
industriels. Elle permet, la compréhension et l’amélioration de tout fonctionnement d’un
système dynamique (physique, économique, social…).
Dans cette optique, la méthodologie Bond-Graph [1], permet de concevoir des modèles
qui se situent entre les modèles physiques et les modèles mathématiques. Les modèles Bond-
Graphs se basent sur les phénomènes d’échanges de puissance au sein d’un système. Ils
permettent ainsi de mieux appréhender la réalité physique d’un processus.
Notre projet consiste à bien étudier la méthodologie de la modélisation des bond-graphs
afin de réaliser un outil permettant d’automatiser l’étude et l’analyse d’un système physique.
La méthodologie Bond Graph se base sur un langage graphique, qui fonctionne par analogie,
afin de représenter de manière unique un système quelque soit les domaines physiques
(Electrique, Electronique, Mécanique, Hydraulique) qui le constitue.
Pour mener à bien notre travail, nous nous sommes documentés pour dégager les principes
de la méthodologie des bond-graphs. On a pu constaté que les résultats issus des Bond-Graphs
tournent autour de la manière de le parcourir, l’identification et l’exploitation de l’information
causale. Nous avons alors élaboré des algorithmes qui permettent :

 Affectation de la causalité (mise en évidence de la relation de cause à effet).


 Détermination des chemins causaux directs et indirects.
 Détermination des boucles causales.
 Vérification de la disjonction entre deux informations causales
 Calcul de la matrice de transfert sous forme d’expressions formelles.

L’élaboration des algorithmes ne constitue le seul résultat de ce mémoire. Pour favoriser


le développement d’un outil informatique de modélisation par les bond-graphs et son
expansion, nous avons proposé une représentation standardisée au format XML. De même,
nous avons élaboré un dossier d’analyse orientée objet utilisant le langage UML. Quant aux
langages de développement, nous avons choisi JAVA pour le serveur d’application et JSP
pour la génération de pages actives. Ces deux approches informatiques seront présentées, en
partie, dans les chapitres 3 et 4. Suite aux travaux d’analyse et de conception, nous avons
développé un prototype et qui nous a permet de tester les principales classes d’objets de notre
projet.
Bien que ce mémoire soit focalisé autour de l’analyse, de la conception et du
développement d’un outil de modélisation, nous avons mené un travail important autour de la
modélisation par les bond-graphs (voir annexes) et qui ouvrent des pistes recherche
intéressantes dans ce domaine.

5
Chapitre 1

MODELISATION BOND GRAPH

La méthodologie de la modélisation par bond-graph est basée sur la caractérisation des


phénomènes d'échange de puissance (par un lien) au sein du système. L'idée de la
modélisation par bond-graph est la représentation des puissances dissipées comme le produit
flux-effort et de les lier par les différentes jonctions pour reproduire le système.
L'outil bond-graph (ou graphe de liaison) défini par [Paynter, 1961], se situe comme
intermédiaire entre le système physique et les modèles mathématiques qui lui sont associés.
Ce chapitre présente les principes et les outils de base de la méthodologie Bond-graph.

I. Représentation des transferts de puissance

Considérons les deux sous-systèmes, l’un mécanique (a) et l’autre électrique (b) :
V V
F F i
A B A B
u

(a) système mécanique (b) système électrique

Dans les deux cas, il existe une liaison physique entre A et B, soit par l’intermédiaire
d’une barre dans le cas (a), soit par un fil électrique dans le cas (b). Le flux d’énergie entre A
et B est représenté par un lien de puissance, caractérisé par le symbole :

qui correspond au ‘bond’ (ou lien) du bond graph. La puissance instantanée échangée entre A
et B se calcule, en mécanique par P = F.V ou en électricité par P = ui. Le lien porte les
variables mises en jeu dans la calcul de la puissance, et le sens de la demi-flèche est celui
correspondant au produit P>0.
La traduction bond-graph des schémas physiques précédents est :

F u
A B A B
V i
(a) système mécanique (b) système électrique
:

6
II. Variables mises en jeu
1. Variables de puissance
Nous avons vu précédemment que la puissance échangée P s’exprime par le produit de
deux variables complémentaires u (ou F) et i (ou V). D’un point de vue général,
indépendamment du domaine considéré, on parle de variables ‘généralisées’ d’effort et de
flux, notées respectivement e et f [3]. Ce sont les variables de puissance, et nous avons :

P = ef

Par convention, nous représentons toujours le lien de la façon suivante :

e
e f e f
f

2. Variable d’énergie :
L’énergie est calculée par intégration de la puissance par rapport au temps :
E (t ) = ∫ P (τ )dτ ,
t
E(0)supposée nulle,
0
On définit les variables d’énergie par les relations intégrales suivantes :
p(t ) = ∫ e(τ )dτ
t
p(0) supposée nulle,
0

q (t ) = ∫ f (τ )dτ
t
q(0) supposée nulle,
0
p(t) est le moment généralisé q(t) est le déplacement généralisé.

Le tableau suivant indique la signification de ces variables généralisées pour quelques


domaines de la physique.
Variables de puissance Variables d’énergie

Domaine Effort e Flux f Moment p Déplacement q


Mécanique
force vitesse moment déplacement
(Translation
couple vitesse angulaire moment angulaire angle
Rotation)
Electrique tension courant flux magnétique charge
moment de
Hydraulique pression débit volumique volume
pression
potentiel
Chimique flux molaire nombre de moles
chimique
Thermodynamique température flux d’entropie entropie
Tableau 1.1 significations des variables généralisées pour différents domaines physiques

7
III. Les éléments bond-graphs
Les éléments bond-graphs peuvent se classifier de la façon suivante :
 Eléments passifs : R, C, I ;
 Eléments actifs : les sources Se, Sf ;
 Eléments de jonction : 0, 1, TF, GY ;

1. Les éléments passifs simples


Ces éléments sont dits passifs car ils dissipent de la puissance. La demi-flèche sera
toujours représentée entrant dans ces éléments.
a. Eléments R
L’élément R est utilisé pour modéliser tout phénomène physique liant l’effort et le
flux. A titre d’exemple, citons : amortisseur, résistance électrique, diode, restriction
hydraulique, tout phénomène de frottement…
La représentation générale est :
e
R
f
R est un élément dissipatif d’énergie.
b. Elément C
L’élément C est utilisé pour modéliser tout phénomène physique liant l’effort au
déplacement.
A titre d’exemple citons : ressort, accumulateur, condensateur, réservoir de stockage, tout
phénomène d’élasticité ou de compressibilité…
La représentation générale d’un élément C est :
e
C
f
C est un élément de stockage d’énergie.
c. Elément I
L’élément I est utilisé pour modéliser tout phénomène physique liant le flux au
moment.
A titre d’exemple, citons les masses en translation, les inerties en rotation, les inductances.
La représentation générale d’un élément I est :
e
I
f

I est un élément de stockage d’énergie.

2. Elément actifs : les sources


Ces éléments sont dits actifs car ils fournissent de la puissance au système. On distingue :
 Les sources d’effort Se (force de gravité, générateur de tension,…) ;
 Les sources de flux Sf(vitesse appliquée, générateur de courant,…) ;

L’orientation de la demi-flèche est fixée et supposée toujours sortant de la source.

8
Se Sf

Dans chaque cas, une des deux variables (effort ou flux) est supposée connue et
indépendante de la variable complémentaire induite qui dépend, elle, du système.

3. Eléments de jonction
Ces éléments, notés 0, 1, TF, GY servent à coupler les éléments R, C, I, et composent la
structure de jonction du modèle, correspondant à l’architecture du système étudié. Ils sont
conservatifs de puissance.
a. Jonction 0
La jonction 0 sert à associer les éléments soumis au même effort. Les relations qui la
caractérisent sont :
égalité des efforts
Somme pondérée des flux = 0

Considérons l’exemple suivant :


On a ici: e3 f3
e1 = e2 =e3 = e4 (caractéristique de la jonction 0)
e1f1 + e2f2 - e3f3 - e4f4 = 0 (bilan des puissances) e1
Ce qui donne: e4
f1 + f2 - f3 - f4 = 0. 0
f1 f4
La pondération sur les flux se fait avec un signe (+) ou
(-) suivant que la demi-flèche est entrante dans la jonction 0
e2 f2
ou sortante.

b. Jonction 1
La jonction 1 sert à associer les éléments soumis au même flux. Elle est la duale de
la jonction 0. Les relations qui la caractérisent sont :

égalité des flux,


Somme pondérée des efforts=0.

Considérons l’exemple suivant : e3 f3


On a ici :
f1 = f2 = f3 = f4 (caractéristique de la jonction 1)
e1
e1f1 + e2f2 - e3f3 - e4f4 = 0 (bilan des puissances) e4
Ce qui donne: 1
f1 f4
e1 + e2 – e3 - e4 = 0.
La pondération sur les efforts se fait avec un signe (+) e2 f2
ou (-) suivant que la demi-flèche correspondante est entrante
dans la jonction 1 ou sortante.

Remarque :

La jonction 0 sert à associer des éléments soumis au même effort, ce qui correspond [5] :

9
- En mécanique à des éléments en série (même effort) ;
- En électricité ou en hydraulique à des éléments en parallèle (même tension ou
même pression).
La jonction 1 sert à associer des éléments soumis au même flux, ce qui correspond :
- En mécanique à des éléments en parallèle (même vitesse) ;
- En électricité ou en hydraulique à des éléments en série (même courant ou même
débit volumique).
c. Transformateur TF
Cet élément est un 2-port, représenté par :
e1 e2
TF
f1 m f2
Où m est le module du transformateur.
Les relations qui le caractérisent sont :

e1 = m e2
f2 = m f1

A titre d’exemple, citons : le transformateur électrique, un système de poulies, un


système d’engrenages, un bras de levier,…
Cette modélisation s’accompagne d’hypothèses simplificatrices, qui supposent
négligeables des phénomènes d’inertie, de frottement, d’échauffements… qui entraîneraient
des pertes de puissance.
Si m n’est pas constant, le transformateur est un transformateur modulé, noté MTF. Cet
élément est utilisé par exemple en mécanique (relations géométriques entre variables,
réducteur variables, cinématique des mécanismes, …).
d. Gyrateur GY
Cet élément est un 2-port, représenté par :
e1 e2
GY
f1 r f2

Où r est le module du gyrateur.


Les relations qui le caractérisent sont :

e1 = r f2
e2 = r f1

Les composants physiques pouvant être modélisés par un GY sont moins courants que
pour le TF. On peut citer le gyroscope (très simplifié), le capteur à effet Hall,…
Si r est variable, l’élément est alors un gyrateur modulé, noté MGY. Cet élément
apparaît en mécanique pour modéliser la dynamique d’un solide dans l’espace.

4. Exemples
* Exemple 1 [14]
Considérons le système suivant :

10
Figure 1.1 schéma électrique

Le bond-graph correspondant est alors :

Figure 1.2 modèle Bond-graph asoicié au schéma électrique

* Exemple 2 : machine à courant continu [16]

Les figures suivantes représentent, respectivement, le schéma électrique d’une machine à


courant continu et son modèle Bond-graph associé.

Figure1.3 Schéma électrique (a) son modèle Bond-graph associé (b)

* Exemple 3 : système à deux réservoirs [15]

Soit un fluide de masse volumique ρ se déversant dans le réservoir cylindrique 1 de


section A1 avec un débit volumique q. Ce réservoir est relié au réservoir 2 de section A2 par un
tuyau de section A3 et de longueur L .Les pertes de charges sont modélisées par une résistance
R1 pour les restrictions du tube et R2 pour la fuite.

11
Figure 1.4 système à deux réservoirs

Le BG du modèle est donné.

Figure 1.5 Bond-graph du système à deux réservoirs

IV. Notion de causalité


Les Bond-graphs représentent l’architecture du système [2], de plus ils permettent de
mettre en évidence des relations de cause à effet au sein du système.
Lorsque deux sous-système A et B sont couplés, tels que A transmet à B la puissance P = ef,
nous avons deus situations possibles :
 A applique à B un « effort » e, qui réagit en envoyant à A un « flux » f ;
 A envoie à B un « flux » f, qui répond par un « effort » e.

Ces deux cas conduisent à deux schémas-blocs différents :

Prenons un exemple mécanique élémentaire pour bien comprendre ce qui vient d'être
dit : pour soulever une valise posée sur le sol, une personne doit fournir un effort. Pour cet
effort, la masse de la valise va déterminer la vitesse de levage de celle-ci. La cause est l'effort,
et la conséquence est la vitesse. De même, si l'on impose une tension électrique à une
résistance pure, cette dernière détermine l'intensité dans le circuit.

12
Pour prendre en compte ces relations de cause à effet et les représenter sur le modèle
bond-graph, nous introduisons le trait causal [8].
Le trait causal est placé perpendiculairement au lien, il indique par convention le sens
dans lequel l’effort est connu, le flux étant toujours connu dans le sens opposé au trait causal.
Ainsi si on prend l’exemple précédent, le transfert de puissance de A vers B conduit à deux
positions du trait causal.
e e
A B ou A B
f f

1. Les causalités obligatoires


Elles apparaissent sur les sources. L’effort imposé par une source d’effort, et le flux
imposé par une source de flux, sont toujours des données connues pour le système [6], ce qui
impose donc la position du trait causal.
e
Se et Sf
f

2. Causalités sur les éléments R, C, I


a. Elément R
Dans le cas linéaire, deux situations tout à fait équivalentes peuvent se présenter :
 e = Rf si f est une donnée pour R,
 f = (1/R)e si e est une donnée pour R.
Ce qui donne deux positions pour le trait causal :
e e
R ou R
f f
Pour un élément R linéaire, il n’y a pas de causalité préférentielle, il s’adapte selon la
situation de contrainte du contexte.
Lorsque l’élément R est non linéaire (restriction hydraulique par exemple), la causalité
n’est plus arbitraire et peut apparaître comme contrainte obligatoire comme pour les sources.
b. Eléments C et I
Si on écrit les relations qui caractérisent les éléments C et I sous la forme :
1 df I
eC = ∫ f C dt ou eI = I
C dt
On suppose que f est une donnée pour les éléments C et I et que e est une conséquence, ce qui
se représente en positionnant le trait causal de la manière suivante :
e e
C et I
f f
Si on écrit les relations qui caractérisent les éléments C et I sous la forme :
deC 1
fC = C ou fI = ∫ eI dt
dt I

13
On suppose que e est une donnée pour les éléments C et I, et que f est une conséquence, ce
qui se représente en positionnant le trait causal de la manière suivante :
e e
C et I
f f
Pour des considérations d’ordre numérique et souvent physique (il est plus aisé et plus robuste
d’intégrer que de dériver)[4], on essaiera d’affecter aux éléments C et I une causalité dite
« intégrale » associée à une loi de type intégrale.

3. Eléments de jonction
a. Jonction 0
Considérons l’exemple suivant : e3 f3
Les relations caractéristiques s’écrivent : e1 e4
e1 = e2 = e3 = e4 0
f1 f4
f1 + f2 - f3 - f4 = 0
e2 f2
Supposons que e2 est connu ; nous pouvons écrire :
e1 = e2 ; e3 = e2 ; e4 = e2
Ce qui conduit à positionner les traits causaux de la manière suivante :

e3 f3
e1 e4
0
f1 f4
e2 f2

Ce qui conduit à la règle suivante :

« Un seul trait causal près de la jonction 0 »

b. Jonction 1
Considérons l’exemple suivant :
Les relations caractéristiques s’écrivent :
f1 = f2 = f3 = f4 e3 f3
e1 + e2 - e3 - e4 = 0 e1 e4
Le raisonnement est le même que pour la jonction 0. Un seul flux 1
f1 f4
donne sa valeur aux autres. Supposons que ce soit f3, nous pouvons
écrire : e2 f2
f1 = f3 f2 = f3 f4 = f3
Ce qui conduit à écrire : e3 = e1 + e2 – e4 et donne le bond-graph causal :

e3 f3
e1 e4
1
f1 f4
e2 f2

14
La règle d’affectation de la causalité est ici :
« Un seul lien sans trait causal prés de la jonction 1 ».
c. Jonction TF
Les relations caractéristiques d’un TF s’écrivent, si e2 et f1 sont connus, sous la forme :
e1 = m e2
f2 = m f1
Ou, si e1 et f2 sont connus,
e2 = (1/m)e1
f1 = (1/m)f2
Ce qui donne les deux bond-graphs causaux
e2 e1
TF
.. TF
..
m m
f1 f2

La règle d’affectation de la causalité peut s’écrire :

« Un seul trait causal prés du transformateur »

d. Jonction GY
Nous avons deux possibilités d’affectation de la causalité. Si les flux sont connus, alors les
relations caractéristiques s’écrivent :
e1 = rf2
e2 = rf1
Sinon, lorsque les efforts sont connus, les relations deviennent :
f2 = (1/r)e1
f1 = (1/r)e2
e1 e2
GY GY
.. ..
r r
f1 f2
La règle de l’affectation de la causalité peut s’écrire :

« Pas de trait causal ou 2 traits causaux près du GY »

V. Propriétés causales d’un Bond-Graph


1. Chemin causal
Un chemin causal dans une structure de jonction bond graph est une alternance de liens
et d’éléments de base [7], appelés ici « noeuds », telle que :
 Tous les noeuds ont une causalité complète et correcte ;
 Deux liens du chemin causal ont en un même noeud des orientations causales
opposées.

15
a. Chemin causal simple
Chemin causal est simple s’il est parcouru en suivant toujours la même variable. Il
existe donc dans une même séquence de liens et de noeuds, deux chemins en suivant soit
l’effort, soit le flux, comme le montre la figure suivante.

Figure 1.6 chemin causal simple

b. Chemin causal mixte


Un chemin causal est mixte si son parcours comporte un gyrateur imposant le
changement de variable suivie.

Figure 1.7 chemin causal mixte


Un chemin causal est mixte indirect s’il passe par un élément passif R, I ou C.

Figure 1.8 chemin causal mixte et indirect

2. Boucle causale
Une boucle causale est un chemin causal fermé entre deux éléments passifs sans lien
parcouru en suivant la même variable plus d’une fois [10].

Figure 1.9 boucle causale

3. Boucle de causalité
Une boucle de causalité est une succession de jonctions et de liens formant un cycle,
pour lesquels la causalité est orientée dans le même sens sur tous les liens (sauf en présence
d’un GY).

16
1 f

0 f 0
f
1 f

Figure 1.10 boucle de causalité

4. Chaîne d’action
Une chaîne d’action est un chemin causal entre une source et une sortie ou un détecteur.
Remarque :
Deux boucles causales sont disjointes s’elles n’ont aucun lien en commun parcourus
en suivant le même type de variable.

5. Gain des éléments R, C, I


Dans le cas linéaire, la relation entre la variable d’entrée et la variable de sortie d’un
élément R, C, I peut s’écrire sous forme symbolique en utilisant l’opérateur de Laplace s
associé à la dérivation par rapport au temps ou son inverse 1/s associé à l’intégration par
rapport au temps [8].
On appelle gain d’un élément le rapport entra sa variable de sortie et sa variable
d’entrée exprimée sous forme symbolique. Ainsi :
a. Elément C en causalité intégrale :
1
Loi élémentaire : e =
C
∫ fdt e
1 C
Soit : E(s) = F ( s) f
Cs
Le gain de l’élément C en causalité intégrale : 1/Cs.
b. Elément C en causalité dérivée :
de
Loi élémentaire : f = C e
dt C
Soit: F(s) = Cs E(s) f
Le gain de l’élément C en causalité dérivée : Cs
De même on a :

17
Tableau 1.2 : gain des éléments passifs

6. Gain d’un chemin causal ou d’une boucle causale [13]


 Pour les chemins causaux simples ou mixtes directs :

 Pour les chemins causaux mixtes indirects :

 Pour les boucles causales

Dans lesquelles :
- n0 : nombre de changements d’orientation aux jonctions 0 quand on suit la variable flux.
- n1 : nombre de changements d’orientation aux jonctions 1 quand on suit la variable effort.
- mi : module de l’élément TFi traversé avec ki = ± 1 suivant le type de causalité appliquée
au transformateur.
- rj : module de l’élément GYj traversé avec Ij = ± 1 suivant le type de causalité appliquée
au gyrateur.
- ge : gain de l’élément passif.

VI. Matrice de transfert


Dans le cas où le système est supposé linéaire, la règle de Mason appliquée au modèle
bond graph permet d’obtenir directement toute matrice de transfert.

Règle de Mason [9]


Si on note y (t ) et u (t ) respectivement la sortie et l’entrée du système, alors la
transmittance entrée-sortie est définie sous forme symbolique par la relation (en notant s
l’opérateur de Laplace) :

Υ (s )
∑ T (s )D (s )
k k
= k

U (s ) D (s )

18
Où :

• Tk (s ) est le gain du k-iéme chemin direct liant la sortie à l’entrée.

• D(s ) est le déterminant du bond-graph et se calcule par :


D(s ) =1 − ∑ B j (s ) + ∑ B j (s )Bk (s ) − ∑ B j (s )Bk (s )Bl (s ) + ...
j j ,k j , k ,l

Où les B j (s ) représentent les gains des boucles causales du système, intervenant


lorsqu’elles sont disjointes en produit 2 à 2 puis 3 à 3 (…etc…).
• Le calcul de Dk (s ) est le même que celui de D(s ) , avec la condition supplémentaires
que les boucles causales retenues pour le calcul ne doivent pas toucher la chaîne
d’action.

Exemple :

Considérons le bond-graph suivant du schéma électrique.

Figure 1.11 Schéma électrique (a) son modèle Bond-graph associé (b)
U C (s)
On veut déterminer la fonction de transfert H ( s) = entre la tension appliquée au
U ( s)
circuit et la tension aux bornes du condensateur. Pour cela cherchons les boucles causales qui
existent dans ce modèle Bond-graph et leur gain.

Ces deux boucles ne sont pas disjointes. La valeur de D(s) est alors :
R 1
D(s) = 1 − ( − )
Ls LCs 2
Une seule chaîne d’action lie la source à la sortie, mais indirectement par l’intermédiaire des
éléments L et C.

19
E
Se 1 I 1 C

1/Ls 1/Cs

Le gain de la chaîne d’action vaut : T1 (s ) = (n0 = n1 = 0)


1
LCs 2
Il n’y a pas de boucle causale qui ne touche pas la chaîne d’action, donc D1 (s ) = 1
On en déduit la fonction de transfert :

20
Chapitre 2

CAUSALITE ET INFORMATIONS CAUSALES

Au cours de ce chapitre, nous donnons un bref rappel sur l’affectation de la causalité


aux éléments et aux jonctions d’un modèle Bond–graph. Ensuite, nous présentons la méthode
que nous avons élaborée dans le cadre de notre mémoire de DESA. Nous donnons ici, un
algorithme et une démarche originale pour permettre d’affecter la causalité à un bond-
graph.

Nous proposons également des algorithmes optimaux pour permettre d’exploiter un


bond-graph causal, afin d’en extraire tout type d’information causale : ses chemins causaux
directs, ses chemins causaux indirects, ses boucles causales,…

I. Affectation de la causalité
1. Rappels
La notion de causalité joue un rôle important dans la théorie des bond-graphs, elle
constitue l’un des facteurs, nécessaires pour modéliser un système dynamique et à analyser sa
structure [12]. Son affectation correspond à la construction d’une série de décisions reflétant,
pour chaque élément la relation de cause à effet.

e e

A B A B
f f

Figure 2.1 : Signification du trait causal

L’affectation de la causalité à un bond-graph acausal doit respecter un certain nombre


de règles conventionnelles. La table 2.1 présente tous les cas possibles de l’affectation causale
pour un élément bond-graph.

Causalité Se Sf
obligatoire

Causalité TF ou TF
restreinte
GY ou GY

21
Causalité
restreinte ou ou

0 0 0

ou ou

1 1 1

Causalité C I
intégrale

Causalité C I
dérivée

Causalité R ou R
arbitraire (linéaire)
Table 2.1 : causalité des éléments de base d’un bond-graph

2. Procédure d’affectation de la causalité


L’algorithme suivant retrace les grandes lignes des étapes suivies pour affecter la
causalité.

{Procédure générale de l’affectation de la causalité}

 Affecter la causalité aux sources, et répercuter sur l’environnement en


respectant les restrictions de la causalité.
 Mettre tous les I et tous les C en causalité intégrale, et affecter la
causalité obligatoires sur les R non linéaires ; répercuter sur
l’environnement.
 Affecter les causalités aux jonctions 0, 1, TF, GY.
 Affecter les causalités aux éléments R linéaires en fonction des
possibilités restantes.

On donnera par la suite l’algorithme détaillé de chaque étape. Et à la fin, on donnera un


exemple applicatif afin de faciliter la compréhension de notre démarche.

Algorithme 2.1 : affectation de la causalité aux sources

{Affectation de la causalité aux sources}

Etape 1 : les sources d’effort Se

Début
Pour chaque Se faire

22
Lui affecter une causalité sortante
Si cette Se se trouve dans une jonction de 1 alors
Si le nombre de connexions de cette jonction est 2 alors
Si le nombre de connexions entrantes est égal à 2 alors
La jonction contient un conflit causal
Sinon
Affecter une causalité sortante à cette connexion
Fin si
Fin si
Fin si
Si cette Se se trouve dans une jonction de 0 alors
Si le nombre de connexions entrantes est égal à 2 alors
La jonction contient un conflit causal
Affecter une causalité sortante aux autres connexions
Sinon
Affecter une causalité sortante aux autres connexions
Fin si
Fin si
Fait
Fin

Etape 2 : les sources de flux Sf

Début
Pour chaque source d’effort Sf faire
Lui affecter une causalité entrante
Si cette source Sf se trouve dans une jonction de 0 alors
Si le nombre de connexions de cette jonction est 2 alors
Si le nombre de connexions sortantes est égal à 2 alors
La jonction contient un conflit causal
Sinon
Affecter une causalité entrante à cette connexion
Fin si
Fin si
Fin si

Si cette source Sf se trouve dans une jonction de 1 alors


Si le nombre de connexions sortantes est égal à 2 alors
La jonction contient un conflit causal
Affecter une causalité entrante aux autres connexions
Sinon
Affecter une causalité entrante aux autres connexions

23
Fin si
Fin si
Fait
Fin

Algorithme 2.2 : affectation de la causalité aux éléments C

{Affectation de la causalité aux éléments C}

Début

Pour chaque élément C faire


Si on n’a pas encore affecté la causalité à ce C alors

Si ce C se trouve dans une jonction de type 1 alors


Si le nombre de connexions entrantes est égal au nombre de
connexion – 1 alors
Affecter une causalité dérivée à cet élément C
Sinon
Affecter une causalité intégrale à cet élément C
Fin si
Fin si

Si cet élément C se trouve dans une jonction de type 0 alors


Si le nombre de connexions entrantes est égal à 1 alors
Affecter une causalité dérivée à cet élément C
Affecter une causalité entrante aux autres connexions
Sinon
Affecter une causalité intégrale à cet élément C
Affecter une causalité entrante aux autres connexions
Fin si
Fin si
Fin si
Fait

Fin

Algorithme 2.3 : affectation de la causalité aux éléments I

{Affectation de la causalité aux éléments I}

Début

Pour chaque élément I faire


Si on n’a pas encore affecté la causalité à cet I alors
Si cet élément I se trouve dans une jonction de type 0 alors
Si le nombre de connexions sortantes est égal au nombre de

24
connexion – 1 alors
Affecter une causalité dérivée à cet élément I
Sinon
Affecter une causalité intégrale à cet élément I
Fin si
Fin si

Si cet élément I se trouve dans une jonction de type 1 alors


Si le nombre de connexions sortantes est égal à 1 alors
Affecter une causalité dérivée à cet élément I
Affecter une causalité entrante aux autres connexions
Sinon
Affecter une causalité intégrale à cet élément I
Affecter une causalité entrante aux autres connexions
Fin si
Fin si
Fin si
Fait
Fin

Algorithme 2.4 : affectation de la causalité aux jonctions 1

{Affectation de la causalité aux jonctions 1}

Début

Pour chaque jonction de type 1 faire


Si le nombre de connexions sortantes est égal à 0 alors
Parcourir les connexions de cette jonction
S’il s’agit d’une connexion dont on n’a pas encore affectée la
causalité alors
Affecter une causalité sortante à cette connexion.
Affecter une causalité entrante aux autres connexions.
Fin si
Fin si
Fait

Fin

Algorithme 2.5 : affectation de la causalité aux jonctions 0

{Affectation de la causalité aux jonctions 0}

Début

25
Pour chaque jonction de type 0 faire
Si le nombre de connexions entrantes est égal à 0 alors
Parcourir les connexions de cette jonction
S’il s’agit d’une connexion dont on n’a pas encore affectée la
causalité alors
Affecter une causalité entrante à cette connexion
Affecter une causalité sortante aux autres connexions
Fin si
Fin si
Fait
Fin

Algorithme 2.6 : affectation de la causalité aux éléments R

{Affectation de la causalité aux éléments R}

Début

Pour chaque élément R faire


Si je n’ai pas encore affecté la causalité à ce R alors
Si ce R se trouve dans une jonction de type 1 alors
Si le nombre de connexions sortantes est égal à 1 alors
Affecter une causalité sortante à ce R
Sinon
Affecter une causalité entrante à ce R
Fin si
Fin si

Si ce R se trouve dans une jonction de type 0 alors


Si le nombre de connexions entrantes est égal à 1 alors
Affecter une causalité entrante à ce R
Sinon
Affecter une causalité sortante à ce R
Fin si
Fin si
Fin si
Fait
Fin

3. Exemple
Reprenons l’exemple du système électrique de la figure 1.3 :

26
Figure1.2 Schéma électrique (a) son modèle Bond-graph associé (b)

Appliquons l’algorithme précédent sur cet exemple :

Etape 1 :
Application de la causalité
au sources Se et Sf

Etape 2 :

Affectation de la causalité
aux éléments I et
répercussion sur
l’environnement

27
Etape 2 (suite)
Affectation de la causalité
aux éléments I et
répercussion sur
l’environnement

II. Informations causales

Après la phase de l’affectation de la causalité, nous pouvons entamer celles de la


modélisation et de l’analyse structurelle. Du point de vue pratique, on commence par explorer
le modèle Bond-graph et extraire les informations sur ses chemins causaux, ses boucles
causales. Ceci va nous permettre, par application d’un certain nombre de méthodes,
d’atteindre les objectifs escomptés.
Dans cette section, nous allons présenter les algorithmes qui permettent de trouver les
chemins causaux directs et indirects ainsi que toutes les boucles causales.

1. Algorithme de la recherche des chemins causaux


Rappelons qu’un chemin causal direct est une séquence d’alternance de liens et de
jonctions liant, selon l’orientation causale, un élément X de type {Se, Sf, I, C, R} à un
élément Y de type {I, C, R}. L’algorithme suivant présente une démarche permettant de
déterminer les chemins directs d’un modèle Bond graph donné.

pile1 contient la liste des jonctions qu’on doit traiter


listeTF liste des transformateurs par lesquels passe le chemin
listeGY liste des gyrateurs par lesquels passe le chemin
causalite_rechercher stocke le type de causalité recherché
eltS et eltE contiennent la liste des éléments qui correspondent au type
de causalité recherché
Jcourant la jonction au cours de traitement

Début

Pour chaque jonction faire


{Recherche des éléments et des jonctions ayant une causalité
sortante}

28
Pour chaque connexion de cette jonction faire
Si le type de la connexion est (R, I, C, Se, Sf) alors
S’il s’agit d’une connexion sortante alors
Ranger l’identificateur de cet élément dans eltS
Sinon
Ranger l’identificateur de cet élément dans eltE
Fin si
Fin si
S’il s’agit d’une jonction de type 0 ou 1 et ayant une connexion
sortante alors
Empiler l’identificateur de cette jonction dans pile1
Fin si
Fait
{Recherche des chemins internes}
Parcourir les tableaux EltE et EltS et sauvegarder les chemins
internes trouvés.
{Recherche des chemins causals directs}
Vider eltE
causalite_rechercher ← sortante
Tant que pile1 n’est vide faire
Jcourant ← dépiler (pile1)
Si Jcourant n’est pas marqué alors
Marquer Jcourant
Si listeGY n’est pas vide alors
Vérifier pour chaque élément de listeGY si on passe
toujours par ce gyrateur
Fin si
Si listeTF n’est pas vide alors
Vérifier pour chaque élément de listeTF si on passe
toujours par ce transformateur
Fin si
S’il s’agit d’une connexion qui passe par un gyrateur alors
Empiler l’identificateur de gyrateur dans listeGY
Inverser causalite_rechercher
Fin si
S’il s’agit d’une connexion qui passe par un transformateur
alors
Empiler l’identificateur de ce transformateur dans listeTF
Fin si
Pour chaque connexion de Jcourant faire
S’il s’agit d’élément de type (R, I, C, Se, Sf) qui a une
causalité de type causalite_rechercher alors

29
Ranger l’identificateur de cet élément dans eltE
Fin si
S’il s’agit d’une jonction de type (0 ou 1) et qui a une
causalité de type causalite_rechercher alors
Empiler l’identificateur de cette jonction dans pile1
Fin si
Fait
Parcourir eltE et enregistrer les chemins directs trouvés
Sinon
Enregistrer la boucle de causalité trouvée
Fin si
Fait
Fait

Fin
Algorithme 2.7 : recherche des chemins directs

Remarque
Par convention, la variable suivie par un chemin direct est l’effort.

Exemple
Considérons le système électrique suivant :

Figure2.2 Schéma électrique (a) son modèle Bond-graph associé (b)

Le résultat de l’application de l’algorithme précédent permet de dégager quatre chemins :


• Entre Se et L :
e e
Se 1 I:L

• Entre R et L :
e e
R : R1 1 I:L

• Entre Cet R2 :
e e
C 0 R : R2

30
• Entre L et C :
e e e
I:L 1 0 C

2. Algorithme recherche chemin indirect


Un chemin causal indirect peut être considéré comme étant une combinaison d’au moins
deux chemins causaux directs. Donc, pour rechercher un chemin indirect entre deux éléments
E et S on suit la démarche suivante :

{Recherche des chemins causaux indirects}


E l’entrée désirée.
S la sortie désirée.
pile1 contient la liste des éléments passifs par lesquels passe le chemin
indirect.
pile2 contient la liste des chemins directs qui composent le chemin
indirect.
pileCCD contient la liste de chemins direct dont une extrémité est égale à
E.
pileExt l’autre extrémité des chemins directs dont une extrémité est
égale à E.
pile3 contient la liste des chemins direct à traiter.
pile4 contient l’autre extrémité des chemins directs à traiter.
extCourant représente l’extrémité en cours de traitement.
ccdCourant l’identificateur du chemin direct en cours du traitement.
Pour chaque chemin direct faire
Si les deux extrémités du chemin coïncident avec E et S alors
Ranger l’identificateur du chemin dans nonValide
Fin si
Fait
Pour chaque chemin direct faire
Si ce chemin possède une extrémité qui coïncide avec E alors
Empiler dans pileCCD l’identificateur de ce chemin
Empiler dans pileExt l’autre extrémité du chemin
Fin si
Fait
extCourant ← lire(pileExt)
ccdCourant ← lire(pileCCD)
Dépiler(pileExt)
Dépiler(pileCCD)
Vider(pile3)
Vider(pile4)
Tant que pile3 est non vide faire
Pour chaque chemin direct faire
Si ce chemin possède une extrémité qui coïncide avec extCourant
alors
Si l’autre extrémité coïncide avec S alors
Sauvegarder le chemin indirect

31
Sinon
Empiler le numéro de ce chemin dans pile3
Empiler l’autre extrémité de ce chemin dans pile4
Fin si
Fin si
Fait
S’il n’existe pas de chemins dont l’extrémité est égale à extCourant
alors
Dépiler(pile1)
Dépiler(pile2)
Sinon
Empiler dans pile1 ccdCourant
Empiler dans pile2 extCourant
Fin si
extCourant ← lire(pile4)
ccdCourant ← lire(pile3)
Dépiler(pile3)
Dépiler(pile4)
Fait
Algorithme 2.8 : recherche des chemins indirects

Considérons, à titre d’exemple, le système électrique (figure 2.2), cherchons s’il existe
un chemin indirect entre Se et C. L’application de l’algorithme permet d’estimer qu’il existe 1
chemin indirect entre Se et C et qui passe par I et par les liens : 1-2-2-4-5 comme le montre la
figure suivante :

Figure 2.3 chemin indirect entre Se et C

3. Algorithme recherche boucle causale


Une boucle causale entre deux éléments X-Y de type {I,C,R} est formée à partir des
combinaisons des parcours, pris 2 à 2, des différents chemins causaux directs liant X à Y.
Il en résulte qu’une boucle causale possède un parcours « aller » et un parcours
« retour ». Ils ne représentent pas forcément le même chemin causal direct. Ainsi, si n est le
nombre de chemins causaux directs, liant deux éléments quelconques, n x n est celui des
boucles causales disponibles. Voici l’algorithme permettant la détermination des boucles
causales d’un modèle Bond Graph.

Pour chaque chemin causal direct faire


Si les deux extrémités d’un chemin sont soit : R, I, C alors
Marquer ce chemin comme chemin valable.

32
Fin Si
Fait
Pour chaque chemin direct valable faire
Si les 2 extrémités du chemin n’ont pas été traitées alors
o Chercher tous les chemins ayant les mêmes extrémités
o Sauvegarder toutes les boucles causales formées à partir de
toutes les combinaisons possibles des chemins causaux trouvés.
o Marquer ces 2 extrémités comme extrémités traitées.
Fin Si
Fait
Algorithme 2.9 : recherche des boucles causales

L’application de l’algorithme sur le système électrique de la figure 2.2, permet


d’estimer qu’il existe 3 boucles causales :
• Entre R et L :
e e
R : R1 1 I:L
f f

• Entre Cet R2 :
e e
C 0 R : R2
f f

• Entre L et C :
e e e
I:L 1 0 C
f f f

4. Calcul du gain d’un chemin direct


Rappelons que le gain d’un chemin direct est donné par la relation suivante :

Avec :
- n0 : nombre de changements d’orientation aux jonctions 0 quand on suit la variable flux.
- n1 : nombre de changements d’orientation aux jonctions 1 quand on suit la variable effort.
- mi : module de l’élément TFi traversé avec ki = ± 1 suivant le type de causalité appliquée
au transformateur.
- rj : module de l’élément GYj traversé avec Ij = ± 1 suivant le type de causalité appliquée
au gyrateur.

L’algorithme suivant donne la démarche suivie pour calculer le gain d’un chemin direct
donné.

33
Gain ← 1
Pour chaque chemin direct faire
Parcourir la liste des transformateurs par lesquels passe le chemin
Si la causalité du TF est de type ‘SE’ alors
Gain ← Gain * m
Sinon
Gain ← Gain * 1/m
Fin Si
Parcourir la liste des gyrateurs par lesquels passe le chemin
Si la causalité du GY est de type ‘SS’ alors
Gain ← Gain * r
Sinon
Gain ← Gain * 1/r
Fin Si
{Calcul du signe du chemin causal}
Si le parcours est de type flux alors
n0 ← 0
Fin si
Parcourir les liens par lesquels passe le chemin deux à deux
Si les deux liens appartiennent à une jonction de type 0 et il
y a un changement d’orientation dans les demi-flèches alors
n0 ← n0 + 1
Fin si
Signe ← (-1)n0
Si le parcours est de type effort alors
n1 ← 0
Fin Si
Parcourir les liens par lesquels passe le chemin deux à deux
Si les deux liens appartiennent à une jonction de type 1 et il
y a un changement d’orientation dans les demi-flèches alors
n1 ← n1 + 1
Fin Si
Signe ← (-1)n1
Gain ← Gain * Signe
Fait
Algorithme 2.10 : calcul du gain d’un chemin direct

Reprenons le système électrique de la figure 2.2, appliquons l’algorithme sur le chemin qui
existe entre R et L.
e e
R : R1 1 I:L n1 = 1

Le gain du chemin est égal à : -1

34
5. Calcul du gain d’un chemin indirect
Le gain d’un chemin direct est égal au produit des gains des chemins directs qui le
composent et des gains des éléments passifs traversés. Donc, pour calculer le gain d’un
chemin indirect, on suit les étapes suivantes :

Gain ← 1
Pour chaque chemin direct composant ce chemin indirect faire
Calculer le gain du chemin direct : gc
Gain ← Gain * gc
Fait
Pour chaque élément passif composant ce chemin faire
Calculer leur gain correspondant ge et cela suivant leur causalité
Fait
Gain ← Gain * ge
Algorithme 2.11 : calcul du gain d’un chemin indirect

Reprenons l’exemple du système électrique de la figure 2.2, appliquons l’algorithme pour


calculer le gain du chemin indirect entre Se et C. on trouve alors :
1
Gain = (n 0
= n1 = 0 )
LCs 2

6. Calcul du gain d’une boucle causale


Le gain d’une boucle causale entre deux éléments X et Y est égal au produit des gains
de son parcours d’aller et de son parcours retour, multiplié par les gains de X et de Y. Donc,
pour calculer le gain d’une boucle, on suit la démarche suivante :

Calculer le gain du parcours d’aller : ga


Calculer le gain du parcours de retour : gr
Calculer le gain des deux extrémités de la boucle : ge
Gain ← ga * gr * ge
Algorithme 2.12 : calcul du gain d’une boucle causale

7. Chemins et boucles disjoints


a. Cas de deux chemins directs
Deux chemins directs sont dits disjoints, s’ils ne possèdent aucun lien en commun
parcourus en suivant le même type de variable. Donc, pour trouver les chemins disjoints, on
suit les étapes suivantes :
On suppose que les deux chemins sont disjoints.
On commence par le chemin ayant le minimum de liens.
On parcourt la liste des liens de ce chemin :

Pour chaque lien faire


Si on trouve que ce lien figure dans la liste des liens du deuxième
chemin et on suit la même variable alors

35
On arrête le traitement et les deux chemins sont non disjoints
Fin Si
Fait

Algorithme 2.13 : recherche des chemins disjoints

b. Boucles disjointes
La recherche des boucles disjointes passe par les étapes suivantes :
On suppose que les deux boucles sont disjointes
On prend le chemin d’aller de la première boucle :
On le compare avec les chemins d’aller et de retour de la deuxième boucle
Si on trouve qu’il existe des chemins non disjoints alors
On arrête le traitement et les deux boucles sont non disjointes
Sinon
On refait la même chose pour le chemin de retour.
Fin si

Algorithme 2.14 : recherche des boucles disjointes

8. Calcul de la fonction de transfert


Pour calculer la fonction de transfert du système, nous appliquons la règle de Mason.
Pour cela l’utilisateur doit préciser l’entrée et la sortie de son système. Ensuite, il suffit de
suivre l’algorithme suivant :

E l’entrée du système
S la sortie du système
Chercher les boucles causales de votre système et calculer leurs gains
Chercher les boucles disjointes
Calculer D(s)
Chercher s’il existe un chemin direct entre E et S, sinon chercher un
chemin indirect
Calculer Dk(s)

Algorithme 2.15 : calcul de la fonction de transfert

Une fois qu’on a déterminé les informations causales d’un modèle Bond-graph
(chemins et boucles causales, boucles disjointes), on peut calculer les modèles mathématiques
sous forme d’expressions formelles [11].

36
Chapitre 3

ANALYSE ET CONCEPTION INFORMATIQUE

Au cours de ce chapitre, on abordera la partie conception et plus précisément le


diagramme de classe de l’application ainsi qu’une description détaillée des classes utilisées.

I. Conception de l’application

La méthode de conception utilisée est UML (Unified Modeling Language ou Langage


de Modélisation Unifié). Il s’agit d’un langage de modélisation orienté objet permettant de
modéliser un problème de façon standard. Elle permet ainsi une représentation claire et
précise, sous forme de modèle objet de n’importe quel problème. En tant que tel, il facilite la
création et la compréhension des logiciels actuels.

1. Diagramme de classes
L’analyse du problème nous a permis de dégager 12 classes. Le diagramme de classes
suivant permet de visualiser les relations inter-classes de notre système d’information. Nous
verrons, par la suite, comment nous avons procédé pour aboutir à ce diagramme.

37
Figure 3.1 diagramme de classes de l’application

2. Description des classes utilisées


a. Classe Modèle Bond Graph Modèle BG
Id
Les actions qu’on peut effectuer sur la classe Modèle Bond Nom
Source
Graph : TypeCausalité
- Ajouter un modèle calculerId
Ajouter
- Supprimer un modèle
Modifier
- Modifier un modèle Supprimer
- Lister tous les modèles Lister
- Affecter la causalité. Affecter causalité
Supprimer causalité
Inverser causalité

38
- Supprimer la causalité.
- Inverser la causalité.
Attributs de la classe Bond Graph
- Id : identificateur du modèle Bond Graph
- Nom : le nom du modèle Bond Graph.
- Source : source du modèle Bond Graph.
- TypeCausalité : cet attribut permet d’indiquer le type de la causalité affectée au
modèle Bond Graph. Il peut prendre les valeurs suivantes :
 A : sil s’agit d’un modèle acausal.
 I : si la causalité affectée aux éléments I et C est intégrale.
 D : si la causalité affectée aux éléments I et C est dérivée.
Méthodes / Attributs
- Calculer identificateur.
Les acteurs
- L’utilisateur.
Schéma contexte :
Afin de construire le graphe de contexte de la classe « Modèle Bond graph », nous
allons identifier l’ensemble des classes ayant une relation avec celle-ci.

Modèle BG

Modèle
Modèle physique
mathématique
Jonction Lien

b. Classe Modèle physique


Les actions qu’on peut effectuer sur la classe Modèle physique : Modèle phy
- Ajouter un modèle Id
Domaine
- Supprimer un modèle Description
- Modifier un modèle calculerId
- Consulter un modèle Ajouter
Modifier
Attributs de la classe physique Supprimer
- Id : identificateur du modèle. Consulter
- Domaine : le(s) domaine(s) au(x) quel(s) appartient le modèle.
- Description : description du modèle physique.
Méthodes / Attributs
- Calculer identificateur.
Les acteurs

39
- L’utilisateur.
Schéma contexte :

Afin de construire le graphe de contexte de la classe « Modèle physique », nous allons


identifier l’ensemble des classes ayant une relation avec celle-ci.

Modèle physique Modèle Bond Graph

c. Classe Jonction
Les actions qu’on peut effectuer sur la classe Jonction : Jonction
Action qui interviennent au niveau de la couche des données Id
Type
- Ajouter une jonction
Module
- Modifier une jonction Conflit causal
- Supprimer une jonction Ajouter
- Lister toutes les jonctions Modifier
Lister
Attributs de la classe Jonction Supprimer
Calcule id
- Identifiant Calculer module
- Type : 0, 1, TF, GY.
- Module : r pour un gyrateur et m pour un transformateur
- Conflit causal : variable qui détermine si la jonction possède un conflit causal. Elle
peut prendre les valeurs :

• 0 : pas de conflit causal.


• 001 : jonction 0 : pas de lien entrant.
• 010 : jonction 0 : plusieurs liens entrants.
• 011 : jonction 1 : pas de lien sortant.
• 100 : jonction 1 : plusieurs liens sortant.
• 101 : erreur de causalité dans la jonction TF.
• 110 : erreur de causalité dans la jonction GY.

Méthodes / Attributs
- Attribuer un identifiant
- Calculer module
Remarques particulières :
- TF, GY ne possèdent pas d’éléments.
- Dans une jonction 0 on a : Σfi = 0 et e1 = e2 = …=en
- Dans une jonction 0 on a un seul élément avec une causalité entrante sinon on a un
conflit causal.
- Dans une jonction 1 : Σei = 0 et f1 = f2 = …=fn
- Dans une jonction 1 on a un seul élément avec une causalité sortante sinon on a un
conflit causal.
Les acteurs
- L’utilisateur.
Schéma contexte :

40
Afin de construire le graphe de contexte de la classe « Jonction », nous allons identifier
l’ensemble des classes ayant une relation avec celle-ci.

Elément Jonction Modèle BG

Lien

Diagramme d’état
La classe Jonction admet deux états : normal (absence d’un conflit causal) ou ayant un
conflit causal. Le diagramme d’état suivant, montre les états potentiels de la classe Jonction
et les transitions d’un état à un autre.

Affecter la causalité

Jonction
‘conflit causal’ Conflit non résolu

Ajout d’un élément


Modifier la causalité des
éléments de la jonction

Conflit résolu
Modifier la causalité de
la jonction

d. Classe lien

Les actions qu’on peut effectuer sur la classe Lien :


Lien
- Ajouter un lien Id
- Modifier un lien Dim
Causalité
- Consulter un lien Ajouter
- Supprimer un lien Modifier
Lister
Attributs de la classe Lien Supprimer
- Id : identificateur du lien. Calculer Id
- Dim : la dimension du lien : Affecter causalité
• 0 s’il s’agit d’un :
• 1 s’il s’agit
• N dans le cas d’un lien multi dimension.
- Causalité :
• 1 si le lien a la forme suivante

41
• 0 si le lien a la forme suivante
Méthodes / Attributs
- Calculer id.
- Affecter la causalité.
Les acteurs
- L’utilisateur.
Schéma contexte :
Afin de construire le graphe de contexte de la classe « Lien », nous allons identifier
l’ensemble des classes ayant une relation avec celle-ci.

Modèle Bond
Graph

Lien Élément

CCD
Jonction

Diagramme d’état
La classe lien admet deux états : causal ou acausal. Le diagramme d’état suivant, montre les
états potentiels de la classe lien et les transitions d’un état à un autre.
Acausal

Lien
Causal

Affecter la causalité
Acausal Causal
Supprimer la causalité

e. Classe élément
Les actions qu’on peut effectuer sur la classe élément :

42
- Ajouter un élément Elément
- Modifier un élément Id
- Supprimer un élément Gain
- Lister tous les éléments N° lien
Type
Attributs de la classe Jonction Ajouter
Modifier
- Id : identificateur. Supprimer
- N° du lien Lister
- Type : type de l’élément : R, C, L, SE, SF. Calcule id
- Gain Calculer gain

Méthodes / Attributs
- Attribuer un identifiant
- Calculer gain
Remarques particulières :
- Se et Sf possèdent une causalité obligatoire.
- R, C, I possèdent une causalité préférentielle.
Les acteurs
- L’utilisateur.
Schéma contexte :
Afin de construire le graphe de contexte de la classe « Elément », nous allons identifier
l’ensemble des classes ayant une relation avec celle-ci.

Lien Élément Jonction

Modèle BG

f. Classe CCD (Chemin Causal Direct)

Les actions qu’on peut effectuer sur la classe CCD : CCD


Id
- Calculer Id
Ext1
- Ajouter un CCD. Ext2
- Modifier un CCD. Liste TF
- Supprimer un CCD. Liste GY
- Lister touts les CCD. ListeLien
ListeVar
ListeOrient
Attributs de la classe CCD BCL_causalité
- Id : un numéro identifiant le chemin causal direct. Gain
- Ext1 : extrémité 1 du chemin. Calcule Id
Ajouter
- Ext2 : extrémité 2 du chemin. Modifier
- ListeTF : contient la liste des transformateurs par lesquels le Supprimer
chemin causal direct passe. Lister
- ListeGY : contient la liste des gyrateurs par lesquels le chemin Calculer gain
causal direct passe.

43
- ListeLien : liste des liens qui composent le chemin causal.
- ListeVar : la liste des variables suivies pour chaque lien (effort ou flux).
- ListeOrient : la liste des orientations des liens par rapport aux éléments. Elle peut
prendre les valeurs :
 R si le lien a l’orientation suivante : Elément
 L si le lien a l’orientation suivante : Elément
- BCL_causalité : variable booléenne qui prend « vrai » s’il s’agit d’une boucle de
causalité sinon « faux » dans le cas contraire.
- Gain : gain du chemin.
Méthodes / Attributs
- Attribuer un identifiant.
- Calculer le gain
- Lire la liste des transformateurs qui composent le chemin direct.
- Lire la liste des gyrateurs par lesquels le chemin direct passe
- Lire la liste des liens qui composent le chemin.
Schéma contexte :
Afin de construire le graphe de contexte de la classe « CCD », nous allons identifier
l’ensemble des classes ayant une relation avec celle-ci.

CCD
Boucle causale
Lien

CCI Modèle mathématique

g. Classe CCI (Chemin Causal Indirect)


Les actions qu’on peut effectuer sur la classe CCI :
CCI
- Ajouter un CCI. Id
- Modifier un CCI. Ext1
- Supprimer un CCI. Ext2
Liste CCD
- Lister tous les CCI
Liste Elt Pass
Gain
Attributs de la classe CCI Calcule Id
Ajouter
- Id : numéro identifiant le chemin indirect. Modifier
- Ext1 : extrémité 1 du chemin. Supprimer
- Ext2 : extrémité 2 du chemin. Lister
Calculer gain
- ListeCCD : liste des chemins directs qui composent le
chemin causal indirect.
- Liste Elt Pass : liste des éléments passifs par lesquels passe le chemin causal indirect.
- Gain : gain du chemin causal indirect.

Méthodes / Attributs

44
- Attribuer un identifiant.
- Lire la liste des éléments passifs par lesquels le chemin causal indirect passe.
- Lire la liste des chemins directs qui composent le chemin causal indirect.
- Calculer le gain du chemin causal indirect.

Schéma contexte :

Afin de construire le graphe de contexte de la classe « CCI », nous allons identifier


l’ensemble des classes ayant une relation avec celle-ci.

CCD CCI Modèle math

h. Classe Boucle causale


Les actions qu’on peut effectuer sur la classe Boucle Boucle causale
causale : Id
Ext1
- Ajouter une boucle. Ext2
- Modifier une boucle. Chemin aller
- Supprimer une boucle. Chemin retour
- Lister toutes les boucles existantes Gain
BCL_Algébrique
BclDisjointe
Attributs de la classe Boucle
Calcule Id
- Id : numéro identifiant la boucle. Ajouter
- Chemin d’aller. Modifier
Supprimer
- Chemin de retour. Lister
- Ext1 : extrémité 1 de la boucle. Calculer disjoint
- Ext2 : extrémité 2 de la boucle. Calculer gain
- BCL_algébrique : variable booléenne qui prend la valeur
« vrai » s’il s’agit d’une boucle algébrique sinon « faux » dans le cas contraire.
- Gain.
- BclDisjointe : contient la liste des boucles disjointes à cette boucle.
Méthodes / Attributs
- Attribuer un identifiant.
- Calculer disjoint : calcule les boucles disjointes à cette boucle.
- Calculer le gain d’une boucle causale.
Les acteurs
- L’utilisateur.
Schéma contexte :
Afin de construire le graphe de contexte de la classe « Boucle causale », nous allons
identifier l’ensemble des classes ayant une relation avec celle-ci.

Modèle Math Boucle causale CCD

45
i. Classe Modèle mathématique

Les actions qu’on peut effectuer sur la classe Modèle mathématique :


- Ajouter un modèle. Modèle math
- Modifier un modèle. Id
- Supprimer un modèle. calculerId
Ajouter
Attributs de la classe Modèle mathématique Modifier
Supprimer
- Id : identificateur du modèle.
Méthodes / Attributs
- Calculer l’identificateur.
Les acteurs
- L’utilisateur.
Schéma contexte :
Afin de construire le graphe de contexte de la classe « Modèle mathématique », nous
allons identifier l’ensemble des classes ayant une relation avec celle-ci.

Modèle
mathématique CCI
CCD

Equa-etat
Boucle causale Vecteur MTF

j. Classe Vecteur

Les actions qu’on peut effectuer sur la classe Vecteur: Vecteur


- Ajouter Id
VE
- Modifier VS
- Supprimer calculerId
Ajouter
Attributs de la classe Vecteur
Modifier
- Id : identificateur du modèle Supprimer
- VE : vecteur d’entrée
- VS : vecteur de sortie
Méthodes / Attributs
- Calculer identificateur.
Les acteurs
- L’utilisateur.
Schéma contexte :
Afin de construire le graphe de contexte de la classe « Vecteur », nous allons identifier
l’ensemble des classes ayant une relation avec celle-ci.

46
Vecteur Modèle Math

k. Classe matrice de transfert (MTF)

Les actions qu’on peut effectuer sur la classe MTF :


MTF
- Calcul MTF Id
- Consulter CalculerId
- Supprimer Calcule MTF
Consulter
Attributs de la classe MTF Supprimer
- Id : identificateur de la matrice de transfert
Méthodes / Attributs
- Calculer identificateur.
Les acteurs
- L’utilisateur.
Schéma contexte :
Afin de construire le graphe de contexte de la classe « Matrice de transfert », nous
allons identifier l’ensemble des classes ayant une relation avec celle-ci.

MTF Modèle Math

l. Classe Equation d’état (EquaEtat)

Les actions qu’on peut effectuer sur la classe EquaEtat :


Equat état
- Calcul Equa Id
- Consulter CalculerId
Calcule equa
- Supprimer Consulter
- Calculer équation d’état Supprimer
Attributs de la classe EquaEtat
- Id : identificateur de l’équation
Méthodes / Attributs
- Calculer identificateur.
Les acteurs
- L’utilisateur.
Schéma contexte :
Afin de construire le graphe de contexte de la classe « EquaEtat », nous allons
identifier l’ensemble des classes ayant une relation avec celle-ci.

EquaEtat Modèle Math

47
II. Schéma de fonctionnement

Voici, en ce qui suit, le schéma de fonctionnement de l’application réalisée. Donc, on


peut voir que l’utilisateur peut effectuer les actions suivantes :
 Ajouter un nouveau modèle Bond-graph
 Consulter un modèle Bond-graph
 Modifier la causalité
 Rechercher les chemins causaux (directs et indirects)
 Rechercher les boucles causales
Et chaque action est réalisée par une méthode spécifique, comme indique le schéma suivant :

Figure 3.2 schéma de fonctionnement de l’application

48
Chapitre 4

IMPLEMENTATION INFORMATIQUE

Ce chapitre se consacre à la partie implémentation informatique. On présentera au cours


duquel les outils et les technologies utilisées ainsi qu’un aperçu de l’application réalisée.

I. Outils et technologies

Notre application permet de modéliser des systèmes physiques avec Bond-graph et ceux
à travers une page web. Au cours du processus de développement, on s’est servi des outils
suivants :
 XML
 JAVA
 JSP
On donnera, par la suite, une brève présentation de chacun de ces outils.

1. L’approche XML et la représentation des données


a. Présentation de XML
XML (eXtensible Markup Language ou Langage à balises extensible) a été mis au point
par le XML Working Group sous l'égide du World Wide Web Consortium (W3C). Il est en
quelque sorte un langage HTML amélioré permettant de définir de nouvelles balises.
Contrairement à HTML, qui est considéré comme un langage défini et figé (avec un
nombre de balises limité), XML peut être considéré comme un métalangage permettant de
définir d'autres langages, c'est-à-dire définir de nouvelles balises permettant de décrire la
présentation d'un texte. La force de XML réside dans sa capacité à pouvoir décrire n'importe
quel domaine de données grâce à son extensibilité.
En réalité les balises XML décrivent le contenu plutôt que la présentation
(contrairement À HTML). Ainsi, XML permet de séparer le contenu de la présentation. Ce
qui permet, par exemple, d'afficher un même document sur des applications ou des
périphériques différents, sans pour autant nécessiter de créer autant de versions du document
que l'on nécessite de représentations.

b. Pourquoi XML ?
Nous avons opté pour XML parce qu’il est doté des atouts suivants :

• La lisibilité : aucune connaissance ne doit théoriquement être nécessaire pour


comprendre un contenu d'un document XML
• Une structure arborescente : permettant de modéliser la majorité des problèmes
informatiques
• Universalité et portabilité : les différents jeux de caractères sont pris en compte

49
• Déployable : il peut être facilement distribué par n'importe quels protocoles à même
de transporter du texte, comme HTTP
• Intégrabilité : un document XML est utilisable par toute application pourvue d'un
parser (c'est-à-dire un logiciel permettant d'analyser un code XML)

Ainsi, XML est particulièrement adapté à l'échange de données et de documents.

c. Transposition d’un bond-graph au format XML


Le tableau suivant illustre une représentation XML des éléments de base d’un modèle
Bond-graph.

Eléments Bond-Graph Représentation XML


<?xml version="1.0" encoding="UTF-8"?>
<Elements>
<Element id="" modelBG="" jonction="" lien="">
Eléments passifs simples : R, C, I et
<gain></gain>
les éléments actifs : Se et Sf.
<type></type>
</Element>
</Elements>
<?xml version="1.0" encoding="UTF-8"?>
<Jonctions>
<Jonction id="" modelBG="">
<type></type>
Eléments de jonction : 0, 1, GY, TF
<module></module>
<conflitcausal></conflitcausal>
</Jonction>
</Jonctions>

d. Exemple d’une représentation au format d’un Bong Graph


Reprenons l’exemple électrique de la figure 1.1

Une représentation XML de ce Bond-graph est la suivante :

<?xml version="1.0" encoding="UTF-8"?>


<ModelBGs>
<ModelBG id="1">

50
<nom>circuit 1</nom>
<source>BG1</source>
<typeCausalite>A</typeCausalite>
</ModelBG>
</ModelBGs>
Figure 4.1 exemple du fichier ModelBG.xml

<?xml version="1.0" encoding="UTF-8"?>


<Jonctions>
<Jonction id="1[1]" modelBG="1">
<type>1</type>
<module>no</module>
<conflitcausal>0</conflitcausal>
</Jonction>
<Jonction id="0[1]" modelBG="1">
<type>0</type>
<module>no</module>
<conflitcausal>0</conflitcausal>
</Jonction>
</Jonctions>
Figure 4.5 exemple du fichier Jonction.xml

<?xml version="1.0" encoding="UTF-8"?>


<Elements>
<Element id="Se[1]" modelBG="1" jonction="1[1]" lien="1">
<gain>no</gain>
<type>Se</type>
</Element>
<Element id="I[1]" modelBG="1" jonction="1[1]" lien="2">
<gain>no</gain>
<type>I</type>
</Element>
<Element id="C[1]" modelBG="1" jonction="1[1]" lien="3">
<gain>no</gain>
<type>C</type>
</Element>
<Element id="I[2]" modelBG="1" jonction="0[1]" lien="5">
<gain>no</gain>
<type>I</type>
</Element>
<Element id="C[2]" modelBG="1" jonction="0[1]" lien="6">
<gain>no</gain>

51
<type>C</type>
</Element>
</Elements>
Figure 4.3 exemple du fichier Element.xml

<?xml version="1.0" encoding="UTF-8"?>


<Liens>
<Lien id="1" modelBG="1" jonction="1[1]">
<dim>1</dim>
<causalite>A</causalite>
</Lien>
<Lien id="2" modelBG="1" jonction="1[1]">
<dim>1</dim>
<causalite>A</causalite>
</Lien>
<Lien id="3" modelBG="1" jonction="1[1]">
<dim>1</dim>
<causalite>A</causalite>
</Lien>
<Lien id="4" modelBG="1" jonction="1[1],0[1]">
<dim>1</dim>
<causalite>A</causalite>
</Lien>
<Lien id="5" modelBG="1" jonction="0[1]">
<dim>1</dim>
<causalite>A</causalite>
</Lien>
<Lien id="6" modelBG="1" jonction="0[1]">
<dim>1</dim>
<causalite>A</causalite>
</Lien>
</Liens>
Figure 4.4 exemple du fichier Lien.xml d’un modèle Bond-graph acausal

Après l’affectation de la causalité, seul le contenu du fichier « Lien.xml » change. La


figure suivante donne une représentation d’un modèle Bond-graph causal :

<?xml version="1.0" encoding="UTF-8"?>


<Liens>
<Lien id="1" modelBG="1" jonction="1[1]">
<dim>1</dim>
<causalite>1</causalite>
</Lien>
<Lien id="2" modelBG="1" jonction="1[1]">

52
<dim>1</dim>
<causalite>1</causalite>
</Lien>
<Lien id="3" modelBG="1" jonction="1[1]">
<dim>1</dim>
<causalite>0</causalite>
</Lien>
<Lien id="4" modelBG="1" jonction="1[1],0[1]">
<dim>1</dim>
<causalite>0</causalite>
</Lien>
<Lien id="5" modelBG="1" jonction="0[1]">
<dim>1</dim>
<causalite>1</causalite>
</Lien>
<Lien id="6" modelBG="1" jonction="0[1]">
<dim>1</dim>
<causalite>0</causalite>
</Lien>
</Liens>
Figure 4.5 exemple du fichier Lien.xml d’un modèle Bond-graph causal
Remarque :
Cette forme de présentation, que nous proposons, peut être d’une grande utilité pour
standardiser les données représentant un modèle bond-graph. L’intérêt d’une telle
proposition peut faciliter l’échange des informations et le travail collaboratif.

2. Développement JAVA
a. Présentation de JAVA
JAVA est un langage objet ressemblant au langage C++. Il a été mis au point en 1991
par la firme Sun Microsystems. Le langage de programmation Java est un langage orienté
objet. Sa syntaxe est assez similaire a celle du C / C++, mais en rejette quelques
caractéristiques techniques de programmation complexes et non sécurisées. Ainsi, en ayant
retiré les difficultés liées au C++, la plate-forme Java initialement développée, a permis de
palier à un manque dans la création de logiciels pour les réseaux. Ce langage a été créé pour
être fonctionnel au sein d’une architecture réseau de machines et de systèmes d’exploitations
hétérogènes, car son implémentation se base sur le déploiement d’une machine virtuelle qui
reste indépendante du support physique.

b. Pourquoi JAVA ?
Nous avons opté pour java car c’est un langage qui présente les avantages suivants :
 C’est un langage orienté objet
 JAVA est simple : le choix de ses auteurs a été d'abandonner des éléments mal compris ou
mal exploités des autres langages tels que : la notion de pointeurs, l'héritage multiple et la
surcharge des opérateurs, ...

53
 JAVA est sûr : la sécurité fait partie intégrante du système d'exécution et du compilateur.
Un programme Java planté ne menace pas le système d'exploitation. Il ne peut pas y avoir
d'accès direct à la mémoire. L'accès au disque dur est réglementé dans une applet.
 JAVA est indépendant de toute plate-forme : il n'y a pas de compilation spécifique pour
chaque plate forme. Le code reste indépendant de la machine sur laquelle il s'exécute.
 JAVA est multitâche

3. Les JSP
a. Présentation des Java Server Pages
Les JSP (Java Server Pages) sont un standard permettant de développer des
applications Web interactives, c'est-à-dire dont le contenu est dynamique. En fait, une page
web JSP (repérable par l'extension .jsp) aura un contenu pouvant être différent selon certains
paramètres (des informations stockées dans une base de données, les préférences de
l'utilisateur,...) tandis que page web "classique" (dont l'extension est .htm ou .html) affichera
continuellement la même information.
Il s'agit en réalité d'un langage de script puissant (un langage interprété) exécuté du côté
du serveur et non du côté client
Les JSP sont intégrables au sein d'une page Web en HTML à l'aide de balises spéciales
permettant au serveur Web de savoir que le code compris à l'intérieur de ces balises doit être
interprété afin de renvoyer du code HTML au navigateur du client.
La figure 4.2 illustre la méthode de fonctionnent des JSP, en effet, lorsqu'un utilisateur
appelle une page JSP, le serveur Web appelle le moteur de JSP. celui-ci crée un code source
Java à partir du script JSP et compile la classe afin de fournir un fichier compilé (d'extension
.class), c'est-à-dire qu'il constitue en fait une servlet à partir du script JSP

.
Figure 4.6 fonctionnement des JSP

b. Pourquoi les JSP ?


Nous avons opté pour les JSP parce qu’ils permettent d'écrire facilement des servlets, en
incluant dans des balises spécifiques le code JSP au sein du fichier HTML. De cette façon,
elles fournissent une technologie rapide afin de créer des pages dynamiques. En plus, les JSP

54
étant basées sur Java côté serveur, elles possèdent toutes les caractéristiques faisant la force de
Java :

• les JSP sont multithreadées,


• les JSP sont portables,
• les JSP sont orientées objet,
• les JSP sont sûres,

II. Aperçu de l’application

Dans les pages qui suivent, nous présentons le prototype de l’application que nous
avons développé. Faute de temps, on n’a pas pu finir l’ensemble de ses fonctionnalités.
La page d’accueil de l’application permet à l’utilisateur de consulter les modèles qui
existent déjà afin de les modifier, leur affecter inverser ou supprimer la causalité, ou bien de
rechercher les chemins directs, indirects et les boucles causales, sans oublier bien sûr
d’ajouter de nouveaux modèles.

Figure 4.7 Page d’accueil

55
Supposons qu’on veut étudier le modèle Bond Graph suivant :
I1 C1 I2
C2

11 01 TF 02 12

Premièrement, l’utilisateur doit indiquer le nom et les domaines aux quels appartient le
nouveau modèle, ainsi qu’une description du modèle physique correspondant. Ensuite, il
suffit de saisir le modèle lien par lien.

Figure 4.8 Ajout d’un nouveau modèle – saisie des informations sur le modèle BG –

56
Figure 4.9 Ajout d’un nouveau modèle –saisie du modèle lien par lien –

Une fois le modèle Bond-graph saisi, il est affiché. L’utilisateur pourra effectuer une
modification ou une suppression du modèle, en cliquant respectivement sur les liens éditer et
supprimer.

Figure 4.10 Affichage du nouveau modèle

57
Figure 4.11 Edition d’un modèle

L’utilisateur pourra par un clic sur le lien causalité lui affecter la causalité, il peut aussi
inverser la causalité déjà affectée, c’est – à – dire inverser la causalité affectée aux éléments C
et I (intégrale ou dérivée) ou bien supprimer la causalité.

Figure 4.12 Affectation de la causalité à un modèle

58
En cliquant sur le lien « chemins causaux », on peut voir les chemins causaux directs
que contient le modèle Bond-graph. Et pour rechercher les chemins causaux indirects
existants entre deux éléments, il suffit de spécifier les 2 extrémités du chemin à travers un
formulaire, comme le montre la figure 4.14.

Figure 4.13 Recherche des chemins causaux directs

Figure 4.14 Recherche des chemins causaux indirects

59
Finalement, pour savoir s’il existe d’éventuelles boucles causales dans notre modèle, il
suffit de cliquer sur lien « boucles causales » pour savoir la réponse.

Figure 4.15 Recherche des boucles causales

60
CONCLUSION

Le travail, que nous présentons ici, nous a initié au principe de la modélisation et plus
spécifiquement dans la modélisation par les bond-graphs. Nous avons pu évaluer l’intérêt de
telles recherches dans un monde, sans frontière et de plus en plus concurrentiels, où la course
à l’innovation est synonyme de survie. Nous avons eu la chance d’appréhender la
modélisation par la méthodologie des bond-graphs. Son formalisme simple à comprendre,
efficace à mettre en œuvre permet d’avoir une vision rapide et concrète sur un système
physique. La production de modèles mathématiques sous forme d’expressions formelles
permet certaines analyses rapides permettant d’améliorer ou de conforter la solvabilité d’un
modèle étudié.

Par notre travail, nous avons pu contribuer par l’élaboration d’algorithmes optimaux et
dont la mise en œuvre informatique, que nous avons également élaborée, permet leur
intégration dans des outils utilisant les bond graph. Un autre aspect particulièrement
intéressant de notre travail, est l’utilisation d’un formalisme de représentation des données par
l’XML. Il s’agit ici d’une initiative qui pourra donner naissance à une standardisation du
« Bond Graph XML », et qui pourra contribuer à ouvrir une nouvelle brèche afin de faciliter
les échanges entre les communautés des spécialistes des bond-graphs ainsi qu’avec d’autres
communautés.

Deux autres aspects de nos recherches résident dans l’élaboration de règles intelligentes
et le découpage modulaire d’un bond-graph. Il s’agit ici, d’une piste demandée par notre
encadrant Monsieur Abdellah AZMANI et qui peut conduire à des recherches
particulièrement utiles pour les projets de modélisation de systèmes de grandes tailles,
élaborés de manière collaboratif et s’appuyant notamment sur l’exploitation des résultats
existants.

Comme perspectives du travail, on peut prévoir :

- Développement d’une application distribuée permettant l’intervention de plusieurs


collaborateurs distants.
- Couplage avec un Matlab afin de faire la simulation du système ainsi modélisé.
- Développement de bibliothèque Matlab classée par domaine physique.
- Intégration d’agents intelligents assurant l’assistance et l’interaction avec
l’utilisateur.

Pour terminer, la qualité du sujet qui nous a été proposé nous a permis d’avoir une bonne
initiation aux travaux de recherche avec un réel désir de continuer le développement
informatique de l’outil de modélisation et d’explorer les nombreuses pistes identifiées à partir
de notre travail.

61
BIBLIOGRAPHIE

[1] H. Paynter "Analysis and design of engineering systems", MIT Press, 1961

[2] D. Karnopp, R. Rosenberg "Systems dynamics : a unified approach", John Wiley &
Sons, 1975, 1991 (2nde édition)

[3] R. Rosenberg, D. Karnopp "Introduction to physical system dynamics", series in


mechanical engineering, Mac Graw Hill, 1983

[4] J. Thoma "Introduction to bond graphs and their applications", Pergamon Press, 1975

[5] BREEDVELD P.C., ROSENBERG R. C., ZHOU T.[1991]" Bond Graph


Bibliography" Journal of the Franklin Institue vol. 328, N°5/6, pp. 1067-1109 Pergamon
Press.

[6] J. Thoma "Simulation by bond graphs", Springer Verlag, 1991

[7] P. Borne, G. Dauphin-Tanguy, J.P. Richard, F. Rotella, I. Zambettakis "Modélisation et


identification des processus", Méthodes et pratiques de l'ingénieur, éditions Technip,
volume 3, tome 2, 1992

[8] G. Dauphin-Tanguy, S. Scavarda "Modélisation des systèmes physiques par bond


graphs", chap. 2 du tome 1 ("Modélisation et Estimation") d'un ouvrage collectif "Systèmes
non linéaires" (contrat DRET/AFCET), Masson, 1993

[9] J. Descusse "La linéarisation entrée-sortie par difféomorphisme et bouclage", Systèmes


non linéaires, tome 3, éditions Masson, 1993

[10] G. Dauphin-Tanguy, M. Lebrun, S. Scavarda "Introduction à la modélisation par bond


graphs", à paraître, éditions Technip

[11] A.AZMANI (19 Décembre 1991) "Analyse qualitative d’un Bond-Graph par les
techniques de l’Intelligence Artificielle. Contribution à la conception et à la réalisation du
logiciel d’aide à la modélisation ARCHER " Thése de Doctorat , Université de Lille,
France.

[12] A.Azmani, R.Bouayad, G.Dauphin_Tanguy (1991) "Artificial Intelligence Approach


for the Causal Analysis of Bond-Graph Models" Mathematical and Intelligent Models in
System Simulation, R.Hanus, P.Koll and S.Tzafestas editors, J.C.Baltzer AG, scientific
Publishing Co IMACS, pp 319-324.

62
[13] ROSENBERG R. C. [1987] "Exploiting Bond Graph Causality in Physical System
Models" Trans. Of the ASME, J. of DYN. SYST., Meas. And Contr., VOL. 109, pp. 378-
383.

WEBOGRAPHIE
[14] http://www.bondgraphs.com

[15] http://perso.orange.fr/philippe.fichou/documents/Du_BG_a_la_FT.pdf

[16] http://ravi.rodr.free.fr/3/bond%20graphs.htm

Liens utiles

http://uml.free.fr/ : site excellent proposant un cours complet sur UML illustré par des
exemples.

http://java.developpez.com/cours/ : site excellent proposant des cours sur java et jsp.

http://www.jsptut.com/: site proposant un cours complet sur les jsp débutant par des
exemples simples jusqu’à des exemples compliqués.

63
Annexes

64
SOMMAIRE DES ANNEXES

ANNEXE A : Règles d’affectation de la causalité............................................. 65

Liste des règles qui regissent les connexion de type 0 – 0 et 1 - 1 .................. 65


Liste des cas ..................................................................................................... 69

Liste des règles qui regissent les connexion de type 0 – 1 ............................ 127

Liste des cas ................................................................................................... 130

ANNEXE B : procédure d’affectation de la causalite ..................................... 194

ANNEXE C : Implémentation des algorithmes en langage JAVA ................. 201

64
Annexe A

REGLES D’AFFECTATION DE LA CAUSALITE

Cette annexe se consacre aux résultats de nos recherches en matière d’affectation de la


causalité. Ces recherches ont été effectuées sur deux jonctions et on a étudié tous les cas
qu’on pourra avoir. Vous aurez, par la suite, la liste des règles élaborées, suivies des cas sur
lesquels elles s’appliquent.

LISTE DES REGLES QUI REGISSENT LES CONNEXION DE TYPE 0–0


ET 1 - 1

Règle 1
Si j’ai une jonction de type 0 contenant I seule et une autre jonction 0 contenant I seule ou
avec une Sf alors un bloc sera dual.
Cas 2, cas 10

Règle 2
Si j’ai une jonction de type 0 contenant I seule et une autre jonction 0 contenant Sf seule alors
ce I sera dual.
Cas 6

Règle 3
Si j’ai une jonction est de type 0 avec une source Se et s’il possède un C alors tous les C sont
non dynamique.
Cas 12, cas 18, cas 20, cas 23, cas 35, cas 41, cas 43, cas 46, cas 59, cas 65, cas 67, cas 70,
cas 103, cas 109, cas 111, cas 114, cas 121, cas 127, cas129, cas 132, cas 138, cas 144, cas
146, cas 150, cas 170, cas 176, cas 178, cas 181, cas 184, cas 190, cas 192, cas 195, cas 215,
cas 217, cas 220, cas 236, cas 238, cas 241, cas 253, cas 255, cas 258, cas 261, cas 263, cas
268, cas 271, cas 274, cas 280

Règle 4
Si j’ai une jonction de type 0 contenant C et une autre jonction 0 contenant C ou Se alors un
bloc sera dual.
Cas 26, cas 28, cas 30, cas 32, cas 34, cas 35, cas 36, cas 37, cas 39, cas 40, cas 41, cas 42,
cas 43, cas 44, cas 45, cas 46, cas 47, cas 78, cas 82, cas 84, cas 88, cas 92, cas 116, cas 118,
cas 120, cas 121, cas 122, cas 123, cas 125, cas 126, cas 127, cas 128, cas 129, cas 130, cas
131, cas 132, cas 133, cas 154, cas 156, cas 160, cas 162, cas 164, cas 183, cas 184, cas 185,
cas 186, cas 188, cas 189, cas 190, cas 191, cas 192, cas 193, cas 194, cas 195, cas 196, cas

65
198, cas 202, cas 204, cas 206, cas 210, cas 211, cas 213, cas 214, cas 215, cas 216, cas 217,
cas 218, cas 219, cas 220, cas 221, cas 225, cas 227, cas 229, cas 244, cas 246, cas 248, cas
252, cas 253, cas 254, cas 255, cas 256, cas 257, cas 258, cas 259, cas 261, cas 263, cas 267,
cas 268, cas 269, cas 270, cas 271, cas 272, cas 274, cas 278, cas 279, cas 280, cas 281

Règle 5
Si j’ai une jonction de type 0 contenant Sf seule (ou avec I) et une autre jonction 0 contenant
Sf et I alors un des deux I sera dual.
Cas 101, cas 168

Règle 6
Si j’ai une jonction de type 1 contenant un I et une autre jonction de type 1 contenant un I ou
Sf alors forcement un I sera dual.
Cas 289, cas 293, cas 294, cas 295, cas 296, cas 297, cas 300, cas 305, cas 306, cas 308, cas
309, cas 310, cas 311, cas 356, cas 357, cas 358, cas 366, cas 374, cas 375, cas 376, cas 377,
cas 380, cas 382, cas 383, cas 384, cas 385, cas 386, cas 388, cas 389, cas 390, cas 391, cas
392, cas 393, cas 394, cas 397, cas 399, cas 400, cas 401, cas 402, cas 403, cas 405, cas 406,
cas 407, cas 408, cas 409, cas 410, cas 412, cas 414, cas 415, cas 416, cas 417, cas 418, cas
420, cas 421, cas 422, cas 423, cas 431, cas 432, cas 470, cas 471, cas 491, cas 492, cas 500,
cas 501, cas 508, cas 509, cas 510, cas 512, cas 513, cas 514, cas 515, cas 516, cas 517, cas
519, cas 520, cas 521, cas 522

Règle 7
Si j’ai une jonction est de type 1 avec une source Sf et s’il possède un I alors tous les I sont
non dynamique.
Cas 297, cas 306, cas 311, cas 319, cas 328, cas 333, cas 340, cas 349, cas 354, cas 340, cas
349, cas 354, cas 367, cas 377, cas 386, cas 391, cas 394, cas 403, cas 408, cas 410, cas 418,
cas 423, cas 425, cas 426, cas 428, cas 430, cas 431, cas 432, cas 434, cas 460, cas 465, cas
483, cas 488, cas 510, cas 515, cas 517, cas 522, cas 524, cas 533

Règle 8
Si j’ai une jonction de type 1 contenant un C seul et une autre jonction de type 1 contenant un
C ou Se seule ou les deux alors un C sera dual.
Cas 312, cas 321

Règle 9
Si j’ai une jonction 1 contenant une Se et une jonction 1 contenant une Se et une C alors
forcément ce C sera dual.
Cas 342, cas 453

Règle 10
Si j’ai deux jonctions de type 1 qui ont une causalité normale et un bloc contient Sf alors
l’ajout d’un nombre impair de gyrateur conduit à une anomalie.

66
Règle 11
Si j’ai deux jonctions de type 0 qui ont une causalité normale et un bloc contient Se alors
l’ajout d’un nombre impair de gyrateur conduit à une anomalie.

Règle 12
Si j’ai deux jonctions qui ont une causalité normale et l’un des blocs ne possède pas un R
alors si j’ajoute un nombre impair de gyrateur un bloc devient dual.

Règle 13
Si j’ai un bloc possédant un problème de causalité causé par la présence de I et Sf dans une
jonction 1 (Règle 7) et le nombre de gyrateurs ajoutés entre les deux blocs est impairs alors :
Le problème de causalité existera toujours pour le bloc contenant I et Sf.
Pour l’autre bloc :
- Si j’ai une Se seule => anomalie.
- Si j’ai une C sans un R => C deviendra duale.
- Si j’ai une I dual (Règle 6) => I deviendra normale.

Règle 14
Si j’ai un bloc possédant un problème de causalité causé par la règle 6, 8, 9 et si j’ajoute un
nombre impair de gyrateurs entre les deux blocs alors le problème de causalité sera résolu.

Règle 15
Si j’ai deux blocs possédant une anomalie et j’ajoute un nombre impair de gyrateurs entre ces
deux blocs alors l’anomalie sera résolue.

Règle 16
Si j’ai un bloc possédant un problème de causalité causé par la présence de C et Se dans une
jonction 1 (Règle 3) et le nombre de gyrateurs ajoutés entre les deux blocs est impairs alors :
- Le problème de causalité existera toujours pour le bloc contenant C et Se.
- Pour l’autre bloc :
- Si j’ai une Sf seule => anomalie.
- Si j’ai une I sans un R => I deviendra duale.
- Si j’ai une C dual (Règle 4) => C deviendra normale.

Règle 17
Si j’ai un bloc possédant un problème de causalité causé par la règle 1, 2, 4, 5 et si j’ajoute un
nombre impair de gyrateurs entre les deux blocs alors le problème de causalité sera résolu.

67
Aussi, au cours de notre recherche, nous avons constaté qu’il existe des cas où on est
confronté à des anomalies. Nous présentons, en ce qui suit, la liste des anomalies trouvées.

Anomalie 1
Si j’ai deux jonctions de types 0 contenant tous les deux des Se cela conduit à une anomalie.
Cas 76, cas 80, cas 83, cas 85, cas 87, cas 89, cas 90, cas 91, cas 93, cas 94, cas 95, cas 152,
cas 155, cas 157, cas 159, cas 161, cas 163, cas 165, cas 166, cas 167, cas 197, cas 199, cas
201, cas 203, cas 205, cas 207, cas 208, cas 209, cas 222, cas 224, cas 226, cas 228, cas 230,
cas 231, cas 232, cas 243, cas 245, cas 247, cas 249, cas 250, cas 251, cas 260, cas 262, cas
264, cas 265, cas 266, cas 273, cas 275, cas 276, cas 277, cas 282, cas 283, cas 284, cas 285,
cas 286, cas 287

Anomalie 2
Si j’ai deux jonctions de types 0 contenant tous les deux des Sf seule cela conduit à une
anomalie.
Cas 97

Anomalie 3
Si j’ai une jonction 1 contenant une Se seule et une autre jonction 1 contenant une Se seule
cela conduit à une anomalie.
Cas 335

Anomalie 4
Si j’ai une jonction 1 contenant une Sf et une autre jonction 1 contenant une Sf cela conduit à
une anomalie.
Cas 355, cas 359, cas 362, cas 364, cas 365, cas 368, cas 370, cas 371, cas 372, cas 373, cas
424, cas 427, cas 429, cas 433, cas 435, cas 436, cas 437, cas 438, cas 466, cas 468, cas 369,
cas 472, cas 474, cas 475, cas 476, cas 477, cas 489, cas 490, cas 493, cas 495, cas 496, cas
497, cas 498, cas 499, cas 502, cas 504, cas 505, cas 506, cas 507, cas 523, cas 525, cas 526,
cas 527, cas 528, cas 534, cas 535, cas 536, cas 537, cas 538, cas 539, cas 540, cas 541, cas
542, cas 543.

68
LISTE DES CAS

Cas 1 I
I 0 0
Cas 2
I 0 0 Sf
I 0 0 I
Cas 11
Cas 3
C
I 0 0 C
Cas 4
I 0 0 R I 0 0 R
Cas 5 Cas 12
I 0 0 Se
Cas 6 C

I 0 0 Sf

Cas 7 0
I 0 Se
C

Cas 13
C
I 0 0 I
Cas 8
R I 0 0 Sf
Cas 14
R
I 0 0 I
Cas 9
Se I 0 0 Se

Cas 15
R
I 0 0 I
Cas 10
I 0 0 Sf

69
Cas 16 R
Sf

I 0 0 Se

I 0 0 Se

Cas 17
C
R
Cas 21
R

I 0 0 I

I 0 0 Sf

C
Cas 18
C
I
Cas 22
R

I 0 0 Se

I 0 0 Sf

C
Cas 19
Se
I
Cas 23
C

I 0 0 Sf

I 0 0 Sf

C
Cas 20
Se
Cas 24

70
I Cas 33
I

I 0 0 Sf

C 0 0 Sf
Cas 34
Se
C
Cas 25
C 0 0
Cas 26 C 0 0 R
C 0 0 C Cas 35
Cas 27 C
C 0 0 R
Cas 28
C 0 0 Se
C 0 0 Se
Cas 36
Cas 29
C
C 0 0 Sf

Cas 30
C 0 0 Sf
C
Cas 37
R
C 0 0 I
Cas 31
R C 0 0 Se

Cas 38
R
C 0 0 I
Cas 32
Se C 0 0 Sf

Cas 39

C 0 0 I

71
Sf R

C 0 0 Se C 0 0 Se

Cas 40
R
C
Cas 44
C 0 0 I R

C 0 0 Sf
C
Cas 41
I
C
Cas 45
C 0 0 Se R

C 0 0 Sf
C
Cas 42
I
Se
Cas 46
C 0 0 Sf C

C 0 0 Sf
C
Cas 43

Se
Cas 47

72
I Se

C 0 0 Sf R 0 0 I
Cas 57
I
Se
Cas 48
R 0 0 R 0 0 Sf
Cas 49 Cas 58
R 0 0 I C
Cas 50
R 0 0 C
R 0 0 R
Cas 51
Cas 59
R 0 0 R
Cas 52
C
R 0 0 Se
Cas 53
R 0 0 Sf R 0 0 Se

Cas 54
Cas 60
C
C

R 0 0 I
R 0 0 Sf
Cas 55
Cas 61
R
R

R 0 0 I
R 0 0 Se
Cas 56
Cas 62

73
R R

R 0 0 Sf R 0 0 Se

Cas 63
Sf
C
Cas 68
R 0 0 Se R

Cas 64
R Sf
R 0 0

R 0 0 I
C
Cas 69
C R

Cas 65
I Sf
R 0 0

R 0 0 Se
Se
Cas 70
C C

Cas 66
I Sf
R 0 0

R 0 0 Sf
Se
Cas 71
C
Cas 67

74
I Se

R 0 0 Sf Se 0 0 I
Cas 81
I
Se
Cas 72
Se 0 0 Se 0 0 Sf
Cas 73 Cas 82
Se 0 0 I C
Cas 74
Se 0 0 C
Se 0 0 R
Cas 75
Cas 83
Se 0 0 R
C
Cas 76
Se 0 0 Se
Cas 77 Se 0 0 Se
Se 0 0 Sf Cas 84
Cas 78 C

Se 0 0 Sf

Se 0 0 I Cas 85
Cas 79 R

Se 0 0 Se

Se 0 0 I Cas 86
Cas 80

75
R R

Se 0 0 Sf Se 0 0 Se

Cas 87
Sf
C
Cas 92
Se 0 0 Se R

Cas 88
R Sf
Se 0 0

Se 0 0 I
C
Cas 93
C R

Cas 89
I Sf
Se 0 0

Se 0 0 Se
Se
Cas 94
C C

Cas 90
I Sf
Se 0 0

Se 0 0 Sf
Se
Cas 95
C
Cas 91

76
I C

Se 0 0 Sf Sf 0 0 R
Cas 103
C
Se
Cas 96
Sf 0 0 Sf 0 0 Se
Cas 97 Cas 104
Sf 0 0 Sf C

Cas 98
C 0
Sf 0 Sf
Cas 105
Sf 0 0 I R

Cas 99
R
Sf 0 0 Se

Cas 106
Sf 0 0 I R

Cas 100
Se
Sf 0 0 Sf

Cas 107
Sf 0 0 I Sf
Cas 101
I
Sf 0 0 Se

Cas 108
Sf 0 0 Sf
Cas 102

77
R R

Sf 0 I Sf 0 0 Sf
0

C C
Cas 109 Cas 113
I R

Sf 0 0 Se Sf 0 0 Sf

C Se
Cas 110 Cas 114
I C

Sf 0 0 Sf Sf 0 0 Sf

C Se
Cas 111 Cas 115
R I

Sf 0 0 Se Sf 0 0 Sf

C Se
Cas 112 Cas 116

78
C C C C

I 0 0 I I 0 0 Sf
Cas 117 Cas 123
C R
C R

I 0 0 Se
I 0 0 I
Cas 124
Cas 118
C R
C Se

I 0 0 Sf
I 0 0 I
Cas 125
Cas 119
C Sf
C I

I 0 0 Se
I 0 0 Sf
Cas 120 Cas 126
C R
C C

I 0 0 I
I 0 0 R
Cas 121
C C C
Cas 127

I 0 0 Se
Cas 122

79
C I C R

I 0 0 Se I 0 0 Sf

C Se
Cas 128 Cas 132
C I C C

I 0 0 Sf I 0 0 Sf

C Se
Cas 129 Cas 133
C R C I

I 0 0 Se I 0 0 Sf

C Se
Cas 130 Cas 134
C R R R

I 0 0 Sf I 0 0 I
Cas 135
R Se
C
Cas 131
I 0 0 I
Cas 136

80
R I R Sf

I 0 0 Sf I 0 0 Se

Cas 137 Cas 143


R C R R

I 0 0 R I 0 0 I

Cas 138
R C
C
Cas 144
I 0 0 Se R I
Cas 139
R C
I 0 0 Se

I 0 0 Sf
C
Cas 140
Cas 145
R R
R I

I 0 0 Se
I 0 0 Sf
Cas 141
R R
C
Cas 146
I 0 0 Sf

Cas 142

81
R R R I

I 0 0 Se I 0 0 Sf

C Se
Cas 147 Cas 152
R R Se Se

I 0 0 Sf I 0 0 I
Cas 153
Se I
C
Cas 148
R R I 0 0 Sf
Cas 154

Sf Se C
I 0 0

I 0 0 R
Se
Cas 155
Cas 150
Se C
R C

Sf I 0 0 Se
I 0 0
Cas 156
Se C
Se
Cas 151
I 0 0 Sf
Cas 157

82
Se R Se I

I 0 0 Se I 0 0 Sf

Cas 158
Se R
C
Cas 163
I 0 0 Sf Se R

Cas 159
Se Sf Se
I 0 0

I 0 0 Se
C
Cas 160 Cas 164
Se R
Se R

I 0 0 I
I 0 0 Sf

C
C
Cas 161 Cas 165
Se I
Se R

I 0 0 Se
I 0 0 Sf

C
Se
Cas 162 Cas 166

83
Se C Sf C

I 0 0 Sf 0
I 0 Sf
Cas 172
Sf R
Se
Cas 167
Se I I 0 0 Se

Cas 173
Sf Sf R
I 0 0

I 0 0 Sf
Se
Cas 168 Cas 174

Sf I Sf Sf

I 0 0 Se
I 0 0 Sf
Cas 169 Cas 175

Sf Sf R
C

I 0 0 I
I 0 0 R
Cas 170
Sf C C
Cas 176

I 0 0 Se
Cas 171

84
Sf I Sf R

I 0 0 Se I 0 0 Sf

C Se
Cas 177 Cas 181
Sf I Sf C

I 0 0 Sf I 0 0 Sf

C Se
Cas 178 Cas 182
Sf R Sf I

I 0 0 Se I 0 0 Sf

C Se
Cas 179 Cas 183
Sf R R C

I 0 0 Sf C 0 0 R
Cas 184
R C
C
Cas 180
C 0 0 Se
Cas 185

85
R R I
C

C 0 0 Se
C 0 0 Sf
Cas 186
R R C
Cas 191

Se R I
C 0 0
Cas 187
R R C 0 0 Sf

C 0 0 Sf C
Cas 188 Cas 192
R Sf R R

C 0 0 Se C 0 0 Se

Cas 189
R R
C
Cas 193
C 0 0 I R R

C C 0 0 Sf

Cas 190

C
Cas 194

86
R R Cas 199
C R

C 0 0 Sf

Se 0 0 Se

Cas 200
Se
C R
Cas 195
R C

Se 0 0 Sf

Sf Cas 201
C 0 0
C Sf

Se
Se 0 0 Se
Cas 196
R I Cas 202
C R

C 0 0 Sf
Se 0 0 I

Se
Cas 197 C

C C Cas 203
C I

Se 0 0 Se
Se 0 0 Se
Cas 198
C C

0
Cas 204
Se 0 Sf

87
C I C C

Se 0 0 Sf Se 0 0 Sf

C Se
Cas 205 Cas 209
C R C I

Se 0 0 Se Se 0 0 Sf

C Se
Cas 206 Cas 210
C R C C

Se 0 0 Sf Sf 0 0 Sf
Cas 211
C R
C
Cas 207
C R Sf 0 0 Se

Cas 212

0 Sf C R
Se 0

Sf 0 0 Sf
Se
Cas 208 Cas 213

88
C Sf C R

0 Se Sf 0 0 Se
Sf 0
Cas 214
C R C
Cas 218
C R
Sf 0 I
0

Sf 0 0 Sf
C
Cas 215
C I C
Cas 219
C R
Sf 0 0 Se

Sf 0 0 Sf
C
Cas 216
C I Se
Cas 220
C C
Sf 0 0 Sf

Sf 0 0 Sf
C
Cas 217

Se
Cas 221

89
C I R I

Sf Se 0 0 Se
Sf 0 0

Se C

Cas 222 Cas 227


R R R I

Se Se 0 0 Sf
Se 0 0
Cas 223
R R
C
Cas 228

Se 0 Sf R R
0
Cas 224
R Sf Se 0 0 Se

Se 0 0 Se
C
Cas 225 Cas 229
R R R R

Se 0 0 I Se 0 Sf
0

C C
Cas 226 Cas 230

90
R R Cas 235
R R

Se 0 0 Sf

Sf 0 I
0

Se
Cas 231 C
R C Cas 236
R I

Se 0 0 Sf

Sf 0 0 Se

Se
Cas 232 C
R I Cas 237
R I

Se 0 0 Sf

Sf 0 0 Sf

Se
Cas 233
C
R R Cas 238
R R

Sf 0 0 Sf

Cas 234 Sf 0 0 Se

R Sf

Sf 0 0 Se
Cas 239

91
R R Se Sf

Sf 0 0 Sf Sf 0 Se
0
Cas 244
Se R
C
Cas 240
R R 0 I
Sf 0

Sf 0 0 Sf
C
Cas 245
Se Se I

Cas 241
R C Se
Sf 0 0

Sf 0 0 Sf
C
Cas 246
Se I
Se
Cas 242
R I Sf 0 0 Sf

Sf 0 0 Sf
C
Cas 247

Se
Cas 243

92
Se R Se I

Sf 0 0 Se Sf 0 0 Sf

C Se
Cas 248 Cas 252
Se R C R

Sf 0 0 Sf I 0 0 I

C R C
Cas 249 Cas 253
Se R C I

Sf 0 0 Sf I 0 0 Se

Se R C
Cas 250 Cas 254
Se C C I

Sf 0 0 Sf I 0 0 Sf

Se R C
Cas 251 Cas 255

93
C R
C I

I 0 0 Se
I 0 0 Sf

R C
R Se
Cas 256
Cas 260
C R
C I

I 0 0 Sf
I 0 0 Se

R C
Se C
Cas 257
Cas 261
C R
C I

I 0 0 Sf

I 0 0 Sf

R Se

Cas 258 Se C

C C Cas 262
C R

I 0 0 Sf

I 0 0 Se

R Se

Cas 259 Se C
Cas 263

94
C R
C I

I 0 0 Sf
I 0 0 Sf

Se C
Sf C
Cas 264
C R Cas 268
C R

I 0 0 Sf
I 0 0 Se

Se Se
Cas 265 Sf C

C C Cas 269
C R

I 0 0 Sf
I 0 0 Sf

Se Se
Cas 266 Sf C

C I Cas 270
C R

I 0 0 Sf
I 0 0 Sf

Se Se
Cas 267 Sf Se
Cas 271

95
C C C R

I 0 0 Sf R 0 0 Sf

Sf Se Se Se
Cas 272 Cas 276
C I C C

I 0 0 Sf R 0 0 Sf

Sf Se Se Se
Cas 273 Cas 277
C R C I

R 0 0 Se R 0 0 Sf

Se C Se Se
Cas 274 Cas 278
C R C R

R 0 0 Sf R 0 0 Sf

Se C Sf C
Cas 275 Cas 279

96
C R Se C

R 0 0 Sf R 0 0 Sf

Sf Se Sf Se
Cas 280 Cas 284
C C Se I

R 0 0 Sf R 0 0 Sf

Sf Se Sf Se
Cas 281 Cas 285
C I Se C

R 0 0 Sf C 0 0 Sf

Sf Se Sf Se
Cas 282 Cas 286
Se R Se I

R 0 0 Sf C 0 0 Sf

Sf Se Sf Se
Cas 283 Cas 287

97
Se I Se

I 0 0 Sf I 1 1 I
Cas 297
I
Sf Se
Cas 288
I 1 1 I 1 1 Sf
Cas 289 Cas 298
I 1 1 I C
Cas 290
I 1 1 C
I 1 1 R
Cas 291
Cas 299
I 1 1 R
Cas 292
C
I 1 1 Se
Cas 293
I 1 1 Sf I 1 1 Se

Cas 294
Cas 300
C
C

I 1 1 I
I 1 1 Sf
Cas 295
Cas 301
R
R

I 1 1 I
I 1 1 Se
Cas 296
Cas 302

98
R Cas 307
R

I 1 1 Sf

I 1 1 Se
Cas 303

Sf
C

Cas 308
I 1 1 Se
R
Cas 304
R
I 1 1 Sf

I 1 1 I
C
Cas 309
C R
Cas 305
I
I 1 1 Sf

I 1 1 Se
Se
Cas 310
C C

Cas 306
I Sf
I 1 1

I 1 1 Sf
Se
Cas 311
C

99
I I

I 1 1 Sf C 1 1 Sf
Cas 320
C
Se
Cas 312
C 1 1 C C 1 1 R

Cas 313 Cas 321


C 1 1 R C
Cas 314
C 1 1 Se
C 1 1 Se
Cas 315
Cas 322
C 1 1 Sf
C
Cas 316
C
C 1 1 Sf
Cas 323
C 1 1 I
Cas 317 R

C 1 1 Se

C 1 1 I
Cas 324
Cas 318 R
Se

C 1 1 Sf
C 1 1 I
Cas 325
Cas 319

100
R
Sf

C 1 1 Se
C 1 1 Se

Cas 326
C
R
Cas 330
R
C 1 1 I

C 1 1 Sf

C
Cas 327
C
I
Cas 331
R
C 1 1 Se

C 1 1 Sf

C
Cas 328
Se
I
Cas 332
C
C 1 1 Sf

C 1 1 Sf

C
Cas 329
Se
Cas 333

101
I I

C 1 1 Sf R 1 1 Sf
Cas 341
C
Se
Cas 334
R 1 1 R R 1 1 R
Cas 335 Cas 342
R 1 1 Se C
Cas 336
R 1 1 Sf
R 1 1 Se
Cas 337
Cas 343
C
C

R 1 1 I
R 1 1 Sf
Cas 338
Cas 344
R
R

R 1 1 I
R 1 1 Se
Cas 339
Se
Cas 345
R

R 1 1 I
Cas 340 R 1 Sf
1
Cas 346

102
R
Sf

R 1 1 Se
R 1 1 Se

Cas 347
C
R
Cas 351
R
R 1 1 I

R 1 1 Sf

C
Cas 348
C
I
Cas 352
R
R 1 1 Se

R 1 1 Sf

C
Cas 349
Se
I
Cas 353
C
R 1 1 Sf

R 1 1 Sf

C
Cas 350
Se
Cas 354

103
I C

R 1 1 Sf Se 1 1 R

Cas 342
C
Se
Cas 335
Se 1 1 Se Se 1 1 Se
Cas 336 Cas 343
Se 1 1 Sf C

Cas 337
C
Se 1 1 Sf
Cas 344
Se 1 1 I R

Cas 338
R
Se 1 1 Se

Cas 345
Se 1 1 I R

Cas 339
Se
Se 1 1 Sf

Cas 346
Se 1 1 I Sf
Cas 340
I
Se 1 1 Se

Cas 347
Se 1 1 Sf
Cas 341

104
R R

Se 1 1 I Se 1 1 Sf

C C
Cas 348 Cas 352
I R

Se 1 1 Se Se 1 1 Sf

C Se

Cas 349 Cas 353


I C

Sf Se 1 1 Sf
Se 1 1

C Se

Cas 350 Cas 354


R I

Se Se 1 1 Sf
Se 1 1

C Se
Cas 351 Cas 355
Sf 1 1 Sf

Cas 356

105
C C

Sf 1 1 I Sf 1 1 Sf
Cas 357 Cas 363
R R

Sf 1 1 I Sf 1 1 Se

Cas 358 Cas 364


Se R

Sf 1 1 I Sf 1 1 Sf

Cas 359 Cas 365


I Sf

Sf 1 1 Sf Sf 1 1 Se

Cas 360 Cas 366


C R

Sf 1 1 R Sf 1 1 I
Cas 361
C
C
Cas 367
Sf 1 1 Se
Cas 362

106
I R

Sf 1 1 Se Sf 1 1 Sf

C Se

Cas 368 Cas 372


I C

Sf Sf 1 1 Sf
Sf 1 1

C Se

Cas 369 Cas 373


R I

Se Sf 1 1 Sf
Sf 1 1

C Se
Cas 370 Cas 374
R C C

Sf 1 1 Sf
I 1 1 I
Cas 375
C R
C
Cas 371
I 1 1 I
Cas 376

107
C Se C R

I 1 1 I I 1 1 Sf

Cas 377 Cas 383


C I C Sf

I 1 1 Sf I 1 1 Se

Cas 378 Cas 384


C C C R

I 1 1 R I
I 1 1
Cas 379
C C
C
Cas 385
I 1 1 Se C I
Cas 380
C C
I 1 1 Se

I 1 1 Sf
C
Cas 381
Cas 386
C R
C I

I 1 1 Se
I 1 1 Sf
Cas 382

108
Cas 387 C I
C R

I 1 1 Sf

I 1 1 Se

Se
C Cas 392
Cas 388 R R
C R

I 1 1 I
I 1 1 Sf
Cas 393
R Se

C
Cas 389 I 1 1 I
C R Cas 394
R I

I 1 1 Sf

I 1 1 Sf
Cas 395
Se
R C
Cas 390
C C

I 1 1 R

Sf
Cas 396
I 1 1
R C

Se
I 1 1 Se
Cas 391
Cas 397

109
R C R I

I 1 1 Se
I 1 1 Sf
Cas 398
R R
C
Cas 403
I 1 1 Se R I

Cas 399
R R Sf
I 1 1

I 1 1 Sf
C
Cas 400 Cas 404
R Sf R R

I 1 1 Se
I 1 1 Se
Cas 401
R R
C
Cas 405
I 1 1 I R R

C I 1 1 Sf

Cas 402

C
Cas 406

110
R R Se C

I 1 1 Sf I 1 1 R

Cas 412
Se C
Se
Cas 407
R C I 1 1 Se
Cas 412
Se C
I 1 1 Sf

I 1 1 Sf
Se
Cas 413
Cas 408
Se R
R I

I 1 1 Se
I 1 1 Sf
Cas 414
Se R
Se
Cas 409
I 1 1 Sf
Se Se
Cas 415
Se Sf
I 1 1 I
Cas 410
Se I I 1 1 Se

Cas 416

I 1 1 Sf
Cas 411

111
Se R Se R

I 1 1 I I 1 1 Sf

C C
Cas 417 Cas 421
Se I Se R

I 1 1 Se I 1 1 Sf

C Se

Cas 418 Cas 422


Se I Se C

I 1 1 Sf I 1 1 Sf

C Se
Cas 419 Cas 423
Se R Se I

I 1 1 Se 1 Sf
I 1

C Se
Cas 420 Cas 424

112
I Sf
I I

Sf 1 1 Se
Sf 1 1 Sf
Cas 431
Cas 425 I R
I C

Sf 1 1 I
Sf 1 1 R

Cas 426
I C C
Cas 432
I I
Sf 1 1 Se
Cas 427
Sf 1 1 Se
I C

Sf 1 1 Sf C

Cas 428 Cas 433

I R I I

Sf 1 1 Sf
Sf 1 1 Se

Cas 429
I R C
Cas 434

Sf 1 1 Sf

Cas 430

113
I R I I

Sf 1 1 Se Sf 1 1 Sf

C Se
Cas 435 Cas 439
I R R C

Sf 1 1 Sf
C 1 1 R

Cas 440
R C
C
Cas 436
I R C 1 1 Se
Cas 441
Sf R C
Sf 1 1

C 1 1 Sf
Se
Cas 437 Cas 442
I C R R

Sf C 1 1 Se
Sf 1 1
Cas 443
R R
Se
Cas 438
C 1 1 Sf

Cas 444

114
R Sf R R

C 1 1 Se 1 Se
C 1
Cas 445
R R
C
Cas 449

C 1 1 I R R

C C 1 1 Sf

Cas 446
R I
C
Cas 450
C 1 1 Se R R

C 1 1 Sf
C
Cas 447
R I
Se
Cas 451

1 Sf R C
C 1

C 1 1 Sf
C
Cas 448

Se
Cas 452

115
R I C R

Sf Se 1 1 I
C 1 1

Se C

Cas 453 Cas 459


C C C I

Se 1 1 Se
Se 1 1 Se
Cas 454
C C
C
Cas 460
Se 1 1 Sf C I

Cas 455
C R Sf
Se 1 1

Se 1 1 Se
C
Cas 456 Cas 461
C R C R

Se 1 1 Sf 1 Se
Se 1
Cas 457
C Sf
C
Cas 462
Se 1 1 Se

Cas 458

116
C R C C

Se 1 1 Sf Sf 1 1 Sf
Cas 467
C R
C
Cas 463
C R Sf 1 1 Se

Cas 468
C R
Se 1 1 Sf

Sf 1 1 Sf
Se
Cas 469
Cas 464
C Sf
C C

Sf 1 1 Se
Se 1 1 Sf
Cas 470
C R
Se
Cas 465
Sf 1 1 I
C I

Sf C
Se 1 1
Cas 471

Se
Cas 466

117
C I C R

Sf 1 1 Se Sf 1 1 Sf

C Se

Cas 472 Cas 476


C I C C

Sf 1 Sf Sf 1 1 Sf
1

C Se
Cas 473 Cas 477
C R C I

Sf 1 1 Se Sf 1 1 Sf

C Se
Cas 474 Cas 478
C R R R

Sf 1 1 Sf Se
Se 1 1
Cas 479
R R
C
Cas 475

Se 1 1 Sf

118
Cas 480 R R
R Sf

Se 1 1 Se

Se 1 1 Se

Cas 481
C
R R
Cas 485
R R

Se 1 1 I

Se 1 1 Sf

C
Cas 482
C
R I
Cas 486
R R

Se 1 1 Se

Se 1 1 Sf

C
Cas 483 Se
R I Cas 487
R C

Se 1 1 Sf

Se 1 1 Sf

C
Cas 484 Se
Cas 488

119
R I R I

Se 1 1 Sf Sf 1 1 Sf

Se C
Cas 489 Cas 494
R R R R

Sf 1 1 Sf Sf 1 1 Se

Cas 490
R Sf C
Cas 495
Se R R
Sf 1 1
Cas 491
R R Sf 1 1 Sf

Sf 1 1 I C
Cas 496
R R
C
Cas 492
R I Sf 1 1 Sf

Sf 1 1 Se
Se
Cas 497

C
Cas 493

120
R C Se I

Sf 1 1 Sf Sf 1 1 Se

Se C
Cas 498 Cas 502
R I Se I

Sf 1 1 Sf Sf
Sf 1 1

Se C
Cas 499 Cas 503
Se Sf Se R

Sf 1 1 Se 1 Se
Sf 1
Cas 500
Se R
C
Cas 504
Sf 1 1 I Se R

Sf 1 1 Sf
C
Cas 501

C
Cas 505

121
Se R C I

Sf 1 1 Sf I 1 1 Se

Se R C
Cas 506 Cas 510
Se C C I

Sf 1 1 Sf 1 Sf
I 1

Se R C
Cas 507 Cas 511
Se I C R

Sf 1 1 Sf Se
I 1 1

Se R C
Cas 508 Cas 512
C R C R

I 1 1 I Sf
I 1 1

R C R C
Cas 509 Cas 513

122
C R C I

Sf I 1 1 Sf
I 1 1

Se Se C
R
Cas 518
Cas 514
C R
C C

I 1 1 Se
I 1 1 Sf

Se C
R Se

Cas 515 Cas 519


C R
C I

I 1 1 Sf
I 1 1 Sf

Se C
R Se
Cas 520
Cas 516
C R
C I

Se I 1 1 Sf
I 1 1

Se C Se Se

Cas 517 Cas 521

123
C C I R

1 Sf Sf 1 1 Sf
I 1

Se Se C C

Cas 522 Cas 526


C I I R

I 1 1 Sf Sf 1 1 Sf

Se Se C Se
Cas 523 Cas 527
I I I C

Sf 1 1 Sf Sf 1 1 Sf

C C C Se
Cas 524 Cas 528
I R I I

Sf 1 1 Se Sf 1 1 Sf

C C Se
C
Cas 525 Cas 529

124
R R R I

Se 1 1 Se Se 1 1 Sf

C C C Se
Cas 530 Cas 534
R R R R

Se 1 1 Sf Sf 1 1 Sf

C C C C
Cas 531 Cas 535
R R R R

Se 1 1 Sf 1 Sf
Sf 1

C Se C Se
Cas 532 Cas 536
R C R C

Se 1 1 Sf Sf
Sf 1 1

C Se C Se
Cas 533 Cas 537

125
R I Cas 541
Se C

Sf 1 1 Sf

Sf 1 1 Sf

C Se

Cas 538 C Se

Se R Cas 542
Se I

Sf 1 1 Sf

Sf 1 1 Sf

R Se

Cas 539 C Se

Se C Cas 543
Se I

Sf 1 1 Sf

Sf 1 1 Sf

R Se
Cas 540 I Se
Se I

Sf 1 1 Sf

R Se

126
LISTE DES REGLES QUI REGISSENT LES CONNEXION DE TYPE 0 – 1

Règle 1
Si j’ai une jonction est de type 0 avec une source Se et s’il possède un C alors tous les C sont
non dynamique.
Cas 174, cas 175, cas 176, cas 177, cas 178, cas 179, cas 180, cas 181, cas 182, cas 183, cas
184, cas 185, cas 186, cas 187, cas 188, cas 189, cas 190, cas 191, cas 192, cas 193, cas 194,
cas 195, cas 196, cas 197, cas 198, cas 199, cas 200, cas 201, cas 202, cas 290, cas 291, cas
292, cas 293, cas 294, cas 295, cas 296, cas 297, cas 298, cas 299, cas 300, cas 301, cas 302,
cas 303, cas 304, cas 305, cas 306, cas 307, cas 308, cas 309, cas 310, cas 311, cas 312, cas
313, cas 314, cas 315, cas 316, cas 317, cas 318, cas 319, cas 320, cas 321, cas 322, cas 323,
cas 324, cas 325, cas 326, cas 327, cas 328, cas 329, cas 330, cas 331, cas 332, cas 333, cas
334, cas 335, cas 336, cas 337, cas 338, cas 339, cas 340, cas 341, cas 342, cas 343, cas 344,
cas 345, cas 346, cas 347
Règle 7
Si j’ai une jonction 0 avec Se et une jonction 1 avec C seul alors C sera dual.
Cas 145, cas 174, cas 203, cas 232, cas 261, cas 290, cas 319
Règle 9
Si j’ai deux blocs de jonctions de type différentes sans aucune source d’effort ni de flux et les
deux bloc possède un C alors forcément l’un des blocs sera dual. (un des bloc possède un C
seul)
Cas 1, cas 58, cas 62, cas 523
Règle 12
Si j’ai une jonction 0 avec C et une jonction 1 avec une Se alors forcement C sera dual.
Cas 14, cas 15, cas 71, cas 72, cas 536, cas 537
Règle 16
Si j’ai une jonction 0 avec Se et une jonction 1 avec Se et C (seuls) alors C sera dual.
Cas 159, cas 188, cas 217, cas 246, cas 275, cas 304, cas 333
Règle 17
Si j’ai une jonction 0 avec C et une jonction 1 avec Se seule et C alors l’un des blocs sera
dual.
Cas 362, cas 479, cas 508
Règle 18
Si j’ai une jonction 0 avec Sf et C et une jonction 1 avec Se alors C sera dual.
Cas 361.

Règle 2
Si j’ai une jonction est de type 1 avec une source Sf et s’il possède un I alors tous les I sont
non dynamique.
Cas 11, cas 12, cas 13, cas 26, cas 27, cas 28, cas 29, cas 39, cas 40, cas 41, cas 54, cas 55,
cas 56, cas 57, cas 68, cas 69, cas 70, cas 83, cas 84, cas 85, cas 86, cas 97, cas 99, cas 112,

127
cas 113, cas 114, cas 115, cas 126, cas127, cas 128,cas 141, cas 142, cas 143, cas 144, cas
155, cas 156, cas 157, cas 170, cas 171, cas 172, cas 173 , cas 185, cas 186, cas 199, cas 200,
cas 202, cas 213, cas 214, cas 215, cas 229, cas 230, cas 231, cas 257, cas 258, cas 259, cas
260, cas 271, cas272, cas 273, cas 289, cas 317, cas 318, cas 329, cas 331, cas 344, cas 345,
cas 346, cas 347, cas 358, cas 359, cas 360, cas 372, cas 374, cas 375, cas 376,cas 387, cas
388, cas 389, cas 402, cas 403, cas 404, cas 405, cas 416, cas 418, cas 431, cas 432, cas 433,
cas 434, cas 445, cas 446, cas 447, cas 460, cas 461, cas 462, cas 463, cas 474, cas 475, cas
476, cas 490, cas 491, cas 492, cas 493, cas 504, cas 505, cas 506, cas 519, cas 520, cas 521,
cas 522, cas 535, cas 548, cas 549, cas 550, cas 551, cas 562, cas 563, cas 564, cas 577,, cas
578, cas 579, cas 580
Règle 8
Si j’ai deux blocs de jonctions de type différentes sans aucune source d’effort ni de flux et les
deux bloc possède un I alors forcément l’un des blocs sera dual.
Cas 90, cas 91, cas 92, cas 93,
Règle 10
Si j’ai une jonction 0 avec Sf et I (pas de C) et une jonction 1 avec I alors l’un des blocs sera
dual.
Cas 410, cas 418
Règle 11
Si j’ai une jonction 0 avec Sf et une jonction 1 avec I ou C alors le bloc de jonction 1 sera
dual.
Cas 119, cas 120, cas 121, cas 122, cas 348, cas 377, cas 409, cas 411, cas 412, cas 417, cas
464, cas 494
Règle 13
Si j’ai une jonction 0 avec I et Sf et une jonction 1 avec une Sf alors forcement I sera dual.
Cas 94, cas 95, cas 96, cas 97, cas 98, cas 99, cas 413, cas 414, cas 415, cas 416, cas 427, cas
428, cas 429, cas 430, cas 431, cas 432, cas 433, cas 434
Règle 14
Si j’ai une jonction 0 avec un I seule et une jonction 1 avec Se et I ou Sf alors forcément I du
bloc de jonction 0 sera dual.
Cas 104, cas 105, cas 106, cas 107, cas 108, cas 109, cas 110, cas 111, cas 112, cas 113, cas
114, cas 115
Règle 15
Si j’ai une jonction 0 avec Sf et une jonction 1 avec Se et I alors I sera dual.
Cas 133, cas 134, cas 135, cas 136, cas 423, cas 424, cas 425, cas 426

Règle 3
Si j’ai deux blocs un possède un élément dynamique normal et l’autre un élément dynamique
dual et le nombre de gyrateurs entre les deux blocs est impairs alors le bloc dual devient
normal.
Règle 4

128
Si j’ai deux blocs un possède un élément dynamique dual et l’autre un élément dynamique
dual et le nombre de gyrateurs entre les deux blocs est impairs alors un seul bloc devient
normal.
Règle 5
Si j’ai deux blocs un possède un élément dynamique normal et l’autre un élément dynamique
dual et le nombre de gyrateurs entre les deux blocs est pairs alors il n y aura aucun
changement de causalité.
Règle 6
L’ajout d’un transformateur entre deux blocs n’influence pas sur la causalité du système.
Règle 19
Si j’ai deux blocs un possède un élément dynamique normal C ou I ou les deux et l’autre un
élément dynamique dual de jonction 1 avec Sf et I et le nombre de gyrateurs entre les deux
blocs est impairs alors le bloc normal devient dual.
Règle 20
Si j’ai deux blocs un possède un élément dynamique normal et l’autre un élément dynamique
dual de jonction 0 avec Se et C et le nombre de gyrateurs entre les deux blocs est impairs alors
le bloc normal devient dual.
Règle 21
Si j’ai deux blocs un possède un élément dynamique normal et l’autre un élément dynamique
normal et le nombre de gyrateurs entre les deux blocs est impairs alors un seul bloc devient
dual.
Anomalie 1
Si j’ai Sf seule dans une jonction 0 et Sf dans une jonction 1 cela conduit à une anomalie.
Cas 123, cas 124, cas 125, cas 126, cas 127, cas 128, cas 137, cas 138, cas 139, cas 140, cas
141, cas 142, cas 143, cas 144
Anomalie 2
Si j’ai Se seule dans une jonction 1 et Se dans une jonction 0 cela conduit à une anomalie.
Cas 158
Anomalie 3
Si j’ai Se seule dans une jonction 0 et Sf dans une jonction 1 et le nombre de gyrateurs entre
les deux blocs est impair cela conduit à une anomalie.
Anomalie 4
Si j’ai Sf seule dans une jonction 0 et Se dans une jonction 1 et le nombre de gyrateurs entre
les deux blocs est impair cela conduit à une anomalie.
Anomalie 5
Si j’ai Se seule dans une jonction 1 et Se dans une jonction 0 et le nombre de gyrateurs entre
les deux blocs et impairs cela conduit à une anomalie.

129
LISTE DES CAS

Cas 1 C 0 1 Sf
C 0 1 C Cas 9
Cas 2 C
C 0 1 R
Cas 3
C 0 1 Sf
R
Cas 10
R
C 0 1 C
Cas 4
C 0 1 Sf
C 0 1 I
Cas 11
Cas 5
I I

C 0 1 C C 0 1 Sf
Cas 6
Cas 12
R
C

C 0 1 I
C 0 1 Sf
Cas 7
Cas 13
R
R

C 0 1 I
C 0 1 Sf

C
I
Cas 8
Cas 14

130
C 0 1 Se I
Cas 15
C
C 0 1 Se

C 0 1 Se
C
Cas 16
Cas 20
R
I

C 0 1 Se
C 0 1 Se
Cas 17
R
R

C 0 1 Se Cas 21
I
Se
C
Cas 18 C 0 1

C
I
R
Cas 22
C 0 1 Se
Se

Cas 19 C 0 1

Sf
Cas 23

131
Se Se

C
C 0 1 C 0 1
C

Sf Sf
Cas 24 Cas 28
Se Se

R
C 0 1 C 0 1
R

Sf Sf
Cas 25 Cas 29
Se Se

C R
C 0 1 C 0 1 C

R I

Sf Sf
Cas 26 Cas 30
Se R 0 1 C
Cas 31
I
R
C 0 1

R 0 1 C
Sf
Cas 32
Cas 27
R 0 1 I
Cas 33

132
I I

R 0 1 C R 0 1 Sf
Cas 34 Cas 40
R C

R 0 1 I R 0 1 Sf
Cas 35 Cas 41
R R

R 0 1 I R 0 1 Sf

C I
Cas 36 Cas 42
R 0 1 Se

R 0 1 SfCas 43
C

Cas 37
C R 0 1 Se

Cas 44

R 0 1 Sf R

Cas 38
R 1 Se
R 0

Cas 45

R 0 1 Sf
Cas 39

133
R I
Se

R 0 1 Se R 0 1

C R
Cas 46 Cas 50
I Se

R 0 1
R 0 1 Se

Cas 47 Sf
I Cas 51
Se

R 0 1 Se

R 0 1 C

C
Cas 48 Sf
I Cas 52
Se

R 0 1 Se

R 0 1 R

R
Cas 49 Sf
Cas 53

134
Se Se

C R
R 0 1 R 0 1
C

R I

Sf Sf
Cas 54 Cas 58
Se C

I
R 0 1 R 0 1 C
Cas 59

Sf C
Cas 55
Se
R 0 1 R

C
1
Cas 60
R 0
C R
I

Sf
R 0 1 C
Cas 56
Cas 61
Se
C
R
R 0 1
R 0 1 I
I Cas 62
Sf C I
Cas 57

R 0 1 C

135
Cas 63 Cas 69

C R

C C
R 0 1 I
Cas 64
R 0 1 Sf
R
C

Cas 70
R 0 1 I
R
C

C
R 0 1 Sf
Cas 65
C

R 0 1 Sf Cas 71

Cas 66 C

C C

R 0 1 Se
Cas 72
R 0 1 Sf
C C
Cas 67

C R

R 0 1 Se

Cas 73
R 0 1 Sf
C R
Cas 68

C I

R 0 1 Se

Cas 74
R 0 1 Sf

136
C R
I
C
Se

R 0 1 Se

R 0 1

C
C
Cas 75 R

C I
Cas 79
C
Se
R 0 1 Se

Cas 76 0 1
R
I
C
Sf

0 1 Se Cas 80
R
Se
C

C
R 0 1
Cas 77 C

C I

Sf

0 1 Se Cas 81
R
C Se

R
R 0 1
Cas 78 R

Sf
Cas 82

137
C Se Se
C

C R
R 0 1 R 0 1
C

R I

Sf Sf
Cas 83 Cas 87

C Se I 0 1 C
Cas 88
I
I 0 1 R
R 0 1
Cas 89
R
Sf
Cas 84
I 0 1 C
C Se
Cas 90
C I 0 1 I

R 0 1 Cas 91

I I

Sf
Cas 85
I 0 1 C
Se
C
Cas 92
R
R
R 0 1

I
I 0 1 I
Sf
Cas 93
Cas 86

138
R R

I 0 1 I I 0 1 Sf

C I
Cas 94 Cas 100
I 0 1 Sf I 0 1 Se
Cas 95 Cas 101
C C

I 0 1 Sf I 0 1 Se

Cas 96 Cas 102


R R

I 0 1 Sf I 0 1 Se

Cas 97 Cas 103


I R

I 0 1 Sf I 0 1 Se

Cas 98
C
C
Cas 104
I 0 1 Sf I
Cas 99

I 0 1 Se

Cas 105

139
I Se

I 0 1 Se I 0 1
C

C Sf
Cas 106 Cas 110
I Se

I 0 1 Se I 0 1
R

R Sf
Cas 107 Cas 111
I Se
Se
C
I 0 1 I 0 1

C R

R Sf
Cas 108 Cas 112
Se Se

I 1 I
0
I 0 1

Sf
Cas 109 Sf
Cas 113

140
Se Sf 0 1 I
Cas 120
C
I
I 0 1

I
Sf 0 1 C
Sf
Cas 121
Cas 114
Se
R
R
I 0 1
Sf 0 1 I
I

Sf
Cas 122
Cas 115
R
Se

R
Sf 0 1 I
I 0 1 C

I
C
Sf
Cas 123
Cas 116
Sf 0 1 Sf
Sf 0 1 C
Cas 117 Cas 124

Sf 0 1 R C
Cas 118
R
Sf 0 1 Sf

Cas 125
Sf 0 1 C
Cas 119

141
R R

Sf 0 1 Sf Sf 0 1 Se

Cas 126 Cas 132


R
I

Sf 0 1 Se
Sf 0 1 Sf

Cas 127
C C
Cas 133
I
Sf 0 1 Sf
Cas 128
Sf 0 1 Se
R
Cas 134
I
Sf 0 1 Sf

Sf 0 1 Se
I
Cas 129
Sf 0 1 Se C

Cas 130 Cas 135

C I

Se Sf 0 1 Se
Sf 0 1

Cas 131

R
Cas 136

142
I Se
Se
C
Sf 0 1 Sf 0 1

C R

R Sf
Cas 137 Cas 141
Se Se

1 I
Sf 0
Sf 0 1

Sf
Cas 138 Sf

Se Cas 142
Se

Sf 0 1 C
C
Sf 0 1

I
Sf
Sf
Cas 139
Cas 143
Se
Se

R
Sf 0
1 R Sf 0 1

I
Sf
Sf
Cas 140
Cas 144

143
Se R

R
Sf 0 1 Se 0 1 I
C

Sf C
Cas 145 Cas 152
Se 0 1 C Se 0 1 Sf
Cas 146
Cas 153
C
Se 0 1 R

Cas 147 Se 0 1 Sf
Cas 154
R
R

Se 0 1 C
Se 0 1 Sf

Cas 148 Cas 155


Se I
0 1 I
Cas 149
I 0
Se 1 Sf
Cas 156
C
Se 0 1 C
Cas 150
R Se 0 1 Sf
Cas 157

Se 0 1 I
Cas 151

144
R I

Se 0 1 Sf Se 0 1 Se

I C
Cas 158 Cas 164
Se 0 1 I

Cas 159
C Se
Se 0 1 Se

Se 0 1 Se
R
Cas 160
Cas 165
R
I
Se

Se 0 1 Se
Se 0 1
Cas 161
C
R
R
Cas 166
Se 0 1 Se
Se

Se 0 1
C
Cas 162
Sf
I
Cas 167

Se 0 1 Se

Cas 163

145
Se Se

C
Se 0 1 Se 0 1
C

Sf Sf
Cas 168 Cas 172
Se Se

R
Se 0 1 Se 0 1
R

Sf Sf
Cas 169 Cas 173
Se Se

C R
Se 0 1 Se 0 1 C

R I

Sf Sf
Cas 170 Cas 174
Se C

I
Se 0 1
Se 0 1 C
Cas 175
C
Sf
Cas 171

Se 0 1 R

146
Cas 176 C
C R

Se 0 1 Sf
Se 0 1 C
Cas 182
Cas 177
C C
C

Se 0 1 Sf
Se 0 1 I
Cas 183
Cas 178
C R
C I

Se 0 1 Sf
Se 0 1 C
Cas 184
Cas 179
C I
C R

Se 0 1 Sf
Se 0 1 I
Cas 185
Cas 180
C C
C R

Se 0 1 Sf
Se 0 1 I
Cas 186

C
Cas 181

147
C C
R I

Se 0 1 Sf 0 1 Se
Se

Cas 192
C
I I

Cas 187
C
Se 0 1 Se

Se 0 1 Se C
Cas 188 Cas 193
C C C
I

Se 0 1 Se
Se 0 1 Se
Cas 189
C R
R
Cas 194
Se 0 1 Se C
I
Cas 190 Se

C
R Se 0 1

C
Se 0 1 Se
R
Cas 195

C
Cas 191

148
C C
Se
Se
I
Se 0 1 Se 0 1

Sf
Sf
Cas 196
Cas 200
C Se C Se

C
Se 0 1 C Se 0 1

I
Sf
Sf
Cas 197
Cas 201
C
Se C Se

R
Se 0 1 R Se 0 1

I
Sf
Sf
Cas 198
Cas 202
C
Se C
Se

C
R
Se 0 1 Se 0 1 C
R
I
Sf
Sf
Cas 199 Cas 203

149
R R
R

Se 0 1 C Se 0 1 I
Cas 204
R
C
Cas 210
Se 0 1 R R

Cas 205
R R
Se 0 1 Sf

Cas 211
Se 0 1 C R C
Cas 206
R
Se 0 1 Sf
Cas 212
Se 0 1 I R R
Cas 207
R I
Se 0 1 Sf
Cas 213
Se 0 1 C R I
Cas 208
R R
Se 0 1 Sf
Cas 214
Se 0 1 I
Cas 209

150
R C R
R

Se 0 1 Sf Se 0 1 Se
Cas 215
R
R
C
Cas 220
Se 0 1 Sf R
I

I Se 0 1 Se
Cas 216 Cas 221
R
R
I

Se 0 1 Se Se
Se 0 1
Cas 217
R C
C
Cas 222
Se 0 1 Se
R
I
Cas 218
R R
Se 0 1 Se

Se 0 1 Se
R
Cas 219
Cas 223

151
R R
I Se
Se
C
Se 0 1 Se 0 1

C R

R Sf
Cas 224 Cas 228
R R
Se
Se
I
Se 0 1 Se 0 1

Sf
Sf
Cas 225
Cas 229
R Se
R Se

Se C
0 1 C
Se 0 1

I
Sf
Sf
Cas 226
Cas 230
R
Se
R Se

R
Se 0 1 R Se 0 1

I
Sf
Sf
Cas 227
Cas 231

152
R Cas 237
Se
I R
R
Se 0 1 C
Se 1 1 I
I
Cas 238
Sf
I
R
Cas 232
I
Se 0 1 I

Se 0 1 C
Cas 233 C

I Cas 239
I

Se 0 1 R
Cas 234 Se 0 1 Sf

I R Cas 240
I C

Se 0 1 C
Cas 235 Se 0 1 Sf
I
Cas 241
I R

Se 0 1 I
Cas 236 Se 0 1 Sf
I I Cas 242

Se 0 1 C

153
I I Cas 248
I
R

Se 0 1 Sf
Cas 243 Se 0 1 Se

I C

Se 0 1 Sf Cas 249
Cas 244 I
I
I
R

Se 0 1 Se

Se 0 1 Sf Cas 250
I
I

I
Cas 245 Se 0 Se
1
I

C
Se 0 1 Se Cas 251
Cas 246 I
I
I C

Se 0 1 Se
Se 0 1 Se

Cas 247
R
I R
Cas 252

Se 0 1 Se

154
I I
I Se
Se
C
Se 0 1 Se 0 1

C R

R Sf
Cas 253 Cas 257
I I
Se
Se
I
Se 0 1 Se 0 1

Sf
Sf
Cas 254
Cas 258
I Se
I Se

Se C
0 1 C
Se 0 1

I
Sf
Sf
Cas 255
Cas 259
I
Se
I Se

R
Se 0 1 R Se 0 1

I
Sf
Sf
Cas 256
Cas 260

155
I I
Se

R
Se 0 1 Se 0 1 I
C

Sf R
Cas 261 Cas 265
I I I

Se 0 1 C Se 0 1 C

R R
Cas 262 Cas 266
I I R

Se 1 1 R Se 0 1 I

R R
Cas 263 Cas 267
I R I
R

Se 0 1 C Se 0 1 I

R R C

Cas 264 Cas 268

156
I I C

Se 0 1 Sf Se 0 1 Sf

R R
Cas 269 Cas 273
I C I
R

Se 0 1 Sf Se 0 1 Sf

R R I

Cas 270 Cas 274


I R I

Se 0 1 Sf Se 0 1 Se

R R
Cas 271 Cas 275
I I I C

Se 0 1 Sf Se 0 1 Se

R R
Cas 272 Cas 276

157
I R I
I

Se 0 1 Se Se 0 1 Se

R R R

Cas 277 Cas 281


I I
R I
Se

Se 0 1 Se Se 0 1

R C R R

Cas 278 Cas 282


I I
I
Se

Se 0 1 Se Se 0 1

Sf
R R

Cas 279 Cas 283


I I Se
I

Se Se Se 1 1
0 1 C

C R Sf
R
Cas 280 Cas 284

158
I I Se
Se

R
Se 0 1 Se 0 1
R

R Sf R Sf

Cas 285 Cas 289


I I
Se Se

C R
Se 0 1 Se 0 1
C

R I

R Sf R Sf

Cas 286 Cas 290


I I
Se

I
Se 0 1 Se 0 1 C

R Sf C
Cas 287 Cas 291
I Se I

C
Se 0 1 Se 0 1 R

R Sf C
Cas 288 Cas 292

159
I R I
R

Se 0 1 C Se 1 1 I

C C C

Cas 293 Cas 297


I I

Se 0 1 I Se 0 1 Sf

C C

Cas 294 Cas 298


I I C
I

Se 0 1 C Se 0 1 Sf

C C

Cas 295 Cas 299


I I R
R

Se 0 1 I Se 0 1 Sf

C C

Cas 296 Cas 300

160
I I I C

Se 0 1 Sf Se 0 1 Se

C C
Cas 301 Cas 305
I C I R

Se 0 1 Sf Se 0 1 Se

C C
Cas 302 Cas 306
I I
R R

Se 0 1 Sf Se 0 1 Se

C I C C
Cas 303 Cas 307
I I
I

Se 0 1 Se Se 0 1 Se

C C
Cas 304 Cas 308

161
I I Se
I

Se 0 1 Se Se 0 1 C

C C C Sf

Cas 309 Cas 313


I I Se
I

Se Se Se 0 1
0 1 R

R C Sf
C
Cas 310 Cas 314
I I
I Se
Se
C
Se 0 1 Se 0 1

C R

C R C Sf

Cas 311 Cas 315


I I
Se
Se
I

Se Se 0 1
0 1

Sf
C Sf
C
Cas 312 Cas 316

162
I Se I
R
C
Se 0 1 Se 0 1 R

C Sf C
Cas 317 Cas 321
I Se I R
R
R
Se 0 1 Se 0 1 C

C Sf
C
Cas 318 Cas 322
I I
Se
R
R
Se 0 1 Se 0 1 I
C

C Sf
C
Cas 319 Cas 323
I I I
R
R

Se 0 1 C Se 0 1 C

C C
Cas 320 Cas 324

163
I R I R
R R

Se 0 1 I Se 0 1 Sf

C C
Cas 325 Cas 329
I I I
R
R R

Se 0 1 I Se 0 1 Sf

C C C
Cas 326 Cas 330
I I C
R R

Se 1 1 Sf Se 0 1 Sf

C C
Cas 327 Cas 331
I C I
R
R R

Se 0 1 Sf Se 0 1 Sf

C C I

Cas 328 Cas 332

164
I I
I
R R

Se 0 1 Se Se 0 1 Se

C C
Cas 333 Cas 337
I C I
I
R R

Se 0 1 Se Se Se
0 1

C C C
Cas 334 Cas 338
I R I
I
R R

Se 0 1 Se Se
Se 0 1

C C R
Cas 335 Cas 339
I I
R I
R R Se

Se 0 1 Se Se 0 1

C C C R
Cas 336 Cas 340

165
I I
Se
R Se R

I
Se 0 1 Se 0 1

Sf
C C Sf

Cas 341 Cas 345


I Se I Se
R R
C
Se 0 1 Se 0 1
C

C Sf C Sf

Cas 342 Cas 346


I Se I Se
R R

R
Se 0 1 Se 0 1
R

C Sf C Sf

Cas 343 Cas 347


I I
Se Se
R R

C R
Se 0 1 Se 0 1
C

R I

C Sf C Sf

Cas 344 Cas 348

166
C C
R

Sf 0 1 C Sf 0 1 I
Cas 349
C
C
Cas 355
Sf 0 1 R C

Cas 350
C R
Sf 0 1 Sf

Cas 356
Sf 0 1 C C C
Cas 351
C
Sf 0 1 Sf
Cas 357
Sf 0 1 I C R
Cas 352
C I
Sf 0 1 Sf
Cas 358
Sf 0 1 C C I
Cas 353
C R
Sf 0 1 Sf
Cas 359
Sf 0 1 I
Cas 354

167
C C C
R

Sf 0 1 Sf Sf 0 1 Se
Cas 360
C
R
C
Cas 365
Sf 0 1 Sf C
I

I Sf 0 1 Se
Cas 361 Cas 366
C
C
I

Sf 0 1 Se Se
Sf 0 1
Cas 362
C C
C
Cas 367
Sf 0 1 Se
C
I
Cas 363
C R
Sf 0 1 Se

Sf 0 1 Se
R
Cas 364
Cas 368

168
C C
I Se
Se
C
Sf 0 1 Sf 0 1

C R

R Sf
Cas 369 Cas 373
C C
Se
Se
I
Sf 0 1 Sf 0 1

Sf
Sf
Cas 370
Cas 374
C Se
C Se

C
Sf 0 1 C Sf 0 1

I
Sf
Sf
Cas 371
Cas 375
C
Se
C Se

R
Sf 0 1 R Sf 0 1

I
Sf
Sf
Cas 372
Cas 376

169
C R I
Se

R
Sf 0 1 Sf 0 1 C
C
Cas 382
I
R R
Sf
Cas 377
R Sf 0 1 I
Cas 383
R
R
Sf 0 1 C
Cas
Cas378
Sf 0 1 I
R

C
Sf 0 1 R
Cas 384
Cas 379
R
R R

Sf 0 1 Sf
Sf 0 1 C
Cas 385
Cas 380
R C
R

Sf 0 1 Sf
Sf 0 1 I
Cas 386
Cas 381
R R

Sf 0 1 Sf

170
Cas 387 R R
R I

Sf 0 1 Se

Sf 0 1 Sf Cas 393
Cas 388 R
R
R C

Sf 0 1 Se
Sf 0 1 Sf
Cas 389
R C
R
Cas 394
R
I
Sf 0 1 Sf

Sf 0 1 Se
I
Cas 395
Cas 390
R
R I

Sf 0 1 Se
Sf 0 1 Se
Cas 391
R C C
Cas 396

Sf 0 1 Se

Cas 392

171
R R
I Se

Sf 0 1 Se Sf 0 1 R

R Sf

Cas 397 Cas 401


R R
I Se
Se
C
Sf 0 1 Sf 0 1

C R

R Sf
Cas 398 Cas 402
R R
Se
Se
I
Sf 0 1 Sf 0 1

Sf
Sf
Cas 399
Cas 403
R Se
R Se

C
Sf 0 1 C Sf 0 1

I
Sf
Sf
Cas 400
Cas 404

172
R Se I

R
Sf 0 1 Sf 0 1 I
Cas 410
I
I I
Sf
Cas 405
R Sf 0 1 C
Se
Cas 411
R
I R
Sf 0 1
C

I
Sf 1 1 I
Sf
Cas 412
Cas 406
I
I R

Sf 0 1 I
Sf 0 1 C
Cas 407
I C
Cas 413
I
Sf 0 1 R
Cas 408
I R Sf 0 1 Sf

Cas 414
Sf 0 1 C I C
Cas 409

Sf 0 1 Sf

173
Cas 415 I C
I R

Sf 0 1 Se
Sf 0 1 Sf Cas 421
Cas 416 I R
I I

Sf 0 1 Se

Sf 0 1 Sf Cas 422
Cas 417 I
R
I C

Sf 0 1 Se
Sf 0 1 Sf
Cas 418
I C
R
Cas 423
I
I
Sf 0 1 Sf

Sf 0 1 Se
I
Cas 424
Cas 419
I
I I

Sf 0 1 Se
Sf 0 1 Se

Cas 420
C
Cas 425

174
I I
I Se

Sf 0 1 Se Sf 0 1 R

R Sf

Cas 426 Cas 430


I I
I Se
Se
C
Sf 0 1 Sf 0 1

C R

R Sf
Cas 427 Cas 431
I I
Se
Se
I
Sf 0 1 Sf 0 1

Sf
Sf
Cas 428
Cas 432
I Se
I Se

C
Sf 0 1 C Sf 0 1

I
Sf
Sf
Cas 429
Cas 433

175
I Se I R

R
Sf 0 1 Sf 0 1 C

Sf
R
Cas 434 Cas 438
I
Se I

R
Sf 0 1 Sf
C 0 1 I

Sf
R
Cas 435
Cas 439
I
I I

Sf 0 1 C
0 1 C

R
R
Cas 436 Sf

I Cas 440
I R

Sf 1 1 R
Sf 0 1 I

R
Cas 437 R
Cas 441

176
I I I
R

Sf 0 1 I Sf 0 1 Sf

R C R
Cas 442 Cas 446
I I C

Sf 0 1 Sf Sf 0 1 Sf

R R
Cas 443 Cas 447
I C I
R

Sf 0 1 Sf Sf 0 1 Sf

R R I

Cas 444 Cas 448


I R I

Sf 0 1 Sf Sf 0 1 Se

R R
Cas 445 Cas 449

177
I C I
I

Sf 0 1 Se Sf 0 1 Se

R R C

Cas 450 Cas 454


I R I
I

Sf 0 1 Se Sf 0 Se
1

R R R
Cas 451 Cas 455
I I
R I
Se

Sf 0 1 Se Sf 0 1

R C R R
Cas 452 Cas 456
I I
I
Se

Sf 0 1 Se Sf 0 1

Sf
R R
Cas 453 Cas 457

178
I Se I Se

C
Sf 1 1 Sf 0 1
C

R Sf R Sf

Cas 458 Cas 462


I Se I Se

R
Sf 0 1 Sf 0 1
R

R Sf R Sf

Cas 459 Cas 463


I I
Se Se

C R
Sf 0 1 Sf 0 1
C

R I

R Sf R Sf

Cas 460 Cas 464


I I
Se

I
Sf 0 1 Sf 0 1 C

R Sf C
Cas 461 Cas 465

179
I I R

Sf 0 1 R Sf 0 1 I

C C
Cas 466 Cas 470
I R I
R

Sf 0 1 C Sf 0 1 I

C C C

Cas 467 Cas 471


I I

Sf 0 1 I Sf 0 1 Sf

C C

Cas 468 Cas 472


I I C
I

Sf 0 1 C Sf 0 1 Sf

C C

Cas 469 Cas 473

180
I R I

Sf 0 1 Sf Sf 0 1 Se

C C
Cas 474 Cas 479
I I I C

Sf 0 1 Sf Sf 0 1 Se

C C
Cas 475 Cas 480
I C I R

Sf 0 1 Sf Sf 0 1 Se

C C
Cas 476 Cas 481
I I
R R

Sf 0 1 Sf Sf 0 1 Se

C I C C
Cas 478 Cas 482

181
I I
I
Se

Sf 0 1 Se Sf 0 1

Sf
C C

Cas 483 Cas 487


I I Se
I

Sf Se Sf 0 1
0 1 C

C C Sf
C
Cas 484 Cas 488

I I Se
I

Sf 0 1
Sf 0 1 Se R

C Sf
C R
Cas 485 Cas 489

I I
I Se
Se
C
Sf 0 Sf 0 1
1

C R

C R C Sf

Cas 486 Cas 490

182
I I
Se
R

I
Sf 0 1 Sf 0 1 C

C Sf C
Cas 491 Cas 495
I Se I
R
C
Sf 0 1 Sf 0 1 R

C Sf C
Cas 492 Cas 496
I Se I R
R
R
Sf 0 1 Sf 0 1 C

C Sf
C
Cas 493 Cas 497
I I
Se
R
R
Sf 0 1 Sf 0 1 I
C

C Sf
C
Cas 494 Cas 498

183
I I I C
R R

Sf 0 1 C Sf 0 1 Sf

C C
Cas 499 Cas 503
I R I R
R R

Sf 0 1 I Sf 0 1 Sf

C C
Cas 500 Cas 504
I I I
R
R R

Sf 0 1 I Sf 0 1 Sf

C C C
Cas 501 Cas 505
I I C
R R

Sf 1 1 Sf Sf 0 1 Sf

C C
Cas 502 Cas 506

184
I I
R R
R R

Sf 0 1 Sf Sf 0 1 Se

C I C C
Cas 507 Cas 511
I I
I
R R

Sf 0 1 Se Sf 0 1 Se

C C
Cas 508 Cas 512
I C I
I
R R

Sf 0 1 Se Sf Se
0 1

C C C
Cas 509 Cas 513
I R I
I
R R

Sf 0 1 Se Se
Sf 0 1

C C R
Cas 510 Cas 514

185
I I
I Se
R Se R

C
Sf 0 1 Sf 0 1

C R

C R C Sf
Cas 515 Cas 519
I I
Se
R Se R

I
Sf 0 1 Sf 0 1

Sf
C C Sf

Cas 516 Cas 520


I Se I Se
R R
C
Sf 0 1 Sf 0 1
C

C Sf C Sf

Cas 517 Cas 521


I I Se
Se
R R

R
Sf 0 1 Sf 0 1
R

C Sf C Sf

Cas 518 Cas 522

186
I Cas 528
Se
R R
C
R
Sf 0 1 C
I 0 1 I
I
Cas 529
C Sf R
C
Cas 523
C
I 0 1 I

I 0 1 C
Cas 524 C
Cas 530
C C

I 0 1 R I 0 1 Sf
Cas 531
Cas 525 C
C
C R

I 0 1 Sf
I 0 1 C Cas 532
Cas 526 R
C
C

I 0 1 Sf
I 0 1 I
Cas 533
Cas 527
C I
C I

I 0 1 Sf
I 0 1 C

187
Cas 534 C R

C I 0 1 Se
C

I 0 1 Sf C
Cas 540
C I
Cas 535
R
C
I 0 1 Se

Cas 541
I 0 1 Sf
I
C

I
0 1 Se
I
Cas 536
C
C
Cas 542
I 0 1 Se
C I
Cas 537
C C

I 0 1 Se

I 0 1 Se

Cas 538 R

C R Cas 543

I 0 1 Se

Cas 539

188
C Se
I
C
Se C
I 0 1
0 1
I
R
C
Sf
R Cas 548

C Se

Cas 544
I
C
Se I 0 1

I 0 1
Sf
Cas 549
Sf
C Se
Cas 545
Se C
C
I 0 1

I 0 1 I
C
Sf
Cas 550
Sf
Se
Cas 546 C

C Se R

I 0 1

I 0 1 I
R
Sf
Cas 551
Sf
Cas 547

189
Se Cas 557
C
R R
R

I 0 1
C
I 0 1 I
I
Cas 558
Sf
R
Cas 552 R

I 0 1 I

I 0 1 C
Cas 553 C
Cas 559
R
R

I 0 1 R
I 0 1 Sf
Cas 560
Cas 554
R C
R R

I 0 1 Sf
I 0 1 C
Cas 561
Cas 555
R R
R

I 0 1 I I 0 1 Sf

Cas 556 Cas 562


R I R I

I 0 1 C I 0 1 Sf

190
Cas 563 R R

C I 0 1 Se
R

I 0 1 Sf C
Cas 569
R I
Cas 564
R
R
I 0 1 Se

Cas 570
I 1 Sf
0 I
R

I
0 1 Se
I
Cas 565
R
C
Cas 571
I 0 1 Se
R I
Cas 566
R C

I 0 1 Se

I 0 1 Se

Cas 567 R

R R Cas 572

I 0 1 Se

Cas 568

191
R Se
I
R
Se C
I 0 1
0 1
I
R
C
Sf
R Cas 577

R Se
Cas 573
R I
Se
I 0 1

I 0 1

Sf
Sf Cas 578
Cas 574 Se
r
Se
R
C

I 0 1
I 0 1 C
I

Sf
Sf Cas 579
Cas 575 Se
R
R Se
R

I 0 1
I 0 1 R
I

Sf
Sf Cas 580
Cas 576

192
Se
R

I 0 1
C

Sf

193
Annexe B

PROCEDURE D’AFFECTATION DE LA CAUSALITE

Cette annexe a pour but de présenter une approche d’affectation de la causalité basée sur
le concept de « bloc ». En fait, on a considéré qu’un modèle bond-graph peut être vu comme
étant un ensemble de bloc, chaque bloc est constitué d’une ou plusieurs jonctions, et il dispose
de ses propres chemins directs, boucles causales et sa fonction de transfert. Ainsi pour
calculer la fonction de transfert du système, il suffit de faire le produit des différentes
fonctions de transfert des blocs. De même pour les chemins et les boucles causales. Mais faute
de temps on n’a pas pu aller plus loin dans cette approche.

Voici, en ce qui suit, l’algorithme général suivi des algorithmes détaillés de chaque
étape.

Algorithme général
1> Construire les blocs, à partir d’une représentation BG XML
2> Déterminer le bloc ayant le minimum de connexions
3> Déterminer les parcours, les boucles de causalité et classifier les parcours par nombre de
blocs maximal, identifier
4> Appliquer l’expertise
Etape 1 ‘Construction des blocs’
Considérons l’exemple suivant :
I1 C1 I2
C2

11 01 TF 02 12
B1 B2 B3 B4

Dans cet exemple on a considéré qu’un bloc est constitué d’une seule jonction. Les
blocs sont symbolisés par : B1, B2, …Une représentation XML de ce Bond Graph est la
suivante :

<BG>
<Bloc Id= “ B1“ Jonction = “11“>
<I> I1</I>
<Connexions>
<Connexion> B2 </Connexion>
</Connexions>
</Bloc>
<BG>
<Bloc Id= “ B2“ Jonction = “01“ >

194
<C> C1</C>
<Connexions>
<Connexion Type = “TF1“ > B3 </Connexion>
<Connexion> B1 </Connexion>
</Connexions>
</Bloc>
<Bloc Id= “ B3“ Jonction = “02“ >
<C> C2</C>
<Connexions>
<Connexion Type = “TF1“ > B2 </Connexion>
<Connexion> B4 </Connexion>
</Connexions>
</Bloc>
<Bloc Id= “ B4“ Jonction = “12“ >
<I> I2</I>
<Connexions>
<Connexion> B3 </Connexion>
</Connexions>
</Bloc>

Avant d’entamer la construction des blocs à partir du fichier XML, définissons les
structures suivantes :

Structure Transformateur
Début
Chaîne Id // Identificateur du transformateur
Chaîne Caus // Information sur la causalité du transformateur soit : ES ou SE
Fin
Structure Gyrateur
Début
Chaîne Id // Identificateur du transformateur
Chaîne Caus // Information sur la causalité du transformateur soit : SS ou EE
Fin
Structure Connexion
Début
Chaîne : Type // Type de la connexion : TF, GY
Chaîne : Co
Fin
Structure Bloc
Début
Chaîne : Id // identificateur du bloc
Chaîne : Jonct // type de la jonction
Chaîne : I // chaîne de caractères stockant les I connectés à la jonction
Chaîne : CausI // pour stocker les informations de causalité des I
Chaîne : C // chaîne de caractères stockant les C connectés à la jonction
Chaîne : CausC // pour stocker les informations de causalité des C
Tableau Connexion : Conex // tableau stockant les connexions du bloc
Fin

195
Pour l’information de la causalité nous utiliserons soit S soit E suivant que le trait causal
soit entrant ou sortant par rapport à l’élément étudié.
I1 I1

Trait causal sortant Trait causal entrant

L’algorithme suivant illustre la manière avec laquelle se fera la construction des blocs à
partir du fichier XML.

Tableau bloc: BG
Entier : i,j
I <- 0
J <- 0
Répéter
S <- LireMot()
Si S égal ‘<Bloc’ alors
BG[i].Id <- LireMot()
FinSi
Si S égal ‘jonction’ alors
BG[i].Jonct <- LireMot()
FinSi
Si S égal ‘<I>’ alors
BG[i].I <- concatenation (BG[i].I, LireMot())
BG[i].I <- concatenation (BG[i].I, ‘,’)
FinSi
Si S égal ‘<C>’ alors
BG[i].C <- concatenation (BG[i].C, LireMot())
BG[i].C <- concatenation (BG[i].C, ‘,’)
FinSi
Si S égal ‘<Connexion>’ alors
S <- LireMot()
Si S égal ‘Type ’ alors
BG[i].Conex[j].Type <- LireMot()
BG[i].Conex[j].Co <- LireMot()
Sinon
BG[i].Conex[j].Co <- S
FinSi
j = j +1
FinSi
Si S égal ‘</Bloc>’ alors
i <- i + 1
j <- 0
FinSi
Jusqu’à la fin Fich_XML

Etape 2 ‘Recherche du bloc ayant le min de connexion’


De même on définit les variables suivantes :

196
Entier Imin // nombre de connexions minimal
Entier Bmin // Bloc possédant un nombre de connexion minimal
Imin <- Dimention (BG[0].conex)
Bmin <- BG[0].Id
i <- 1
Répéter
Si Dimention(BG[i].conex) < Imin alors
Imin <- Dimention(BG[i].conex)
Bmin <- BG[i].id
FinSi
i <- i +1
Jusqu’à la fin du tableau BG

Etape 3 ‘Détermination des parcours et des boucles de causalité’

Avant de déterminer les parcours relatifs à notre bond Graph, modélisons, tout d’abord,
ce dernier sous forme d’un arbre. On identifie le bloc ayant le minimum de connexions, s’il
existe plusieurs on prend le premier.
On définit la structure nœud de la manière suivante :

Structure Nœud
Début
Chaîne : Val // identificateur du bloc
Pointeur : Frere
Pointeur : Fils
Fin

L’arbre est construit de la manière suivante :

Nœud L
Noeud NC, NS
Bloc BC
Entier n, i
BC <- MinConnexion (BG)
NC <- AjouterNoeud(L,BC.Id)
Répéter
// Je monte dans l’arbre et je calcule le nombre d’occurrence du bloc dans l’arbre
n <- NbreOccurrence ( NC.Val)
Si n égal 1 Alors
// Je cherche dans BG le bloc qui a le même identificateur que NC
BC <- Chercher(NC.Val)
Pour i<- 1 jusqu’à Dimention(BC.Conex) faire
Si BC.Conex.Co[i] différent du père de BC Alors
Si i égal 1 alors
// On ajoute le fils et on retourne un pointeur sur lui
NS <- AjouterFils(L,BC.Conex.Co[i])
Sinon
AjouterFrère(L,BC.Conex.Co[i])
FinSi

197
FinSi
FinPour
FinSi
Si NS est différent du Null Alors
NC <- NS
Sinon
// On traite le frère s’il existe, ou on remonte dans l’arbre et on cherche un nœud dont
le frère n’a pas été traité
NC <- ChercherFrere()
FinSi
NS <- Null
Jusqu’à NC égal à la racine

Si on veut appliquer l’algorithme précédent sur notre exemple, on obtient le résultat


suivant :

B1

B2

B3

B4
Si on veut appliquer l’algorithme sur l’exemple suivant :

B1 B2 B3 B4
0 1 GY 1 0

1
C I C I
B5
On obtient l’arbre suivant

198
B1

B2

B3 B5

B4 B5 B3

B2 B4
Maintenant vient l’étape de la recherche des parcours. Pour cela, on se sert d’une pile
qui contiendra les nœuds visités, et les parcours trouvés seront enregistrés dans un tableau de
listes (ListeParcours). D’autre part, les boucles seront stockées dans un autre tableau de listes
(ListeBoucle)
En parallèle, on opère à un classement décroissant des parcours trouvés. Le premier
élément de chaque nœud contient la longueur du parcours, et un tableau contiendra les
numéros des listes ainsi triées. Tout ceci s’effectuera à l’intérieur de la fonction
SauvegarderParcours.

Noeud NC
Tableau Nœud : ListeParcours
NC <- Racine(L)
Empiler(PileParc, NC)
Répéter
NC <- NC.Fils
Si NC différent Null Alors
Si Appartient (NC, PileParcours) est vrai Alors
SauvegarderBoucle(ListeBoucle)
FinSi
Empiler(PileParc, NC)

Sinon
SauvegarderParcours(ListeParcours)
NC <- Dépiler (PileParc)
Répéter
NC <- NC.Frere
Si NC différent Null Alors
Empiler (PileParc, Nc)
Sinon
NC <- Pere(NC)
Dépiler (PileParc)
FinSi
Jusqu’à ce que NC égal Racine(L)

199
FinSi
Jusqu’à ce que NC égal Racine(L)

Etape 3 ‘Application de l’expertise’

Une fois que nous avons construit l’arbre, il suffit d’appliquer l’expertise permettant
d’affecter la causalité au bond-graph, comme le montre l’algorithme suivant.

Chaîne BTr // Chaîne stockant les blocs traités


Nœud NC
Entier i
Pour i <- 0 jusqu’à Longeur(ListeParcours) Faire
NC <- Lire(ListeParcours[ i])
Répéter
Si Appartient (NC, BTr) est Faux Alors
// Appliquer l’expertise
// Puis ranger le bloc dans la chaîne BTr
Ranger (NC.Val, BTr)
FinSi
NC <- NC.Fils
Jusqu’à ce NC égal Null
FinPour

200
Annexe C

IMPLEMENTATION DES ALGORITHMES EN LANGAGE JAVA

Cette annexe présente une implémentation des algorithmes établis, lors de la phase
d’analyse, en langage JAVA.

/* Classe ModelBG.java */

package BondGraph;

import java.util.*;
import java.util.Iterator;
import java.util.List;
import java.sql.Date;
import java.lang.Double;
import org.jdom.Element;
import XML_Package.*;
import java.io.*;
import BondGraph.*;

public class ModelBG{

int id;
String nom;
String source;
String typeCausalite;

private String str = "";


private String fichier = "";
private Element elt = new Element("aa");

/**
* le constructeur par défaut de la classe
*/
public ModelBG(){
id = 1;
typeCausalite = "A";
nom = "";
source = "";
}
/**
* le constructeur de la classe
*/
public ModelBG(String fichier){
this.fichier = fichier;
id = 1;
nom = "";
source = "";
typeCausalite = "A";
}
/**
* le constructeur de la classe
*/

201
public ModelBG(String fichier, int id, String nom, String source,String
c){
this.id = id;
this.nom = nom;
this.source = source;
this.fichier = fichier;
this.typeCausalite = c;
}
/**
* la methode set de la variable fichier
*/
public void setFichier(String fichier){
this.fichier = fichier;
}
/**
* la methode set de la variable typeCausalite
*/
public void setTypeCausalite(String typeCausalite){
this.typeCausalite = typeCausalite;
}
/**
* la methode set de la variable id
*/
public void setId(int id){
this.id = id;
}
/**
* la methode set de la variable nom
*/
public void setNom(String nom){
this.nom = nom;
}
/**
* la methode set de la variable source
*/
public void setSource(String source){
this.source = source;
}
/**
* la methode get de la variable typeCausalite
*/
public String getTypeCausalite(){
return typeCausalite;
}
/**
* la methode get de la variable fichier
*/
public String getFichier(){
return this.fichier;
}
/**
* la methode get de la variable id
*/
public int getId(){
return id;
}
/**
* la methode get de la variable nom
*/
public String getNom(){
return nom;

202
}
/**
* la methode get de la variable source
*/
public String getSource(){
return source;
}
/**
* la methode idMax de la classe
*/
public int idMax() throws Exception{
try{
XML xml= new XML();
return xml.chercher_idmax(this.fichier);
}catch(Exception ex){return 0;}
}

/**
* la methode ajouter de la classe
*/
public boolean ajouter() throws Exception{
try{
XML xml= new XML();
File file = new File(this.fichier);
if(!file.exists()) xml.creerXML(this.fichier, "ModelBGs");
xml= new XML(this.fichier);
xml.courant = xml.addNoeud(xml.racine, "ModelBG", "");
//ajouter l'attribut id
xml.add_Attribut(xml.courant,"id", this.id+"");
//ajouter l'element nom
xml.add_noeud(xml.courant,"nom", this.nom+"");
//ajouter l'element source
xml.add_noeud(xml.courant,"source", this.source+"");
//ajouter l'element typeCausalite
xml.add_noeud(xml.courant,"typeCausalite", this.typeCausalite+"");
xml.save(this.fichier);
return true;
}catch(Exception ex){return false;}
}

/**
* la methode supprimer de la classe
*/
public boolean supprimer() throws Exception{
File file = new File(this.fichier);
try{
if(file.exists()){
XML xml= new XML(this.fichier);
if(xml.search("ModelBGs","ModelBG", "id", this.id+"")!=null){
xml.courant = xml.search("ModelBGs","ModelBG", "id",
this.id+"");
xml.racine.removeContent(xml.courant);
xml.racine.removeChild(""+xml.courant);
xml.save(this.fichier);
return true;
}
return false;
}
return false;
}catch(Exception ex){return false;}
}

203
/**
* la methode modifier de la classe
*/
public boolean modifier() throws Exception{
try{
File file = new File(this.fichier);
if(file.exists()){
XML xml= new XML(this.fichier);
if(xml.search("ModelBGs","ModelBG", "id", this.id+"")!=null){
xml.courant = xml.search("ModelBGs","ModelBG", "id",
this.id+"");
//modification de l'attribut id
xml.courant.getAttribute("id").setValue(this.id+"");
//modification de l'element nom
xml.courant.getChild("nom").setText(this.nom+"");
//modification de l'element source
xml.courant.getChild("source").setText(this.source+"");
//modification de l'element typeCausalite

xml.courant.getChild("typeCausalite").setText(this.typeCausalite+"");
xml.save(this.fichier);
return true;
}
return false;
}
return false;
}catch(Exception ex){return false;}
}

/**
* la methode lister de la classe (retourne une liste des objets du
fichier XML)
*/
public List lister(){
try{
File file = new File(this.fichier);
if(file.exists()){
ModelBG obj = new ModelBG(this.fichier);
List listeElmt=new ArrayList();
List listeObjet=new ArrayList();
Iterator itr;//itr pointe sur les elts de la list
Element parcourirElmt= new Element("aa");
List xmlListe= new ArrayList();

XML xml= new XML(this.fichier);


List liste = xml.racine.getChildren();
Iterator it = liste.iterator();//i pointe sur les elts de la
list
Element parcourir= new Element("aa");
while (it.hasNext()){
parcourir = (Element)it.next();
//recuperation de l'attribut id

obj.setId(Integer.parseInt(parcourir.getAttributeValue("id")));
//recuperation de l'element nom
obj.setNom(parcourir.getChildText("nom"));
//recuperation de l'element source
obj.setSource(parcourir.getChildText("source"));
//recuperation de l'element typeCausalite

204
obj.setTypeCausalite(parcourir.getChildText("typeCausalite"));
listeObjet.add(obj);
obj=new ModelBG(this.fichier);
}
if(listeObjet.size() < 1) return null;
return listeObjet;
}
return null;
}catch(Exception ex){return null;}
}

/**
* la methode rechercherParId de la classe (retourne un objet qui
contien la chaine de caractaire)
*/
public ModelBG rechercherParId(String aRechercher){
try{
File file = new File(this.fichier);
if(file.exists()){
ModelBG obj = new ModelBG(this.fichier);

XML xml= new XML(this.fichier);


Element parcourir= new Element("aa");
if(xml.search("ModelBGs","ModelBG", "id", aRechercher)!=null){
parcourir = xml.search("ModelBGs","ModelBG", "id",
aRechercher);
//recuperation de l'attribut id

obj.setId(Integer.parseInt(parcourir.getAttributeValue("id")));
//recuperation de l'element nom
obj.setNom(parcourir.getChildText("nom"));
//recuperation de l'element source
obj.setSource(parcourir.getChildText("source"));
//recuperation de l'element typeCausalite

obj.setTypeCausalite(parcourir.getChildText("typeCausalite"));
return obj;
}
return null;
}
return null;
}catch(Exception ex){ return null;}
}

/**
* la methode rechercherParMotCle de la classe (retourne un objet qui
contient la chaine de caractaire)
*/
public List rechercherParMotCle(String motCle, String aRechercher){
try{
File file = new File(this.fichier);
if(file.exists()){
ModelBG obj = new ModelBG(this.fichier);
List listeElmt;
List listeObjet=new ArrayList();
Iterator itr;//itr pointe sur les elts de la list
Element parcourirElmt= new Element("aa");
List xmlListe= new ArrayList();

XML xml= new XML(this.fichier);

205
List liste = xml.racine.getChildren();
Iterator it = liste.iterator();//i pointe sur les elts de la
list
Element parcourir= new Element("aa");
boolean ok = false;
while (it.hasNext())
{
parcourir = (Element)it.next();
if(motCle.equals("nom")){
if(aRechercher.equals(parcourir.getChildText("nom"))){
ok = true;
}
}
if(motCle.equals("source")){

if(aRechercher.equals(parcourir.getChildText("source"))){
ok = true;
}
}
if(ok)
{ //recuperation de l'attribut id

obj.setId(Integer.parseInt(parcourir.getAttributeValue("id")));
//recuperation de l'element nom
obj.setNom(parcourir.getChildText("nom"));
//recuperation de l'element source
obj.setSource(parcourir.getChildText("source"));
//recuperation de l'element typeCausalite
obj.setSource(parcourir.getChildText("typeCausalite"));

listeObjet.add(obj);
obj=new ModelBG(this.fichier);
ok = false;
}
}
return listeObjet;
}
return null;
}catch(Exception ex){return null;}
}

/**
* la methode AffecterCausalite reçoit un paramètre indiquant le type
de la causalité
* désirée intégrale ou dérivée et elle retourne false si une erreur
s'est produite sinon true
*/

public boolean AffecterCausalite(String c,String path) throws


Exception
{
try
{
Elemen elt = new Elemen(path + "Element.xml");
Jonction jct = new Jonction(path + "Jonction.xml");
Lien l = new Lien(path + "Lien.xml");
List liste = new ArrayList();
String s = "";
int NC = 0, NCE = 0, NCS = 0;
// Pour les Se
liste = elt.rechercherParMotCle("type","Se");

206
for(int j = 0; j<liste.size(); j++)
{
elt = (Elemen)liste.get(j);
elt.AffecterCausalite(path,"1");

s = elt.getJonction();
jct = jct.rechercherParId(s);
NC = jct.NbConnexion(path);
NCE = jct.NbConnexionE(path);NCS =
jct.NbConnexionS(path);
if (s.startsWith("1")) //Jonction de type 1
{

if (NC==2){
if(NCE==2)
{

jct.setConflitcausal("011");
jct.modifier();
}
else
{
String cnx =
jct.Connexion(path);
String ss = "";

while(cnx.length()>0)
{
ss =
cnx.substring(0,cnx.indexOf(","));
if
(!ss.equals(elt.getId()))
{

l.setCausalite(jct.getId(),ss,"1",path);
break;//Cette
connexion sera forcément sortante
}
else
cnx =
cnx.substring(cnx.indexOf(",")+1,cnx.length());

}}
}
if(s.startsWith("0")) //Jonction de type 0
{
if(NCE == 2) //il y a un conflit causal
{
jct.setConflitcausal("010");
jct.modifier();
String cnx = jct.Connexion(path);
String ss = "";
while(cnx.length()>0)
{
ss =
cnx.substring(0,cnx.indexOf(","));
if (!ss.equals(elt.getId()))
{

207
if((ss.startsWith("R")) ||
(ss.startsWith("C")) || (ss.startsWith("I")) )
{
elt =
elt.rechercherParId(ss);

elt.AffecterCausalite(path,"1");
}
if(ss.startsWith("Sf") )
{
elt =
elt.rechercherParId(ss);

elt.AffecterCausalite(path,"0");

if((ss.startsWith("0")) ||
(ss.startsWith("1")))
{

l.setCausalite(jct.getId(),ss,"1",path);
}

cnx =
cnx.substring(cnx.indexOf(",")+1,cnx.length());
}
}
else
{
String cnx = jct.Connexion(path);
String ss = "";
while(cnx.length()>0)
{
ss =
cnx.substring(0,cnx.indexOf(","));
if (!ss.equals(elt.getId()))
{

if((ss.startsWith("R")) ||
(ss.startsWith("C")) || (ss.startsWith("I")) )
{
elt =
elt.rechercherParId(ss);

elt.AffecterCausalite(path,"1");

}
if((ss.startsWith("0")) ||
(ss.startsWith("1")))
{

l.setCausalite(jct.getId(),ss,"1",path);
}

cnx =
cnx.substring(cnx.indexOf(",")+1,cnx.length());

208
}

}// Fin affectation Se

//Affectation de la causalité des Sf


liste = elt.rechercherParMotCle("type","Sf");

for(int j = 0; j<liste.size(); j++)


{
elt = (Elemen)liste.get(j);
elt.AffecterCausalite(path,"0");
s = elt.getJonction();
jct = jct.rechercherParId(s);
NC = jct.NbConnexion(path);
NCS = jct.NbConnexionS(path);
if (s.startsWith("0")) //Jonction de type 0
{

if (NC == 2)
if(NCS == 2)
{
jct.setConflitcausal("001");
jct.modifier();
}
else
{
String cnx =
jct.Connexion(path);
String ss = "";
while(cnx.length()>0)
{
ss =
cnx.substring(0,cnx.indexOf(","));
if
(!ss.equals(elt.getId()))
{

l.setCausalite(jct.getId(),ss,"0",path); //Cette connexion sera


forcément entrante
break;
}
else
cnx =
cnx.substring(cnx.indexOf(",")+1,cnx.length());
}

}
}

if(s.startsWith("1")) //Jonction de type 1


{
if(NCS == 2) //il y a un conflit causal
{
jct.setConflitcausal("100");
jct.modifier();
String cnx = jct.Connexion(path);
String ss = "";

209
while(cnx.length()>0)
{
ss =
cnx.substring(0,cnx.indexOf(","));
if (!ss.equals(elt.getId()))
{

if((ss.startsWith("R")) ||
(ss.startsWith("C")) || (ss.startsWith("I")) )
{
elt =
elt.rechercherParId(ss);

elt.AffecterCausalite(path,"0");

}
if((ss.startsWith("0")) ||
(ss.startsWith("1")))
{

l.setCausalite(jct.getId(),ss,"0",path);
}
}

cnx =
cnx.substring(cnx.indexOf(",")+1,cnx.length());
}
}
else
{
String cnx = jct.Connexion(path);
String ss = "";
while(cnx.length()>0)
{
ss =
cnx.substring(0,cnx.indexOf(","));
if (!ss.equals(elt.getId()))
{

if((ss.startsWith("R")) ||
(ss.startsWith("C")) || (ss.startsWith("I")) )
{
elt =
elt.rechercherParId(ss);

elt.AffecterCausalite(path,"0");

}
if((ss.startsWith("0")) ||
(ss.startsWith("1")))
{

l.setCausalite(jct.getId(),ss,"0",path);
}
}

cnx =
cnx.substring(cnx.indexOf(",")+1,cnx.length());
}

210
}

}
}

//Affectation de la causalité pour les C


//------------ | Cas de l'affectation d'une causalité
intégrale |--------------
if (c.equals("I")){

this.setTypeCausalite("I");
this.modifier();
liste = elt.rechercherParMotCle("type","C");

for(int j = 0; j<liste.size(); j++)


{
elt = (Elemen)liste.get(j);
s = elt.getCausalite(path);
if(s.equals("A"))
{
s = elt.getJonction();
jct = jct.rechercherParId(s);
NC = jct.NbConnexion(path);
NCE = jct.NbConnexionE(path);
if(s.startsWith("1"))
{
if (NCE == NC - 1)

elt.AffecterCausalite(path,"1");
else
elt.AffecterCausalite(path,"0");

}
if(s.startsWith("0"))
if (NCE == 1)
{
elt.AffecterCausalite(path,"1");

//Les autres connexions seront


entrante
String cnx = jct.Connexion(path);
String ss = "";
while(cnx.length()>0)
{
ss =
cnx.substring(0,cnx.indexOf(","));
if (!ss.equals(elt.getId()))
{

if((ss.startsWith("R")) || (ss.startsWith("I")) ||
(ss.startsWith("C")))
{
elt =
elt.rechercherParId(ss);

elt.AffecterCausalite(path,"1");

if((ss.startsWith("0")) || (ss.startsWith("1")))

211
{

l.setCausalite(jct.getId(),ss,"1",path);
}
}

cnx =
cnx.substring(cnx.indexOf(",")+1,cnx.length());
}

}
else
{
elt.AffecterCausalite(path,"0");
elt.modifier();
//Les autres connexions seront
entrante
String cnx = jct.Connexion(path);
String ss = "";
while(cnx.length()>0)
{
ss =
cnx.substring(0,cnx.indexOf(","));
if (!ss.equals(elt.getId()))
{

if((ss.startsWith("R")) || (ss.startsWith("I"))||
(ss.startsWith("C")) )
{
elt =
elt.rechercherParId(ss);

elt.AffecterCausalite(path,"1");

if((ss.startsWith("0")) || (ss.startsWith("1")))
{

l.setCausalite(jct.getId(),ss,"1",path);
}
}

cnx =
cnx.substring(cnx.indexOf(",")+1,cnx.length());
}

}
}
//Affectation de la causalité pour les I
liste = elt.rechercherParMotCle("type","I");

for(int j = 0; j<liste.size(); j++)


{
elt = (Elemen)liste.get(j);
s = elt.getCausalite(path);
if(s.equals("A"))

212
{
s = elt.getJonction();
jct = jct.rechercherParId(s);
NC = jct.NbConnexion(path);
NCS = jct.NbConnexionS(path);
if(s.startsWith("0"))
{
if (NCS == NC - 1)

elt.AffecterCausalite(path,"0");
else
elt.AffecterCausalite(path,"1");

}
if(s.startsWith("1"))
if (NCS == 1)
{
elt.AffecterCausalite(path,"0");

//Les autres connexions seront


sortante
String cnx = jct.Connexion(path);
String ss = "";
while(cnx.length()>0)
{
ss =
cnx.substring(0,cnx.indexOf(","));
if (!ss.equals(elt.getId()))
{

if((ss.startsWith("R")) || (ss.startsWith("I")) )
{
elt =
elt.rechercherParId(ss);

elt.AffecterCausalite(path,"0");

if((ss.startsWith("0")) || (ss.startsWith("1")))
{

l.setCausalite(jct.getId(),ss,"0",path);
}
}

cnx =
cnx.substring(cnx.indexOf(",")+1,cnx.length());
}

}
else
{
elt.AffecterCausalite(path,"1");

//Les autres connexions seront


entrante
String cnx = jct.Connexion(path);
String ss = "";
while(cnx.length()>0)

213
{
ss =
cnx.substring(0,cnx.indexOf(","));
if (!ss.equals(elt.getId()))
{

if((ss.startsWith("R")) || (ss.startsWith("I")) )
{
elt =
elt.rechercherParId(ss);

elt.AffecterCausalite(path,"0");

if((ss.startsWith("0")) || (ss.startsWith("1")))
{

l.setCausalite(jct.getId(),ss,"0",path);
}
}

cnx =
cnx.substring(cnx.indexOf(",")+1,cnx.length());
}

}
}
//Fin affectation I
}

//------------ | Cas de l'affectation d'une causalité


dérivée |--------------

//Affectation de la causalité pour les I


if (c.equals("D"))
{
this.setTypeCausalite("D");
this.modifier();
liste = elt.rechercherParMotCle("type","I");

for(int j = 0; j<liste.size(); j++)


{
elt = (Elemen)liste.get(j);
s = elt.getCausalite(path);
if(s.equals("A"))
{
s = elt.getJonction();
jct = jct.rechercherParId(s);
NC = jct.NbConnexion(path);
NCE = jct.NbConnexionE(path);
if(s.startsWith("1"))
{
if (NCE == NC - 1)

elt.AffecterCausalite(path,"1");
else

214
elt.AffecterCausalite(path,"0");

}
if(s.startsWith("0"))
if (NCE == 1)
{
elt.AffecterCausalite(path,"1");

//Les autres connexions seront


entrante
String cnx = jct.Connexion(path);
String ss = "";
while(cnx.length()>0)
{
ss =
cnx.substring(0,cnx.indexOf(","));
if (!ss.equals(elt.getId()))
{

if((ss.startsWith("R")) || (ss.startsWith("I")) ||
(ss.startsWith("C")))
{
elt =
elt.rechercherParId(ss);

elt.AffecterCausalite(path,"1");

if((ss.startsWith("0")) || (ss.startsWith("1")))
{

l.setCausalite(jct.getId(),ss,"1",path);
}
}

cnx =
cnx.substring(cnx.indexOf(",")+1,cnx.length());
}

}
else
{
elt.AffecterCausalite(path,"0");
elt.modifier();
//Les autres connexions seront
entrante
String cnx = jct.Connexion(path);
String ss = "";
while(cnx.length()>0)
{
ss =
cnx.substring(0,cnx.indexOf(","));
if (!ss.equals(elt.getId()))
{

if((ss.startsWith("R")) || (ss.startsWith("I"))||
(ss.startsWith("C")) )
{

215
elt =
elt.rechercherParId(ss);

elt.AffecterCausalite(path,"1");

if((ss.startsWith("0")) || (ss.startsWith("1")))
{

l.setCausalite(jct.getId(),ss,"1",path);
}
}

cnx =
cnx.substring(cnx.indexOf(",")+1,cnx.length());
}

}
}
//Fin affectation I
//Affectation de la causalité pour les C
liste = elt.rechercherParMotCle("type","C");

for(int j = 0; j<liste.size(); j++)


{
elt = (Elemen)liste.get(j);
s = elt.getCausalite(path);
if(s.equals("A"))
{
s = elt.getJonction();
jct = jct.rechercherParId(s);
NC = jct.NbConnexion(path);
NCS = jct.NbConnexionS(path);
if(s.startsWith("0"))
{
if (NCS == NC - 1)

elt.AffecterCausalite(path,"0");
else
elt.AffecterCausalite(path,"1");

}
if(s.startsWith("1"))
if (NCS == 1)
{
elt.AffecterCausalite(path,"0");

//Les autres connexions seront


sortante
String cnx = jct.Connexion(path);
String ss = "";
while(cnx.length()>0)
{
ss =
cnx.substring(0,cnx.indexOf(","));
if (!ss.equals(elt.getId()))

216
{

if((ss.startsWith("R")) || (ss.startsWith("C")) )
{
elt =
elt.rechercherParId(ss);

elt.AffecterCausalite(path,"0");

if((ss.startsWith("0")) || (ss.startsWith("1")))
{

l.setCausalite(jct.getId(),ss,"0",path);
}
}

cnx =
cnx.substring(cnx.indexOf(",")+1,cnx.length());
}

}
else
{
elt.AffecterCausalite(path,"1");

//Les autres connexions seront


entrante
String cnx = jct.Connexion(path);
String ss = "";
while(cnx.length()>0)
{
ss =
cnx.substring(0,cnx.indexOf(","));
if (!ss.equals(elt.getId()))
{

if((ss.startsWith("R")) || (ss.startsWith("C")) )
{
elt =
elt.rechercherParId(ss);

elt.AffecterCausalite(path,"0");

if((ss.startsWith("0")) || (ss.startsWith("1")))
{

l.setCausalite(jct.getId(),ss,"0",path);
}
}

cnx =
cnx.substring(cnx.indexOf(",")+1,cnx.length());
}

217
}

}
}
//Fin affectation C
}
//Affectation de la causalité aux jonctions
//Affectation de la causalité aux jonctions de type 1
liste = jct.rechercherParMotCle("type","1");
for(int j = 0; j<liste.size(); j++)
{
jct = (Jonction)liste.get(j);
NCS = jct.NbConnexionS(path);
if(NCS == 0)
{
String cnx = jct.Connexion(path);
String ss = "";
while(cnx.length()>0)
{
ss = cnx.substring(0,cnx.indexOf(","));
if((ss.startsWith("0")) ||
(ss.startsWith("1")))
{

if(l.setCausalite(jct.getId(),ss,"1",path))
{
cnx =
cnx.substring(cnx.indexOf(",")+1,cnx.length());

while(cnx.length()>0)
{
ss =
cnx.substring(0,cnx.indexOf(","));

if((ss.startsWith("0")) || (ss.startsWith("1")))
{

l.setCausalite(jct.getId(),ss,"0",path);
}
cnx =
cnx.substring(cnx.indexOf(",")+1,cnx.length());
}
}
}
cnx =
cnx.substring(cnx.indexOf(",")+1,cnx.length());
}

}
} //Fin de l'affectation causalité des jonctions de type 1

//Affectation de la causalité aux jonctions de type 0

liste = jct.rechercherParMotCle("type","0");
for(int j = 0; j<liste.size(); j++)
{
jct = (Jonction)liste.get(j);
NCE = jct.NbConnexionS(path);
if(NCE == 0)
{
String cnx = jct.Connexion(path);

218
String ss = "";
while(cnx.length()>0)
{
ss = cnx.substring(0,cnx.indexOf(","));
if((ss.startsWith("0")) ||
(ss.startsWith("1")))
{

if(l.setCausalite(jct.getId(),ss,"0",path))
{
cnx =
cnx.substring(cnx.indexOf(",")+1,cnx.length());

while(cnx.length()>0)
{
ss =
cnx.substring(0,cnx.indexOf(","));

if((ss.startsWith("0")) || (ss.startsWith("1")))
{

l.setCausalite(jct.getId(),ss,"1",path);
}
cnx =
cnx.substring(cnx.indexOf(",")+1,cnx.length());
}
}
}
cnx =
cnx.substring(cnx.indexOf(",")+1,cnx.length());
}

}
} //Fin de l'affectation causalité des jonctions de type 0

//Fin affectation causalité aux jonctions


//Affectation de la causalité pour les R
liste = elt.rechercherParMotCle("type","R");

for(int j = 0; j<liste.size(); j++)


{
elt = (Elemen)liste.get(j);
s = elt.getCausalite(path);
if(s.equals("A"))
{
s = elt.getJonction();
jct = jct.rechercherParId(s);

NCS = jct.NbConnexionS(path);
NCE = jct.NbConnexionE(path);
if (s.startsWith("1"))
{
if (NCS == 1)
elt.AffecterCausalite(path,"0");
else
elt.AffecterCausalite(path,"1");
}
if (s.startsWith("0"))
{
if (NCE== 1)
elt.AffecterCausalite(path,"1");

219
else
elt.AffecterCausalite(path,"0");

}
}
}
//Fin affectation R

return true;
}catch(Exception ex){return false;}
}

/**
* la methode SupprimerCausalite permet de transformer un BG causal en
un BG acausal
*/
public boolean SupprimerCausalite(String path) throws Exception
{
try
{
Lien l = new Lien(path + "Lien.xml");
List liste = new ArrayList();

this.setTypeCausalite("A");
this.modifier();
liste = l.lister();
for(int j = 0; j<liste.size(); j++)
{
l = (Lien)liste.get(j);
l.setCausalite("A");
l.modifier();
}
return true;
}catch(Exception ex){return false;}
}

/**
* la methode InverserCausalite permet d'inverser la causalité d'un BG
retourne false dans le cas
* d'un BG acausal
*/
public boolean InverserCausalite(String path) throws Exception
{
try
{
String c = this.getTypeCausalite();
if(c.equals("I"))
{
this.AffecterCausalite("D",path);
return true;
}
if(c.equals("D"))
{
this.AffecterCausalite("I",path);
return true;
}
return false;
}catch(Exception ex){return false;}
}
public String lire(String pile1)
{

220
if(pile1.length()== 0) return "";
pile1 = pile1.substring(0,pile1.lastIndexOf(","));
return
pile1.substring(pile1.lastIndexOf(",")+1,pile1.length());

}
public String depiler(String pile1)
{
if(pile1.length()== 0) return "";
pile1 = pile1.substring(0,pile1.lastIndexOf(","));
return pile1.substring(0,pile1.lastIndexOf(",")+1);

}
public boolean estMarque(String sMarque,String s)
{
while(sMarque.length()>0)
{
if(s.equals(lire(sMarque)))
return true;
sMarque = depiler(sMarque);
}
return false;
}

/**
* la methode RechercherCCDs permet de rechercher les CCDs d'un BG
*/
public boolean RechercherCCDs(String path) throws Exception
{
try
{
Jonction jct = new Jonction (path + "Jonction.xml");
Jonction jcourant = new Jonction (path + "Jonction.xml");
Lien l = new Lien(path + "Lien.xml");
Elemen el = new Elemen(path + "Element.xml");
CCD chemin = new CCD(path + "CCD.xml");
String pile1 = "",cnx = "",eltE = "",eltS = "",causE =
"",causJ = "",PassJct = "",listeGY = "",listeLien= "",listeOrient="";
String listeTF = "",liens = "",parcours = "",nSpec1 =
"",nSpec2 = "",nSpec3 = "",ext1 = "",ext2 = "",s = "",ss = "";
String info = "", listeVar = "", vars = "", orients =
"",nMarque = "";
String tmp = "",varSuivie = "",tmp2 = "";
List liste = new ArrayList();
boolean ok = false,depile = false,GYTF = false;

liste = jct.lister();
for(int i = 0; i<liste.size(); i++)
{
listeTF = "";listeGY = "";listeLien = "";listeVar =
"";varSuivie = "e";
pile1 = "";parcours = "";liens = "";listeOrient =
"";PassJct="";
eltE = "";eltS = "";causE = "E";causJ = "S";nMarque
= "";
jct = (Jonction)liste.get(i);
cnx = jct.Connexion(path);
System.out.println("Jonction ::" + jct.getId());
//recherche des connexions à causalité sortantes

while(cnx.length()>0)

221
{
ss = cnx.substring(0,cnx.indexOf(","));
if((ss.startsWith("I")) ||
(ss.startsWith("C")) || (ss.startsWith("R")))
{
el = el.rechercherParId(ss);
s = el.getCausalite(path);
if (s.equals("0"))
eltS = eltS + el.getId() + ",";
if (s.equals("1"))
eltE = eltE + el.getId()+ ",";
}
if (ss.startsWith("Se"))
{
el = el.rechercherParId(ss);
eltS = eltS + el.getId()+ ",";
}
if (ss.startsWith("Sf"))
{
el = el.rechercherParId(ss);
eltE = eltE + el.getId()+ ",";

if((ss.startsWith("0")) ||
(ss.startsWith("1")))
{
info = jct.InfoConnexion(ss,path);
s = info.substring(0,info.indexOf(","));

if (s.equals("S"))
{
pile1 = pile1 + ss + ",";
info =
info.substring(info.indexOf(",")+1,info.length());
s =
info.substring(0,info.indexOf(","));
PassJct = PassJct + s +",";
if(s.equals("no"))
{
info =
info.substring(info.indexOf(",")+1,info.length());
s =
info.substring(0,info.indexOf(","));

liens = liens + s + ",";


info =
info.substring(info.indexOf(",")+1,info.length());
s =
info.substring(0,info.indexOf(","));
orients = orients + s + ",";

}
else
{

info =
info.substring(info.indexOf(",")+1,info.length());//stockage des liens
s =
info.substring(0,info.indexOf(","));

222
liens = liens + s + ",";
info =
info.substring(info.indexOf(",")+1,info.length());
s =
info.substring(0,info.indexOf(","));

liens = liens + s + ",";


info =
info.substring(info.indexOf(",")+1,info.length());
s =
info.substring(0,info.indexOf(","));
orients = orients + s + ","
+ s + ",";

}
}
}
cnx =
cnx.substring(cnx.indexOf(",")+1,cnx.length());
}
//Enregistrement des chemins causaux internes
if((eltE.length()>0) && (eltS.length()>0))
{
ss = eltS;
while(ss.length()>0)
{
ext1 = ss.substring(0,ss.indexOf(","));
s = eltE;
while(s.length()>0)
{

ext2 =
s.substring(0,s.indexOf(","));
if(((!ext1.startsWith("Se")) &&
(!ext2.startsWith("Sf"))) || ((!ext1.startsWith("Sf")) &&
(!ext2.startsWith("Se"))) || ((!ext1.startsWith("Sf")) &&
(!ext2.startsWith("Sf"))) || ((!ext1.startsWith("Se")) &&
(!ext2.startsWith("Se"))))
{
el =
el.rechercherParId(ext1);
listeLien = el.getLien() +
",";
el =
el.rechercherParId(ext2);
listeLien = listeLien +
el.getLien() + ",";

if((ext1.startsWith("Se"))
|| (ext1.startsWith("Sf")))
tmp = "R,";
else
tmp = "L,";
if((ext2.startsWith("Se"))
|| (ext2.startsWith("Sf")))
tmp = tmp + "L,";
else
tmp = tmp +"R,";

chemin.setExt1(ext1);
chemin.setExt2(ext2);

223
chemin.setId(chemin.calculerId());
chemin.setListeOrient(tmp);

chemin.setListeLien(listeLien);
chemin.setListeVar("e,e,");
chemin.setListeTF("no");
chemin.setListeGY("no");

chemin.setBcl_Causalite(false);
chemin.ajouter();

}
s =
s.substring(s.indexOf(",")+1,s.length());
}
ss =
ss.substring(ss.indexOf(",")+1,ss.length());
}
}
//recherche des CCDs
//si la jonction possède des éléments à causalité
sortantes
if(eltS.length()>0)
{
listeLien = "";
//causE = "E";causJ = "S";
while(pile1.length()>0)
{
s = lire(pile1);eltE = "";
ok = false;depile = false;GYTF = false;
jcourant = jcourant.rechercherParId(s);
if ((nSpec1.length() != 0) &&
(s.equals(lire(nSpec1)))) // un noeud spécial rencontré
{
depile = true;
nSpec1 = depiler(nSpec1);
listeGY = depiler(listeGY);
//inverser les causalités recherchées
if(causE.equals("E"))
{ causE = "S";
causJ = "E";varSuivie = "f";
}
else
{ causE = "E";
causJ = "S";varSuivie = "e";
}
parcours = depiler(parcours);
listeVar = depiler(listeVar);
listeOrient = depiler(listeOrient);

parcours = depiler(parcours);
listeVar = depiler(listeVar);
listeOrient = depiler(listeOrient);

}
if ((nSpec2.length() != 0) &&
(s.equals(lire(nSpec2)))) // un noeud spécial rencontré
{

224
nSpec2 = depiler(nSpec2);
listeTF = depiler(listeTF);

parcours = depiler(parcours);
listeVar = depiler(listeVar);
listeOrient = depiler(listeOrient);

parcours = depiler(parcours);
listeVar = depiler(listeVar);
listeOrient = depiler(listeOrient);

depile = true;

}
if((nSpec3.length() != 0) &&
(s.equals(lire(nSpec3))))
{
if(!depile)
{
parcours = depiler(parcours);
listeVar = depiler(listeVar);
listeOrient =
depiler(listeOrient);
}
nSpec3 = depiler(nSpec3);
}
parcours = parcours + lire(liens) +",";
listeVar = listeVar + varSuivie + ",";
listeOrient = listeOrient + lire(orients) +
",";
liens = depiler(liens);
pile1 = depiler(pile1);

orients = depiler(orients);

if(!estMarque(nMarque,s)) //si la jonction


n'est pas déjà traitée
{

nMarque = nMarque + s + ",";//marquer


cette jonction

ss = lire(PassJct);
if(ss.startsWith("GY")) //connexion qui
passe par un gyrateur
{
GYTF = true;
tmp = lire(parcours);//inverser
l'ordre des liens
parcours = depiler(parcours);

parcours = parcours + lire(liens)


+ "," + tmp + ",";
nSpec1 = nSpec1 + lire(pile1) +
",";
listeOrient = listeOrient +
lire(orients) + ",";
orients = depiler(orients);
liens = depiler(liens);
if(causE.equals("E")) //inverser
les causalité recherchée

225
{ causE = "S";
causJ = "E";varSuivie = "f";
}
else
{ causE = "E";
causJ = "S";varSuivie = "e";
}
listeGY = listeGY + ss + ",";
listeVar = listeVar + varSuivie +
",";
}
if(ss.startsWith("TF")) //connexion qui
passe par un transformateur
{
GYTF = true;
tmp = lire(parcours);//inverser
l'ordre des liens
parcours = depiler(parcours);

parcours = parcours + lire(liens)


+ "," + tmp + ",";
nSpec2 = nSpec2 + lire(pile1) +
",";
listeTF = listeTF + ss + ",";
listeVar = listeVar + varSuivie +
",";
liens = depiler(liens);
}
PassJct = depiler(PassJct);
cnx = jcourant.Connexion(path);
//recherche les éléments à causalité
causE et les jonctions à causalité causJ
while(cnx.length()>0)
{
ss =
cnx.substring(0,cnx.indexOf(","));
if((ss.startsWith("I")) ||
(ss.startsWith("C")) || (ss.startsWith("R")))
{
el = el.rechercherParId(ss);
s = el.getCausalite(path);
if ((s.equals("0")) &&
(causE.equals("S")))
eltE = eltE +
el.getId() + ",";
if ((s.equals("1")) &&
(causE.equals("E")))
eltE = eltE +
el.getId()+ ",";
}
if ((ss.startsWith("Se")) &&
(causE.equals("S")))
{
el = el.rechercherParId(ss);
eltE = eltE + el.getId()+
",";
}
if ((ss.startsWith("Sf"))&&
(causE.equals("E")))
{
el = el.rechercherParId(ss);

226
eltE = eltE + el.getId()+
",";

if((ss.startsWith("0")) ||
(ss.startsWith("1")))
{
if(!ss.equals(jct.getId()))
{info =
jct.InfoConnexion(ss,path);
s =
info.substring(0,info.indexOf(","));
if (s.equals(causJ))
{
ok = true;
pile1 = pile1 + ss +
","; //empiler la jonction
info =
info.substring(info.indexOf(",")+1,info.length());
s =
info.substring(0,info.indexOf(","));
PassJct = PassJct + s
+",";
if(s.equals("no"))
{
info =
info.substring(info.indexOf(",")+1,info.length());
s =
info.substring(0,info.indexOf(","));

liens = liens +
s + ",";
info =
info.substring(info.indexOf(",")+1,info.length());
s =
info.substring(0,info.indexOf(","));
orients =
orients + s + ",";
}
else
{

info =
info.substring(info.indexOf(",")+1,info.length());//stockage des liens
s =
info.substring(0,info.indexOf(","));

liens = liens +
s + ",";
info =
info.substring(info.indexOf(",")+1,info.length());
s =
info.substring(0,info.indexOf(","));

liens = liens +
s + ",";
info =
info.substring(info.indexOf(",")+1,info.length());
s =
info.substring(0,info.indexOf(","));

227
orients =
orients + s + "," + s + ",";

}
}
}

}
cnx =
cnx.substring(cnx.indexOf(",")+1,cnx.length());

}
//Sauvegarder les chemins trouvés
if(eltE.length()>0)
{
ss = eltS;
while(ss.length()>0)
{
ext1 =
ss.substring(0,ss.indexOf(","));
s = eltE;
while(s.length()>0)
{
ext2 =
s.substring(0,s.indexOf(","));

if(((!ext1.startsWith("Se")) && (!ext2.startsWith("Sf"))) ||


((!ext1.startsWith("Sf")) && (!ext2.startsWith("Se"))) ||
((!ext1.startsWith("Sf")) && (!ext2.startsWith("Sf"))) ||
((!ext1.startsWith("Se")) && (!ext2.startsWith("Se"))))
{
el =
el.rechercherParId(ext1);
listeLien =
el.getLien() + "," + parcours ;
el =
el.rechercherParId(ext2);
listeLien =
listeLien + el.getLien() + ",";

if(!chemin.existe(listeLien))

if((ext1.startsWith("Se")) || (ext1.startsWith("Sf")))
tmp
= "R," + listeOrient;
else
tmp
= "L,"+ listeOrient;

if((ext2.startsWith("Se")) || (ext2.startsWith("Sf")))
tmp
= tmp + "L,";
else
tmp
= tmp +"R,";

chemin.setExt1(ext1);

228
chemin.setExt2(ext2);

chemin.setId(chemin.calculerId());

chemin.setListeOrient(tmp);

chemin.setListeLien(listeLien);

chemin.setListeVar("e," + listeVar + varSuivie + ",");

if(listeTF.length()!=0)

chemin.setListeTF(listeTF);

if(listeGY.length()!=0)

chemin.setListeGY(listeGY);

chemin.ajouter();
}
}
s =
s.substring(s.indexOf(",")+1,s.length());
}
ss =
ss.substring(ss.indexOf(",")+1,ss.length());
}
}
//Fin suvegarde des chemins
if(ok)
{
//sauvegarder la noeud courant de
pile1 dans nSpec3
nSpec3 = nSpec3 + lire(pile1) +
",";
}
else
//la jonction ne possède pas de
connexions répondant aux critères recherchés
//depiler parcours, listevar,
listeoriens si la jonction ne passe pas par un gyrateur ou un
transformateur
if(!GYTF)
{
parcours =
depiler(parcours);
listeVar =
depiler(listeVar);
listeOrient =
depiler(listeOrient);
}

}
else
{
//Boucle de causalité détectée
chemin.setExt1(s);
chemin.setExt2(s);
chemin.setId(chemin.calculerId());

229
chemin.setListeOrient(listeOrient);
chemin.setListeLien(parcours);
chemin.setListeVar(listeVar);
chemin.setBcl_Causalite(true);
if(listeTF.length()!=0)
chemin.setListeTF(listeTF);
if(listeGY.length()!=0)
chemin.setListeGY(listeGY);
chemin.ajouter();

}
//fin du traitement du de la jonction courante
passage à la jonction suivante
}
}//Fin recherche CCD

}
return false;
}catch(Exception ex){return false;}
}

/**
* la methode RechercherBCs permet de rechercher les boucles causales
d'un BG
*/
public boolean RechercherBCs(String path) throws Exception
{
try
{
CCD chemin = new CCD(path + "CCD.xml");
BoucleCausale boucle = new BoucleCausale(path +
"BoucleCausale.xml");
List liste = new ArrayList();
String ext1 = "",ext11 = "",ext22 = "",ext2 = "", tmp =
"", s = "",ss = "",cheminValable = "", cheminAtraiter = "", cheminTraite =
"";
int id = 1, id2 = 1;

liste = chemin.lister();
//Recherche des chemins valables
for(int j = 0; j<liste.size(); j++)
{
chemin = (CCD)liste.get(j);
ext1 = chemin.getExt1();
ext2 = chemin.getExt2();
id = chemin.getId();
if(((ext1.startsWith("R")) || (ext1.startsWith("C")) ||
(ext1.startsWith("I"))) && ((ext2.startsWith("R")) ||
(ext2.startsWith("C")) || (ext2.startsWith("I"))))
cheminValable = cheminValable + id + ",";

}
while(cheminValable.length()>0)
{
s = lire(cheminValable);
if(!estMarque(cheminTraite,s))
{
chemin = chemin.rechercherParId(s);
id = chemin.getId();

230
ext1 = chemin.getExt1();
ext2 = chemin.getExt2();

//Sauvegarder cette boucle


boucle.setId(boucle.calculerId());
boucle.setExt1(ext1);
boucle.setExt2(ext2);
boucle.setCheminAller(id);
boucle.setCheminRetour(id);
if((ext1.startsWith("R")) &&
(ext2.startsWith("R")))
boucle.setBcl_algebrique(true);
else
boucle.setBcl_algebrique(false);
boucle.ajouter();
tmp = depiler(cheminValable);
//Rechercher dans cheminValable les chemins
qui ont les mêmes extrémités
while(tmp.length()>0)
{
ss = lire(tmp);
chemin = chemin.rechercherParId(ss);

ext11 = chemin.getExt1();
ext22 = chemin.getExt2();

if((ext11.equals(ext1)) ||
(ext22.equals(ext1)))
if((ext11.equals(ext2)) ||
(ext22.equals(ext2)))
{
//Sauvegarder toutes les
combinaisons possibles

boucle.setId(boucle.calculerId());
boucle.setExt1(ext1);
boucle.setExt2(ext2);
boucle.setCheminAller(id);

boucle.setCheminRetour(chemin.getId());
if((ext1.startsWith("R")) &&
(ext2.startsWith("R")))

boucle.setBcl_algebrique(true);
boucle.ajouter();

boucle.setId(boucle.calculerId());
boucle.setExt1(ext1);
boucle.setExt2(ext2);

boucle.setCheminAller(chemin.getId());

boucle.setCheminRetour(chemin.getId());
if((ext1.startsWith("R")) &&
(ext2.startsWith("R")))

boucle.setBcl_algebrique(true);
else

boucle.setBcl_algebrique(false);

231
boucle.ajouter();

//Marquer ce chemin comme


chemin traité
cheminTraite = cheminTraite
+ chemin.getId() + ",";
}
tmp = depiler(tmp);
}
}
cheminValable = depiler(cheminValable);

}
return true;
}catch(Exception ex){return false;}
}

/**
* la methode RechercherCCIs permet de rechercher les chemins causaux
indirects d'un BG
*/
public boolean RechercherCCIs(String path, String E, String S) throws
Exception
{
try
{
CCI cheminI = new CCI(path + "CCI.xml");
CCD cheminD = new CCD(path + "CCD.xml");
List liste = new ArrayList();
String pileCCD = "",pileExt = "",extCourant =
"",ccdCourant = "",pile1 = "",pile2 = "";
String pile3 = "", pile4 = "",nonValide = "", ext1 =
"",ext2 = "",tmp ="";
boolean ok = false, vide =false;

//Rechercher s'il existe des chemins directs entre E et S


liste = cheminD.lister();
for(int j = 0; j<liste.size(); j++)
{
cheminD = (CCD)liste.get(j);
ext1 = cheminD.getExt1();
ext2 = cheminD.getExt2();
if(((ext1.equals(E)) || (ext2.equals(E))) &&
((ext1.equals(S)) || (ext2.equals(S))))
nonValide = nonValide + cheminD.getId() + ",";

}
//Rechercher les chemins dont les extémités coincident avec E
liste = cheminD.lister();
for(int j = 0; j<liste.size(); j++)
{
cheminD = (CCD)liste.get(j);
ext1 = cheminD.getExt1();
ext2 = cheminD.getExt2();
if((ext1.equals(E)) &&
(!estMarque(nonValide,cheminD.getId()+"")))
{
pileCCD = pileCCD + cheminD.getId() + ",";
pileExt = pileExt + cheminD.getExt2() + ",";
}

232
if((ext2.equals(E)) &&
(!estMarque(nonValide,cheminD.getId()+"")))
{
pileCCD = pileCCD + cheminD.getId() + ",";
pileExt = pileExt + cheminD.getExt1() + ",";
}
}
while(pileCCD.length()!= 0)
{
pile1 = lire(pileCCD) + ",";
pile2 = lire(pileExt) + ",";
ccdCourant = lire(pile1);
extCourant = lire(pile2);
pileCCD = depiler(pileCCD);
pileExt = depiler(pileExt);
pile3 = "";
pile4 = "";
vide = false;
while(!vide)
{
ok = false;
liste = cheminD.lister();
for(int j = 0; j<liste.size(); j++)
{
cheminD = (CCD)liste.get(j);
ext1 = cheminD.getExt1();
ext2 = cheminD.getExt2();
tmp = "" + cheminD.getId();
if((ext1.equals(extCourant)) &&
(!tmp.equals(ccdCourant)))
{
if(ext2.equals(S))
{
//Sauvegarder le chemin indirect
tmp = cheminD.getId() + ",";

cheminI.setId(cheminI.calculerId());
cheminI.setExt1(E);
cheminI.setExt2(S);
cheminI.setListePassif(pile2);
cheminI.setListeCCD(pile1 + tmp);
cheminI.ajouter();
}
else
{
pile3 = pile3 + cheminD.getId() +
",";
pile4 = pile4 + ext2 + ",";
ok = true;
}
}
if((ext2.equals(extCourant)) &&
(!tmp.equals(ccdCourant)))
{
if(ext1.equals(S))
{
//Sauvegarder le chemin indirect

cheminI.setId(cheminI.calculerId());
cheminI.setExt1(E);
cheminI.setExt2(S);

233
cheminI.setListePassif(pile2);
cheminI.setListeCCD(pile1 +
cheminD.getId() + ",");
cheminI.ajouter();
}
else
{
pile3 = pile3 + cheminD.getId() +
",";
pile4 = pile4 + ext1 + ",";
ok = true;
}
}
}
if(pile3.length() == 0)
vide = true;
extCourant = lire(pile4);
ccdCourant = lire(pile3);
pile4 = depiler(pile4);
pile3 = depiler(pile3);
if(ok)
{
pile1 = pile1 + ccdCourant + ",";
pile2 = pile2 + extCourant + ",";
}
else
{
pile1 = depiler(pile1);
pile2 = depiler(pile2);

}
}
}
return true;
}catch(Exception ex){return false;}
}

/**
* La méthode calculerId permet de calculer l'identificateur du nouveau
BG à ajouter
*/
public int calculerId() throws Exception
{
try
{
return this.idMax()+1;

}catch(Exception ex){return 0;}


}
}

/* Classe ModelPHY.java */

package BondGraph;

import java.util.*;
import java.util.Iterator;
import java.util.List;
import java.sql.Date;
import java.lang.Double;

234
import org.jdom.Element;
import XML_Package.*;
import java.io.*;

public class ModelPHY{


int id;
String domaine;
String description;
int modelBG;
private String str = "";
private String fichier = "";
private Element elt = new Element("aa");
/**
* le constructeur par défaut de la classe
*/
public ModelPHY(){
id = 1; //
domaine = ""; //
description = ""; //
modelBG = 1; //
}
/**
* le constructeur de la classe
*/
public ModelPHY(String fichier){
this.fichier = fichier;
id = 1; //
domaine = ""; //
description = ""; //
modelBG = 1; //
}
/**
* le constructeur de la classe
*/
public ModelPHY(String fichier, int id, String domaine, String
description,int modelBG){
this.id = id;
this.domaine = domaine;
this.description = description;
this.modelBG = modelBG;
this.fichier = fichier;
}
/**
* la methode set de la variable fichier
*/
public void setFichier(String fichier){
this.fichier = fichier;
}
/**
* la methode set de la variable id
*/
public void setId(int id){
this.id = id;
}
/**
* la methode set de la variable domaine
*/
public void setDomaine(String domaine){
this.domaine = domaine;
}
/**

235
* la methode set de la variable description
*/
public void setDescription(String description){
this.description = description;
}
/**
* la methode set de la variable modelBG
*/
public void setModelBG(int modelBG){
this.modelBG = modelBG;
}
/**
* la methode get de la variable fichier
*/
public String getFichier(){
return this.fichier;
}
/**
* la methode get de la variable id
*/
public int getId(){
return id;
}
/**
* la methode get de la variable domaine
*/
public String getDomaine(){
return domaine;
}
/**
* la methode get de la variable description
*/
public String getDescription(){
return description;
}
/**
* la methode get de la variable modelBG
*/
public int getModelBG(){
return modelBG;
}
/**
* la methode idMax de la classe
*/
public int idMax() throws Exception{
try{
XML xml= new XML();
return xml.chercher_idmax(this.fichier);
}catch(Exception ex){return 0;}
}
/**
* la methode ajouter de la classe
*/
public boolean ajouter() throws Exception{
try{
XML xml= new XML();
File file = new File(this.fichier);
if(!file.exists()) xml.creerXML(this.fichier, "ModelPHYs");
xml= new XML(this.fichier);
xml.courant = xml.addNoeud(xml.racine, "ModelPHY", "");
//ajouter l'attribut id

236
xml.add_Attribut(xml.courant,"id", this.id+"");
//ajouter l'element domaine
xml.add_noeud(xml.courant,"domaine", this.domaine+"");
//ajouter l'element description
xml.add_noeud(xml.courant,"description", this.description+"");
//ajouter l'attribut modelBG
xml.add_Attribut(xml.courant,"modelBG", this.modelBG+"");
xml.save(this.fichier);
return true;
}catch(Exception ex){return false;}
}
/**
* la methode supprimer de la classe
*/
public boolean supprimer() throws Exception{
File file = new File(this.fichier);
try{
if(file.exists()){
XML xml= new XML(this.fichier);
if(xml.search("ModelPHYs","ModelPHY", "id", this.id+"")!=null){
xml.courant = xml.search("ModelPHYs","ModelPHY", "id",
this.id+"");
xml.racine.removeContent(xml.courant);
xml.racine.removeChild(""+xml.courant);
xml.save(this.fichier);
return true;
}
return false;
}
return false;
}catch(Exception ex){return false;}
}
/**
* la methode modifier de la classe
*/
public boolean modifier() throws Exception{
try{
File file = new File(this.fichier);
if(file.exists()){
XML xml= new XML(this.fichier);
if(xml.search("ModelPHYs","ModelPHY", "id", this.id+"")!=null){
xml.courant = xml.search("ModelPHYs","ModelPHY", "id",
this.id+"");
//modification de l'attribut id
xml.courant.getAttribute("id").setValue(this.id+"");
//modification de l'element domaine
xml.courant.getChild("domaine").setText(this.domaine+"");
//modification de l'element description

xml.courant.getChild("description").setText(this.description+"");
//modification de l'attribut modelBG

xml.courant.getAttribute("modelBG").setValue(this.modelBG+"");
xml.save(this.fichier);
return true;
}
return false;
}
return false;
}catch(Exception ex){return false;}
}

237
/**
* la methode lister de la classe (retourne une liste des objets du
fichier XML)
*/

public List lister(){


try{
File file = new File(this.fichier);
if(file.exists()){
ModelPHY obj = new ModelPHY(this.fichier);
List listeElmt=new ArrayList();
List listeObjet=new ArrayList();
Iterator itr;//itr pointe sur les elts de la list
Element parcourirElmt= new Element("aa");
List xmlListe= new ArrayList();

XML xml= new XML(this.fichier);


List liste = xml.racine.getChildren();
Iterator it = liste.iterator();//i pointe sur les elts de la
list
Element parcourir= new Element("aa");
while (it.hasNext()){
parcourir = (Element)it.next();
//recuperation de l'attribut id

obj.setId(Integer.parseInt(parcourir.getAttributeValue("id")));
//recuperation de l'element domaine
obj.setDomaine(parcourir.getChildText("domaine"));
//recuperation de l'element description

obj.setDescription(parcourir.getChildText("description"));
//recuperation de l'attribut modelBG

obj.setModelBG(Integer.parseInt(parcourir.getAttributeValue("modelBG")));
listeObjet.add(obj);
obj=new ModelPHY(this.fichier);
}
if(listeObjet.size() < 1) return null;
return listeObjet;
}
return null;
}catch(Exception ex){return null;}
}

/**
* la methode rechercherParId de la classe (retourne un objet qui
contien la chaine de caractaire)
*/
public ModelPHY rechercherParId(String aRechercher){
try{
File file = new File(this.fichier);
if(file.exists()){
ModelPHY obj = new ModelPHY(this.fichier);
List listeElmt;
Iterator itr;//itr pointe sur les elts de la list
Element parcourirElmt= new Element("aa");
List xmlListe= new ArrayList();
XML xml= new XML(this.fichier);
Element parcourir= new Element("aa");

238
if(xml.search("ModelPHYs","ModelPHY", "id",
aRechercher)!=null){
parcourir = xml.search("ModelPHYs","ModelPHY", "id",
aRechercher);
//recuperation de l'attribut id

obj.setId(Integer.parseInt(parcourir.getAttributeValue("id")));
//recuperation de l'element domaine
obj.setDomaine(parcourir.getChildText("domaine"));
//recuperation de l'element description

obj.setDescription(parcourir.getChildText("description"));
//recuperation de l'attribut modelBG

obj.setModelBG(Integer.parseInt(parcourir.getAttributeValue("modelBG")));
return obj;
}
return null;
}
return null;
}catch(Exception ex){return null;}
}

/**
* la methode rechercherParMotCle de la classe (retourne un objet qui
contien la chaine de caractaire)
*/
public List rechercherParMotCle(String motCle, String aRechercher){
try{
File file = new File(this.fichier);
if(file.exists()){
ModelPHY obj = new ModelPHY(this.fichier);
List listeElmt;
List listeObjet=new ArrayList();
Iterator itr;//itr pointe sur les elts de la list
Element parcourirElmt= new Element("aa");
List xmlListe= new ArrayList();
XML xml= new XML(this.fichier);
List liste = xml.racine.getChildren();
Iterator it = liste.iterator();//i pointe sur les elts de la
list
Element parcourir= new Element("aa");
boolean ok = false;
while (it.hasNext()){
parcourir = (Element)it.next();
if(motCle.equals("domaine")){

if(aRechercher.equals(parcourir.getChildText("domaine"))){
ok = true;
}
}
if(motCle.equals("description")){

if(aRechercher.equals(parcourir.getChildText("description"))){
ok = true;
}
}
if(motCle.equals("sources")){

if(aRechercher.equals(parcourir.getChildText("sources"))){
ok = true;

239
}
}
if(ok){
//recuperation de l'attribut id

obj.setId(Integer.parseInt(parcourir.getAttributeValue("id")));
//recuperation de l'element domaine
obj.setDomaine(parcourir.getChildText("domaine"));
//recuperation de l'element description

obj.setDescription(parcourir.getChildText("description"));
//recuperation de l'attribut modelBG

obj.setModelBG(Integer.parseInt(parcourir.getAttributeValue("modelBG")));
listeObjet.add(obj);
obj=new ModelPHY(this.fichier);
ok = false;
}
}
return listeObjet;
}
return null;
}catch(Exception ex){return null;}
}

/**
* La méthode calculerId permet de calculer l'identificateur du nouveau
ModelPHY à ajouter
*/
public int calculerId() throws Exception
{
try
{
return this.idMax()+1;

}catch(Exception ex){return 0;}


}
}

/* Classe ModelMath.java */

package BondGraph;

import java.util.*;
import java.util.Iterator;
import java.util.List;
import java.sql.Date;
import java.lang.Double;
import org.jdom.Element;
import XML_Package.*;
import java.io.*;

public class ModelMath{


String id;
String cci;
String ccd;
String equaEtat;
String boucleCausale;
String mtf;
private String str = "";
private String fichier = "";

240
private Element elt = new Element("aa");

/**
* le constructeur par défaut de la classe
*/
public ModelMath(){
id = "";
cci = "";
ccd = "";
equaEtat = "";
boucleCausale = "";
mtf = "";
}
/**
* le constructeur de la classe
*/
public ModelMath(String fichier){
this.fichier = fichier;
id = "";
cci = "";
ccd = "";
equaEtat = "";
boucleCausale = "";
mtf = "";
}
/**
* le constructeur de la classe
*/
public ModelMath(String fichier, String id, String cci, String ccd,
String equaEtat, String boucleCausale, String mtf){
this.id = id;
this.cci = cci;
this.ccd = ccd;
this.equaEtat = equaEtat;
this.boucleCausale = boucleCausale;
this.mtf = mtf;
this.fichier = fichier;
}
/**
* la methode set de la variable fichier
*/
public void setFichier(String fichier){
this.fichier = fichier;
}
/**
* la methode set de la variable id
*/
public void setId(String id){
this.id = id;
}
/**
* la methode set de la variable cci
*/
public void setCci(String cci){
this.cci = cci;
}
/**
* la methode set de la variable ccd
*/
public void setCcd(String ccd){
this.ccd = ccd;

241
}
/**
* la methode set de la variable equaEtat
*/
public void setEquaEtat(String equaEtat){
this.equaEtat = equaEtat;
}
/**
* la methode set de la variable boucleCausale
*/
public void setBoucleCausale(String boucleCausale){
this.boucleCausale = boucleCausale;
}
/**
* la methode set de la variable mtf
*/
public void setMtf(String mtf){
this.mtf = mtf;
}
/**
* la methode get de la variable fichier
*/
public String getFichier(){
return this.fichier;
}
/**
* la methode get de la variable id
*/
public String getId(){
return id;
}
/**
* la methode get de la variable cci
*/
public String getCci(){
return cci;
}
/**
* la methode get de la variable ccd
*/
public String getCcd(){
return ccd;
}
/**
* la methode get de la variable equaEtat
*/
public String getEquaEtat(){
return equaEtat;
}
/**
* la methode get de la variable boucleCausale
*/
public String getBoucleCausale(){
return boucleCausale;
}
/**
* la methode get de la variable mtf
*/
public String getMtf(){
return mtf;
}

242
/**
* la methode idMax de la classe
*/
public int idMax() throws Exception{
try{
XML xml= new XML();
return xml.chercher_idmax(this.fichier);
}catch(Exception ex){return 0;}
}
/**
* la methode ajouter de la classe
*/
public boolean ajouter() throws Exception{
try{
XML xml= new XML();
File file = new File(this.fichier);
if(!file.exists()) xml.creerXML(this.fichier, "ModelMaths");
xml= new XML(this.fichier);
xml.courant = xml.addNoeud(xml.racine, "ModelMath", "");
//ajouter l'attribut id
xml.add_Attribut(xml.courant,"id", this.id+"");
//ajouter l'attribut cci
xml.add_Attribut(xml.courant,"cci", this.cci+"");
//ajouter l'attribut ccd
xml.add_Attribut(xml.courant,"ccd", this.ccd+"");
//ajouter l'attribut equaEtat
xml.add_Attribut(xml.courant,"equaEtat", this.equaEtat+"");
//ajouter l'attribut boucleCausale
xml.add_Attribut(xml.courant,"boucleCausale",
this.boucleCausale+"");
//ajouter l'attribut mtf
xml.add_Attribut(xml.courant,"mtf", this.mtf+"");
xml.save(this.fichier);
return true;
}catch(Exception ex){return false;}
}

/**
* la methode supprimer de la classe
*/
public boolean supprimer() throws Exception{
File file = new File(this.fichier);
try{
if(file.exists()){
XML xml= new XML(this.fichier);
if(xml.search("ModelMaths","ModelMath", "id",
this.id+"")!=null){
xml.courant = xml.search("ModelMaths","ModelMath", "id",
this.id+"");
xml.racine.removeContent(xml.courant);
xml.racine.removeChild(""+xml.courant);
xml.save(this.fichier);
return true;
}
return false;
}
return false;
}catch(Exception ex){return false;}
}

/**

243
* la methode modifier de la classe
*/
public boolean modifier() throws Exception{
try{
File file = new File(this.fichier);
if(file.exists()){
XML xml= new XML(this.fichier);
if(xml.search("ModelMaths","ModelMath", "id",
this.id+"")!=null){
xml.courant = xml.search("ModelMaths","ModelMath", "id",
this.id+"");
//modification de l'attribut id
xml.courant.getAttribute("id").setValue(this.id+"");
//modification de l'attribut cci
xml.courant.getAttribute("cci").setValue(this.cci+"");
//modification de l'attribut ccd
xml.courant.getAttribute("ccd").setValue(this.ccd+"");
//modification de l'attribut equaEtat

xml.courant.getAttribute("equaEtat").setValue(this.equaEtat+"");
//modification de l'attribut boucleCausale

xml.courant.getAttribute("boucleCausale").setValue(this.boucleCausale+"");
//modification de l'attribut mtf
xml.courant.getAttribute("mtf").setValue(this.mtf+"");
xml.save(this.fichier);
return true;
}
return false;
}
return false;
}catch(Exception ex){return false;}
}

/**
* la methode lister de la classe (retourne une liste des objets du
fichier XML)
*/
public List lister(){
try{
File file = new File(this.fichier);
if(file.exists()){
ModelMath obj = new ModelMath(this.fichier);
List listeElmt=new ArrayList();
List listeObjet=new ArrayList();
Iterator itr;//itr pointe sur les elts de la list
Element parcourirElmt= new Element("aa");
List xmlListe= new ArrayList();

XML xml= new XML(this.fichier);


List liste = xml.racine.getChildren();
Iterator it = liste.iterator();//i pointe sur les elts de la
list
Element parcourir= new Element("aa");
while (it.hasNext()){
parcourir = (Element)it.next();
//recuperation de l'attribut id
obj.setId(parcourir.getAttributeValue("id"));
//recuperation de l'attribut cci
obj.setCci(parcourir.getAttributeValue("cci"));
//recuperation de l'attribut ccd

244
obj.setCcd(parcourir.getAttributeValue("ccd"));
//recuperation de l'attribut equaEtat

obj.setEquaEtat(parcourir.getAttributeValue("equaEtat"));
//recuperation de l'attribut boucleCausale

obj.setBoucleCausale(parcourir.getAttributeValue("boucleCausale"));
//recuperation de l'attribut mtf
obj.setMtf(parcourir.getAttributeValue("mtf"));
listeObjet.add(obj);
obj=new ModelMath(this.fichier);
}
if(listeObjet.size() < 1) return null;
return listeObjet;
}
return null;
}catch(Exception ex){return null;}
}

/**
* la methode rechercherParId de la classe (retourne un objet qui
contien la chaine de caractaire)
*/
public ModelMath rechercherParId(String aRechercher){
try{
File file = new File(this.fichier);
if(file.exists()){
ModelMath obj = new ModelMath(this.fichier);
List listeElmt;
Iterator itr;//itr pointe sur les elts de la list
Element parcourirElmt= new Element("aa");
List xmlListe= new ArrayList();

XML xml= new XML(this.fichier);


Element parcourir= new Element("aa");
if(xml.search("ModelMaths","ModelMath", "id",
aRechercher)!=null){
parcourir = xml.search("ModelMaths","ModelMath", "id",
aRechercher);

//recuperation de l'attribut id
obj.setId(parcourir.getAttributeValue("id"));
//recuperation de l'attribut cci
obj.setCci(parcourir.getAttributeValue("cci"));
//recuperation de l'attribut ccd
obj.setCcd(parcourir.getAttributeValue("ccd"));
//recuperation de l'attribut equaEtat

obj.setEquaEtat(parcourir.getAttributeValue("equaEtat"));
//recuperation de l'attribut boucleCausale

obj.setBoucleCausale(parcourir.getAttributeValue("boucleCausale"));
//recuperation de l'attribut mtf
obj.setMtf(parcourir.getAttributeValue("mtf"));
return obj;
}
return null;
}
return null;
}catch(Exception ex){return null;}
}

245
/**
* la methode rechercherParMotCle de la classe (retourne un objet qui
contien la chaine de caractaire)
*/
public List rechercherParMotCle(String motCle, String aRechercher){
try{
File file = new File(this.fichier);
if(file.exists()){
ModelMath obj = new ModelMath(this.fichier);
List listeElmt;
List listeObjet=new ArrayList();
Iterator itr;//itr pointe sur les elts de la list
Element parcourirElmt= new Element("aa");
List xmlListe= new ArrayList();

XML xml= new XML(this.fichier);


List liste = xml.racine.getChildren();
Iterator it = liste.iterator();//i pointe sur les elts de la
list
Element parcourir= new Element("aa");
boolean ok = false;
while (it.hasNext()){
parcourir = (Element)it.next();
if(ok){
//recuperation de l'attribut id
obj.setId(parcourir.getAttributeValue("id"));
//recuperation de l'attribut cci
obj.setCci(parcourir.getAttributeValue("cci"));
//recuperation de l'attribut ccd
obj.setCcd(parcourir.getAttributeValue("ccd"));
//recuperation de l'attribut equaEtat

obj.setEquaEtat(parcourir.getAttributeValue("equaEtat"));
//recuperation de l'attribut boucleCausale

obj.setBoucleCausale(parcourir.getAttributeValue("boucleCausale"));
//recuperation de l'attribut mtf
obj.setMtf(parcourir.getAttributeValue("mtf"));
listeObjet.add(obj);
obj=new ModelMath(this.fichier);
ok = false;
}
}
return listeObjet;
}
return null;
}catch(Exception ex){return null;}

}
}

/* Classe Elemen.java */

package BondGraph;

import java.util.*;
import java.util.Iterator;
import java.util.List;
import java.sql.Date;
import java.lang.Double;

246
import org.jdom.Element;
import XML_Package.*;
import java.io.*;

public class Elemen{

String id;
int modelBG;
String jonction;
String gain;
String type;
int lien;

private String str = "";


private String fichier = "";
private Element elt = new Element("aa");
/**
* le constructeur par défaut de la classe
*/
public Elemen(){
id = "";
modelBG = 1;
jonction = "";
gain = "no";
type = "";
lien = 1;
}
/**
* le constructeur de la classe
*/
public Elemen(String fichier){
this.fichier = fichier;
id = "";
modelBG = 1;
jonction = "";
gain = "no";
type = "";
lien = 1;
}
/**
* le constructeur de la classe
*/
public Elemen(String fichier, String id, int ModelBG, String jonction,
String gain, String type, int lien){
this.id = id;
this.modelBG = modelBG;
this.jonction = jonction;
this.gain = gain;
this.type = type;
this.lien = lien;
this.fichier = fichier;
}
/**
* la methode set de la variable fichier
*/
public void setFichier(String fichier){
this.fichier = fichier;
}
/**
* la methode set de la variable id

247
*/
public void setId(String id){
this.id = id;
}
/**
* la methode set de la variable ModelBG
*/
public void setModelBG(int modelBG){
this.modelBG = modelBG;
}
/**
* la methode set de la variable jonction
*/
public void setJonction(String jonction){
this.jonction = jonction;
}
/**
* la methode set de la variable gain
*/
public void setGain(String gain){
this.gain = gain;
}
/**
* la methode set de la variable type
*/
public void setType(String type){
this.type = type;
}
/**
* la methode set de la variable lien
*/
public void setLien(int lien){
this.lien = lien;
}
/**
* la methode get de la variable fichier
*/
public String getFichier(){
return this.fichier;
}
/**
* la methode get de la variable id
*/
public String getId(){
return id;
}
/**
* la methode get de la variable ModelBG
*/
public int getModelBG(){
return modelBG;
}
/**
* la methode get de la variable jonction
*/
public String getJonction(){
return jonction;
}
/**
* la methode get de la variable gain
*/

248
public String getGain(){
return gain;
}
/**
* la methode get de la variable type
*/
public String getType(){
return type;
}
/**
* la methode get de la variable lien
*/
public int getLien(){
return lien;
}
/**
* la methode idMax de la classe
*/
public int idMax() throws Exception{
try{
XML xml= new XML();
return xml.chercher_idmax(this.fichier);
}catch(Exception ex){return 0;}
}

/**
* la methode ajouter de la classe
*/
public boolean ajouter() throws Exception{
try{
XML xml= new XML();
File file = new File(this.fichier);
if(!file.exists()) xml.creerXML(this.fichier, "Elements");
xml= new XML(this.fichier);
xml.courant = xml.addNoeud(xml.racine, "Element", "");
//ajouter l'attribut id
xml.add_Attribut(xml.courant,"id", this.id+"");
//ajouter l'attribut ModelBG
xml.add_Attribut(xml.courant,"modelBG", this.modelBG+"");
//ajouter l'attribut jonction
xml.add_Attribut(xml.courant,"jonction", this.jonction+"");
//ajouter l'element gain
xml.add_noeud(xml.courant,"gain", this.gain+"");
//ajouter l'element type
xml.add_noeud(xml.courant,"type", this.type+"");
//ajouter l'attribut lien
xml.add_Attribut(xml.courant,"lien", this.lien+"");
xml.save(this.fichier);
return true;
}catch(Exception ex){return false;}
}

/**
* la methode supprimer de la classe
*/
public boolean supprimer() throws Exception{
File file = new File(this.fichier);
try{
if(file.exists()){
XML xml= new XML(this.fichier);
if(xml.search("Elements","Element", "id", this.id+"")!=null){

249
xml.courant = xml.search("Elements","Element", "id",
this.id+"");
xml.racine.removeContent(xml.courant);
xml.racine.removeChild(""+xml.courant);
xml.save(this.fichier);
return true;
}
return false;
}
return false;
}catch(Exception ex){return false;}
}

/**
* la methode modifier de la classe
*/
public boolean modifier() throws Exception{
try{
File file = new File(this.fichier);
if(file.exists()){
XML xml= new XML(this.fichier);
if(xml.search("Elements","Element", "id", this.id+"")!=null){
xml.courant = xml.search("Elements","Element", "id",
this.id+"");
//modification de l'attribut id
xml.courant.getAttribute("id").setValue(this.id+"");
//modification de l'attribut ModelBG

xml.courant.getAttribute("modelBG").setValue(this.modelBG+"");
//modification de l'attribut jonction

xml.courant.getAttribute("jonction").setValue(this.jonction+"");
//modification de l'element gain
xml.courant.getChild("gain").setText(this.gain+"");
//modification de l'element type
xml.courant.getChild("type").setText(this.type+"");
//modification de l'attribut lien
xml.courant.getAttribute("lien").setValue(this.lien+"");
xml.save(this.fichier);
return true;
}
return false;
}
return false;
}catch(Exception ex){return false;}
}

/**
* la methode lister de la classe (retourne une liste des objets du
fichier XML)
*/
public List lister(){
try{
File file = new File(this.fichier);
if(file.exists()){
Elemen obj = new Elemen(this.fichier);
List listeElmt=new ArrayList();
List listeObjet=new ArrayList();
Iterator itr;//itr pointe sur les elts de la list
Element parcourirElmt= new Element("aa");
List xmlListe= new ArrayList();

250
XML xml= new XML(this.fichier);
List liste = xml.racine.getChildren();
Iterator it = liste.iterator();//i pointe sur les elts de la
list
Element parcourir= new Element("aa");
while (it.hasNext()){
parcourir = (Element)it.next();
//recuperation de l'attribut id
obj.setId(parcourir.getAttributeValue("id"));
//recuperation de l'attribut ModelBG

obj.setModelBG(Integer.parseInt(parcourir.getAttributeValue("modelBG")));
//recuperation de l'attribut jonction

obj.setJonction(parcourir.getAttributeValue("jonction"));
//recuperation de l'element gain
obj.setGain(parcourir.getChildText("gain"));
//recuperation de l'element type
obj.setType(parcourir.getChildText("type"));
//recuperation de l'attribut lien

obj.setLien(Integer.parseInt(parcourir.getAttributeValue("lien")));
listeObjet.add(obj);
obj=new Elemen(this.fichier);
}
if(listeObjet.size() < 1) return null;
return listeObjet;
}
return null;
}catch(Exception ex){return null;}
}

/**
* la methode rechercherParId de la classe (retourne un objet qui
contien la chaine de caractaire)
*/
public Elemen rechercherParId(String aRechercher){
try{
File file = new File(this.fichier);
if(file.exists()){
Elemen obj = new Elemen(this.fichier);
XML xml= new XML(this.fichier);
Element parcourir= new Element("aa");

if(xml.search("Elements","Element", "id", aRechercher)!=null)


{
parcourir = xml.search("Elements","Element", "id",
aRechercher);
obj.setId(parcourir.getAttributeValue("id"));

obj.setModelBG(Integer.parseInt(parcourir.getAttributeValue("modelBG")));
obj.setJonction(parcourir.getAttributeValue("jonction"));
obj.setGain(parcourir.getChildText("gain"));
obj.setType(parcourir.getChildText("type"));

obj.setLien(Integer.parseInt(parcourir.getAttributeValue("lien")));
return obj;
}
return null;
}

251
return null;
}catch(Exception ex){return null;}
}

/**
* la methode rechercherParMotCle de la classe (retourne un objet qui
contien la chaine de caractaire)
*/
public List rechercherParMotCle(String motCle, String aRechercher){
try{
File file = new File(this.fichier);
if(file.exists()){
Elemen obj = new Elemen(this.fichier);
List listeElmt;
List listeObjet=new ArrayList();
Iterator itr;//itr pointe sur les elts de la list
Element parcourirElmt= new Element("aa");
List xmlListe= new ArrayList();

XML xml= new XML(this.fichier);


List liste = xml.racine.getChildren();
Iterator it = liste.iterator();//i pointe sur les elts de la
list
Element parcourir= new Element("aa");
boolean ok = false;
while (it.hasNext()){
parcourir = (Element)it.next();
if(motCle.equals("gain")){
if(aRechercher.equals(parcourir.getChildText("gain"))){
ok = true;
}
}
if(motCle.equals("jonction")){

if(aRechercher.equals(parcourir.getAttributeValue("jonction"))){
ok = true;
}
}
if(motCle.equals("lien")){

if(aRechercher.equals(parcourir.getAttributeValue("lien"))){
ok = true;
}
}
if(motCle.equals("type")){
if(aRechercher.equals(parcourir.getChildText("type"))){
ok = true;
}
}
if(ok){

//recuperation de l'attribut id
obj.setId(parcourir.getAttributeValue("id"));
//recuperation de l'attribut ModelBG

obj.setModelBG(Integer.parseInt(parcourir.getAttributeValue("modelBG")));
//recuperation de l'attribut jonction

obj.setJonction(parcourir.getAttributeValue("jonction"));
//recuperation de l'element gain
obj.setGain(parcourir.getChildText("gain"));

252
//recuperation de l'element type
obj.setType(parcourir.getChildText("type"));
//recuperation de l'attribut lien

obj.setLien(Integer.parseInt(parcourir.getAttributeValue("lien")));
listeObjet.add(obj);
obj=new Elemen(this.fichier);
ok = false;
}
}
return listeObjet;
}
return null;
}catch(Exception ex){return null;}
}

//Cette méthode permet d'affecter la causalité à un élément donné

public boolean AffecterCausalite(String path,String causalite)


{
try{
Lien l = new Lien(path + "Lien.xml");
String u = "";

l = l.rechercherParId("" + this.getLien());
u = l.getCausalite();
if (u.equals("A"))
{
l.setCausalite(causalite);
l.modifier();
}
return true;
}catch(Exception ex){return false;}
}

//Cette méthode permet de retourner la causalité d' un élément donné

public String getCausalite(String path)


{
try{
Lien l = new Lien(path + "Lien.xml");
l = l.rechercherParId("" + this.lien);
return l.getCausalite();
}catch(Exception ex){return null;}
}

/**
* La méthode calculerId permet de calculer l'identificateur du nouveau
élément à ajouter
* elle reçoit en paramètre le type de l'élément à ajouter
*/
public String calculerId(String type) throws Exception
{
try
{
Jonction jct = new Jonction(this.fichier);
List liste = new ArrayList();
int a = 0;

liste = jct.rechercherParMotCle("type",type);
a = liste.size()+1;

253
if(type.equals("Se"))
return "Se["+ a +"]";
if(type.equals("Sf"))
return "Sf["+ a +"]";
if(type.equals("I"))
return "I["+ a +"]";
if(type.equals("C"))
return "C["+ a +"]";
if(type.equals("R"))
return "R["+ a +"]";
return null;

}catch(Exception ex){return null;}


}

/*
* La méthode calculerGain permet de calculer le gain d'un élément
*/
public void calculerGain(String path) throws Exception
{
try
{
String gain = this.getGain();
if(gain.equals("no"))
{
String tmp = "";
tmp = this.getType();
if(tmp.equals("C"))
{
tmp = this.getCausalite(path);
if(tmp.equals("0"))
this.setGain("1/Cs");
else
this.setGain("Cs");
}
if(tmp.equals("I"))
{
tmp = this.getCausalite(path);
if(tmp.equals("1"))
this.setGain("1/Is");
else
this.setGain("Is");
}
if(tmp.equals("R"))
{
tmp = this.getCausalite(path);
if(tmp.equals("0"))
this.setGain("R");
else
this.setGain("1/R");
}
this.modifier();
}

}catch(Exception ex){return;}
}
}

/* Classe Jonction.java */

package BondGraph;

254
import java.util.*;
import java.util.Iterator;
import java.util.List;
import java.sql.Date;
import java.lang.Double;
import org.jdom.Element;
import XML_Package.*;
import java.io.*;

public class Jonction{

String id;
String modelBG;
String type;
String module;
String conflitcausal;

private String str = "";


private String fichier = "";
private Element elt = new Element("aa");
/**
* le constructeur par défaut de la classe
*/
public Jonction(){
id = "";
modelBG = "";
type = "";
module = "";
conflitcausal = "0";
}
/**
* le constructeur de la classe
*/
public Jonction(String fichier){
this.fichier = fichier;
id = "";
modelBG = "";
type = "";
module = "";
conflitcausal = "0";
}
/**
* le constructeur de la classe
*/
public Jonction(String fichier, String id, String modelBG, String type,
String module, String conflitcausal){
this.id = id;
this.modelBG = modelBG;
this.type = type;
this.module = module;
this.conflitcausal = conflitcausal;
this.fichier = fichier;
}
/**
* la methode set de la variable fichier
*/
public void setFichier(String fichier){
this.fichier = fichier;
}

255
/**
* la methode set de la variable id
*/
public void setId(String id){
this.id = id;
}
/**
* la methode set de la variable modelBG
*/
public void setModelBG(String modelBG){
this.modelBG = modelBG;
}
/**
* la methode set de la variable type
*/
public void setType(String type){
this.type = type;
}
/**
* la methode set de la variable module
*/
public void setModule(String module){
this.module = module;
}
/**
* la methode set de la variable conflitcausal
*/
public void setConflitcausal(String conflitcausal){
this.conflitcausal = conflitcausal;
}
/**
* la methode get de la variable fichier
*/
public String getFichier(){
return this.fichier;
}
/**
* la methode get de la variable id
*/
public String getId(){
return id;
}
/**
* la methode get de la variable modelBG
*/
public String getModelBG(){
return modelBG;
}
/**
* la methode get de la variable type
*/
public String getType(){
return type;
}
/**
* la methode get de la variable module
*/
public String getModule(){
return module;
}
/**

256
* la methode get de la variable conflitcausal
*/
public String getConflitcausal(){
return conflitcausal;
}
/**
* la methode idMax de la classe
*/
public int idMax() throws Exception{
try{
XML xml= new XML();
return xml.chercher_idmax(this.fichier);
}catch(Exception ex){return 0;}
}
/**
* la methode ajouter de la classe
*/
public boolean ajouter() throws Exception{
try{
XML xml= new XML();
File file = new File(this.fichier);
if(!file.exists()) xml.creerXML(this.fichier, "Jonctions");
xml= new XML(this.fichier);
xml.courant = xml.addNoeud(xml.racine, "Jonction", "");
//ajouter l'attribut id
xml.add_Attribut(xml.courant,"id", this.id+"");
//ajouter l'attribut modelBG
xml.add_Attribut(xml.courant,"modelBG", this.modelBG+"");
//ajouter l'element type
xml.add_noeud(xml.courant,"type", this.type+"");
//ajouter l'element module
xml.add_noeud(xml.courant,"module", this.module+"");
//ajouter l'element conflitcausal
xml.add_noeud(xml.courant,"conflitcausal", this.conflitcausal+"");
xml.save(this.fichier);
return true;
}catch(Exception ex){return false;}
}
/**
* la methode supprimer de la classe
*/
public boolean supprimer() throws Exception{
File file = new File(this.fichier);
try{
if(file.exists()){
XML xml= new XML(this.fichier);
if(xml.search("Jonctions","Jonction", "id", this.id+"")!=null){
xml.courant = xml.search("Jonctions","Jonction", "id",
this.id+"");
xml.racine.removeContent(xml.courant);
xml.racine.removeChild(""+xml.courant);
xml.save(this.fichier);
return true;
}
return false;
}
return false;
}catch(Exception ex){return false;}
}
/**
* la methode modifier de la classe

257
*/
public boolean modifier() throws Exception{
try{
File file = new File(this.fichier);
if(file.exists()){
XML xml= new XML(this.fichier);
if(xml.search("Jonctions","Jonction", "id", this.id+"")!=null){
xml.courant = xml.search("Jonctions","Jonction", "id",
this.id+"");
//modification de l'attribut id
xml.courant.getAttribute("id").setValue(this.id+"");
//modification de l'attribut modelBG

xml.courant.getAttribute("modelBG").setValue(this.modelBG+"");
//modification de l'element type
xml.courant.getChild("type").setText(this.type+"");
//modification de l'element module
xml.courant.getChild("module").setText(this.module+"");
//modification de l'element conflitcausal

xml.courant.getChild("conflitcausal").setText(this.conflitcausal+"");
xml.save(this.fichier);
return true;
}
return false;
}
return false;
}catch(Exception ex){return false;}
}
/**
* la methode lister de la classe (retourne une liste des objets du
fichier XML)
*/
public List lister(){
try{
File file = new File(this.fichier);
if(file.exists()){
Jonction obj = new Jonction(this.fichier);
List listeElmt=new ArrayList();
List listeObjet=new ArrayList();
Iterator itr;//itr pointe sur les elts de la list
Element parcourirElmt= new Element("aa");
List xmlListe= new ArrayList();

XML xml= new XML(this.fichier);


List liste = xml.racine.getChildren();
Iterator it = liste.iterator();//i pointe sur les elts de la
list
Element parcourir= new Element("aa");
while (it.hasNext()){
parcourir = (Element)it.next();
//recuperation de l'attribut id
obj.setId(parcourir.getAttributeValue("id"));
//recuperation de l'attribut modelBG
obj.setModelBG(parcourir.getAttributeValue("modelBG"));
//recuperation de l'element type
obj.setType(parcourir.getChildText("type"));
//recuperation de l'element module
obj.setModule(parcourir.getChildText("module"));
//recuperation de l'element conflitcausal

258
obj.setConflitcausal(parcourir.getChildText("conflitcausal"));
listeObjet.add(obj);
obj=new Jonction(this.fichier);
}
if(listeObjet.size() < 1) return null;
return listeObjet;
}
return null;
}catch(Exception ex){return null;}
}

/**
* la methode rechercherParId de la classe (retourne un objet qui
contien la chaine de caractaire)
*/
public Jonction rechercherParId(String aRechercher){
try{
File file = new File(this.fichier);
if(file.exists()){
Jonction obj = new Jonction(this.fichier);
List listeElmt;
Iterator itr;//itr pointe sur les elts de la list
Element parcourirElmt= new Element("aa");
List xmlListe= new ArrayList();

XML xml= new XML(this.fichier);


Element parcourir= new Element("aa");
if(xml.search("Jonctions","Jonction", "id",
aRechercher)!=null){
parcourir = xml.search("Jonctions","Jonction", "id",
aRechercher);
//recuperation de l'attribut id
obj.setId(parcourir.getAttributeValue("id"));
//recuperation de l'attribut modelBG
obj.setModelBG(parcourir.getAttributeValue("modelBG"));
//recuperation de l'element type
obj.setType(parcourir.getChildText("type"));
//recuperation de l'element module
obj.setModule(parcourir.getChildText("module"));
//recuperation de l'element conflitcausal

obj.setConflitcausal(parcourir.getChildText("conflitcausal"));
return obj;
}
return null;
}
return null;
}catch(Exception ex){return null;}
}

/**
* la methode rechercherParMotCle de la classe (retourne un objet qui
contien la chaine de caractaire)
*/
public List rechercherParMotCle(String motCle, String aRechercher){
try{
File file = new File(this.fichier);
if(file.exists()){
Jonction obj = new Jonction(this.fichier);
List listeElmt;

259
List listeObjet=new ArrayList();
Iterator itr;//itr pointe sur les elts de la list
Element parcourirElmt= new Element("aa");
List xmlListe= new ArrayList();

XML xml= new XML(this.fichier);


List liste = xml.racine.getChildren();
Iterator it = liste.iterator();//i pointe sur les elts de la
list
Element parcourir= new Element("aa");
boolean ok = false;
while (it.hasNext()){
parcourir = (Element)it.next();
if(motCle.equals("type")){
if(aRechercher.equals(parcourir.getChildText("type"))){
ok = true;
}
}
if(motCle.equals("module")){

if(aRechercher.equals(parcourir.getChildText("module"))){
ok = true;
}
}
if(motCle.equals("conflitcausal")){

if(aRechercher.equals(parcourir.getChildText("conflitcausal"))){
ok = true;
}
}
if(ok){

//recuperation de l'attribut id
obj.setId(parcourir.getAttributeValue("id"));
//recuperation de l'attribut modelBG
obj.setModelBG(parcourir.getAttributeValue("modelBG"));
//recuperation de l'element type
obj.setType(parcourir.getChildText("type"));
//recuperation de l'element module
obj.setModule(parcourir.getChildText("module"));
//recuperation de l'element conflitcausal

obj.setConflitcausal(parcourir.getChildText("conflitcausal"));
listeObjet.add(obj);
obj=new Jonction(this.fichier);
ok = false;
}
}
return listeObjet;
}
return null;
}catch(Exception ex){return null;}
}

/**
* La méthode ConnectedWithTF permet d'extraire les jonctions
connectées par un TF donné
*/
public String ConnectedWithTF(String idJ1,String path)throws
Exception
{

260
try
{
String Conx = "";
String tmp = "";
File file = new File(path + "Lien.xml");
if(file.exists())
{
XML xml= new XML(path + "Lien.xml");
List liste = xml.racine.getChildren();
Iterator it = liste.iterator();//i pointe sur les elts
de la list
Element parcourir= new Element("aa");

if (idJ1.length()==0)
{
while (it.hasNext())
{
parcourir = (Element)it.next();
tmp = parcourir.getAttributeValue("jonction");
if (tmp.startsWith(this.id + ','))
Conx = Conx +
(tmp.substring(tmp.indexOf(",")+1,tmp.length())) + ",";
if (tmp.endsWith(',' + this.id))
Conx = Conx +
(tmp.substring(0,tmp.indexOf(","))) + ",";
}
return Conx;
}
else
{
while (it.hasNext())
{
parcourir = (Element)it.next();
tmp = parcourir.getAttributeValue("jonction");
if (tmp.startsWith(this.id + ','))
{
tmp =
tmp.substring(tmp.indexOf(",")+1,tmp.length());
if (!idJ1.equals(tmp))
return tmp;
}
if (tmp.endsWith(',' + this.id))
{
tmp = tmp.substring(0,tmp.indexOf(","));
if (!idJ1.equals(tmp))
return tmp;
}
}
}
}
return null;
}catch(Exception ex){return null;}
}

/**
* La méthode ConnectedWithGY permet d'extraire les jonctions
connectées par un GY donné
*/
public String ConnectedWithGY(String idJ1,String path)throws
Exception
{

261
try
{
String Conx = "";
String tmp = "";
File file = new File(path + "Lien.xml");
if(file.exists())
{
XML xml= new XML(path + "Lien.xml");
List liste = xml.racine.getChildren();
Iterator it = liste.iterator();//i pointe sur les elts
de la list
Element parcourir= new Element("aa");
if (idJ1.length()==0)
{
while (it.hasNext())
{
parcourir = (Element)it.next();
tmp = parcourir.getAttributeValue("jonction");
if (tmp.startsWith(this.id + ','))
Conx = Conx +
(tmp.substring(tmp.indexOf(",")+1,tmp.length())) + ",";
if (tmp.endsWith(',' + this.id))
Conx = Conx +
(tmp.substring(0,tmp.indexOf(","))) + ",";
}
return Conx;
}
else
{
while (it.hasNext())
{
parcourir = (Element)it.next();
tmp = parcourir.getAttributeValue("jonction");
if (tmp.startsWith(this.id + ','))
{
tmp =
tmp.substring(tmp.indexOf(",")+1,tmp.length());
if (!idJ1.equals(tmp))
return tmp;
}
if (tmp.endsWith(',' + this.id))
{
tmp = tmp.substring(0,tmp.indexOf(","));
if (!idJ1.equals(tmp))
return tmp;
}
}
}
}
return null;
}catch(Exception ex){return null;}
}

/**
* La méthode Connexion permet d'extraire les connexions d'une jonction
donnée
*/
public String Connexion(String path)throws Exception
{
try
{

262
String Conx = "";
String tmp = "";
File file = new File(path + "Lien.xml");
if(file.exists())
{
XML xml= new XML(path + "Lien.xml");
List liste = xml.racine.getChildren();
Iterator it = liste.iterator();//i pointe sur les elts de
la list
Element parcourir= new Element("aa");
Jonction jc = new Jonction(path + "Jonction.xml");

while (it.hasNext())
{
parcourir = (Element)it.next();
tmp = parcourir.getAttributeValue("jonction");
if (tmp.startsWith(this.id + ','))
{
tmp =
tmp.substring(tmp.indexOf(",")+1,tmp.length());

if(tmp.startsWith("GY")) // C'est un gyrateur


{
jc = jc.rechercherParId(tmp);
Conx = Conx + jc.ConnectedWithGY(this.id,path)
+ ",";
}
else
if(tmp.startsWith("TF")) // C'est un transformateur
{
jc = jc.rechercherParId(tmp);
Conx = Conx + jc.ConnectedWithTF(this.id,path)
+ ",";
}
else
Conx = Conx + tmp + ",";
}
if (tmp.endsWith(',' + this.id))
{
tmp = tmp.substring(0,tmp.indexOf(","));

if(tmp.startsWith("GY")) // C'est un gyrateur


{
jc = jc.rechercherParId(tmp);
Conx = Conx + jc.ConnectedWithGY(this.id,path)
+ ",";
}
else
if(tmp.startsWith("TF")) // C'est un transformateur
{
jc = jc.rechercherParId(tmp);
Conx = Conx + jc.ConnectedWithTF(this.id,path)
+ ",";
}
else
Conx = Conx + tmp + ",";
}
//cas d'une connexion avec un élément
if (tmp.equals(this.id))
{

263
String no = "" +
parcourir.getAttributeValue("id");;
List listet = new ArrayList();
Elemen elt = new Elemen(path +
"Element.xml");

listet =
elt.rechercherParMotCle("lien",no);
elt = (Elemen)listet.get(0);
Conx = Conx + elt.getId() + ",";
}
}
return Conx;
}
return null;
}catch(Exception ex){return null;}
}

/**
* La méthode NbConnexion retourne le nombre de connexion d'une
jonction donnée
*/
public int NbConnexion(String path)throws Exception
{
try
{
String Conx = "";
String tmp = "";
int nb = 0;
File file = new File(path + "Lien.xml");
if(file.exists())
{
XML xml= new XML(path + "Lien.xml");
List liste = xml.racine.getChildren();
Iterator it = liste.iterator();//i pointe sur les elts de
la list
Element parcourir= new Element("aa");

while (it.hasNext())
{
parcourir = (Element)it.next();
tmp = parcourir.getAttributeValue("jonction");
if ((tmp.startsWith(this.id)) ||
(tmp.endsWith(this.id)))
nb++;
}
}
return nb;
}catch(Exception ex){return -1;}
}

/**
* La méthode NbConnexionE retourne le nombre de connexion entrante
d'une jonction donnée
*/
public int NbConnexionE(String path)throws Exception
{
try
{
String Cnx = "";
int nb = 0;

264
Cnx = this.Connexion(path);
String s = Cnx,t="";

while(Cnx.length()>0)
{
t = Cnx.substring(0,Cnx.indexOf(","));

Lien l = new Lien(path + "Lien.xml");

if ((t.startsWith("Se")) || (t.startsWith("Sf")) ||
(t.startsWith("R")) || (t.startsWith("C")) || (t.startsWith("I")) )
{
Elemen elt = new Elemen(path + "Element.xml");

String ss ="";
elt = elt.rechercherParId(t);
s = elt.getCausalite(path);
ss = elt.getType();
if( (s.equals("1")) && (ss.equals("Se")))
nb++;
if( (s.equals("0")) && ((ss.equals("R")) ||
(ss.equals("C")) || (ss.equals("I"))))
nb++;
}
if ((t.startsWith("0")) || (t.startsWith("1")) )
{
List liste = new ArrayList();

liste =
l.rechercherParMotCle("jonction",this.id + "," + t);
if (liste.size()==0)
{
liste =
l.rechercherParMotCle("jonction",t + "," + this.id);
if (liste.size()==0)
{

//les jonctions sont reliée soit


par un gyrateur ou un transformateur

XML xml= new XML(path + "Lien.xml");


List li = xml.racine.getChildren();
Iterator it = li.iterator();
Element parcourir= new Element("aa");
String tmp = "",tmp2 = "";

while (it.hasNext())
{
parcourir = (Element)it.next();
tmp =
parcourir.getAttributeValue("jonction");
//Cas d'une connexion avec un
transformateur
if (tmp.startsWith(this.id +
",TF"))
{
tmp2 =
parcourir.getChildText("causalite");
if(tmp2.equals("0"))
nb++;break;
}

265
if (tmp.startsWith(t + ",TF"))
{
tmp2 =
parcourir.getChildText("causalite");
if(tmp2.equals("1"))
nb++;break;
}
//Cas d'une connexion avec un
gyrateur
if (tmp.startsWith(this.id +
",GY"))
{
tmp2 =
parcourir.getChildText("causalite");
if(tmp2.equals("0"))
nb++;break;
}
if (tmp.startsWith(t + ",GY"))
{
tmp2 =
parcourir.getChildText("causalite");
if(tmp2.equals("0"))
nb++;break;
}
}

}
else
{
l = (Lien)liste.get(0);
s = l.getCausalite();
if(s.equals("1"))
nb++;
}
}
else
{
l = (Lien)liste.get(0);
s = l.getCausalite();
if(s.equals("0"))
nb++;
}
}
Cnx =
Cnx.substring(Cnx.indexOf(",")+1,Cnx.length());
}

return nb;
}catch(Exception ex){return -1;}
}

/**
* La méthode NbConnexionS retourne le nombre de connexion sortante
d'une jonction donnée
*/
public int NbConnexionS(String path)throws Exception
{
try
{
String Cnx = "";
int nb = 0;

266
Cnx = this.Connexion(path);
String s = "",t="";

while(Cnx.length()>0)
{
t = Cnx.substring(0,Cnx.indexOf(","));
Lien l = new Lien(path + "Lien.xml");

if ((t.startsWith("Se")) || (t.startsWith("Sf")) ||
(t.startsWith("R")) || (t.startsWith("C")) || (t.startsWith("I")) )
{
Elemen elt = new Elemen(path + "Element.xml");

String ss ="";
elt = elt.rechercherParId(t);
l = l.rechercherParId("" + elt.getLien());
s = l.getCausalite();
ss = elt.getType();
if( (s.equals("0")) && (ss.equals("Sf")))
nb++;
if( (s.equals("1")) && ((ss.equals("C")) ||
(ss.equals("I")) || (ss.equals("R"))) )
nb++;
}
if ((t.startsWith("0")) || (t.startsWith("1")) )
{
List liste = new ArrayList();
liste =
l.rechercherParMotCle("jonction",this.id + "," + t);
if (liste.size()==0)
{
liste =
l.rechercherParMotCle("jonction",t + "," + this.id);
if (liste.size()==0)
{
//les jonctions sont reliée soit
par un gyrateur ou un transformateur

XML xml= new XML(path + "Lien.xml");


List li = xml.racine.getChildren();
Iterator it = li.iterator();
Element parcourir= new Element("aa");
String tmp = "",tmp2 = "";

while (it.hasNext())
{
parcourir = (Element)it.next();
tmp =
parcourir.getAttributeValue("jonction");
//Cas d'une connexion avec un
transformateur
if (tmp.startsWith(this.id +
",TF"))
{
tmp2 =
parcourir.getChildText("causalite");
if(tmp2.equals("1"))
nb++;break;
}
if (tmp.startsWith(t + ",TF"))
{

267
tmp2 =
parcourir.getChildText("causalite");
if(tmp2.equals("0"))
nb++;break;
}
//Cas d'une connexion avec un
gyrateur
if (tmp.startsWith(this.id +
",GY"))
{
tmp2 =
parcourir.getChildText("causalite");
if(tmp2.equals("1"))
nb++;break;
}
if (tmp.startsWith(t + ",GY"))
{
tmp2 =
parcourir.getChildText("causalite");
if(tmp2.equals("1"))
nb++;break;
}
}

}
else
{
l = (Lien)liste.get(0);
s = l.getCausalite();
if(s.equals("0"))
nb++;
}
}
else
{
l = (Lien)liste.get(0);
s = l.getCausalite();
if(s.equals("1"))
nb++;
}
}
Cnx =
Cnx.substring(Cnx.indexOf(",")+1,Cnx.length());
}

return nb;
}catch(Exception ex){return -1;}
}

/**
* La méthode InfoConnexion renvoie une chaine de caractères qui permet
de savoir respectivement
* type de la connexion sortante ou entrante, passe par un gyrateur ou
transformateur
* No du lien et l'orientation du lien
*/
public String InfoConnexion(String ext2, String path) throws Exception
{
try
{
Lien l = new Lien (path + "Lien.xml");

268
List liste = new ArrayList();
String info = "",s = "",ss = "";

liste = l.rechercherParMotCle("jonction",this.id + "," +


ext2);
if (liste.size()==0)
{
liste = l.rechercherParMotCle("jonction",ext2 + ","
+ this.id);
if (liste.size()==0)
{
//la connexion passe par un transformateur ou
gyrateur
XML xml= new XML(path + "Lien.xml");
List li = xml.racine.getChildren();
Iterator it = li.iterator();
Element parcourir= new Element("aa");

while (it.hasNext())
{
parcourir = (Element)it.next();
s =
parcourir.getAttributeValue("jonction");
//Cas d'une connexion avec un
transformateur
if (s.startsWith(this.id + ",TF"))
{
s =
parcourir.getChildText("causalite");
if(s.equals("1"))
info = info + "S" + ",";
else
info = info + "E" + ",";
s =
parcourir.getAttributeValue("jonction");
ss =
s.substring(s.indexOf(",")+1,s.length());
info = info + ss + ",";
s = parcourir.getAttributeValue("id");
info = info + s + ",";
liste =
l.rechercherParMotCle("jonction",ss + "," + ext2);
l = (Lien)liste.get(0);
info = info + l.getId() + ",";

info = info + "R" + ",";


return info;
}
if (s.startsWith(ext2 + ",TF"))
{
s =
parcourir.getChildText("causalite");
if(s.equals("1"))
info = info + "E" + ",";
else
info = info + "S" + ",";
s =
parcourir.getAttributeValue("jonction");

269
ss =
s.substring(s.indexOf(",")+1,s.length());
info = info + ss + ",";
liste =
l.rechercherParMotCle("jonction",ss + "," + this.id);
l = (Lien)liste.get(0);
info = info + l.getId() + ",";

s = parcourir.getAttributeValue("id");
info = info + s + ",";

info = info + "L" + ",";


return info;
}
//Cas d'une connexion avec un gyrateur
if (s.startsWith(this.id + ",GY"))
{
s =
parcourir.getChildText("causalite");

if(s.equals("1"))
info = info + "S" + ",";
else
info = info + "E" + ",";
s =
parcourir.getAttributeValue("jonction");
ss =
s.substring(s.indexOf(",")+1,s.length());
info = info + ss + ",";
s = parcourir.getAttributeValue("id");
info = info + s + ",";
liste =
l.rechercherParMotCle("jonction",ss + "," + ext2);
l = (Lien)liste.get(0);
info = info + l.getId() + ",";

info = info + "R" + ",";


return info;
}
if (s.startsWith(ext2 + ",GY"))
{
s =
parcourir.getChildText("causalite");

if(s.equals("1"))
info = info + "S" + ",";
else
info = info + "E" + ",";
s =
parcourir.getAttributeValue("jonction");
ss =
s.substring(s.indexOf(",")+1,s.length());
info = info + ss + ",";
liste =
l.rechercherParMotCle("jonction",ss + "," + this.id);
l = (Lien)liste.get(0);
info = info + l.getId() + ",";

s = parcourir.getAttributeValue("id");
info = info + s + ",";

270
info = info + "L" + ",";
return info;
}
}
}
else
{
l = (Lien)liste.get(0);
s = l.getCausalite();
if(s.equals("1"))
info = info + "E" + ",";
else
info = info + "S" + ",";
info = info + "no,";
info = info + l.getId() + ",";
info = info + "L" + ",";

}
}
else
{
l = (Lien)liste.get(0);
s = l.getCausalite();
if(s.equals("1"))
info = info + "S" + ",";
else
info = info + "E" + ",";
info = info + "no,";
info = info + l.getId() + ",";
info = info + "R" + ",";
}
return info;

}catch(Exception ex){return null;}


}

/**
* La méthode calculerId permet de calculer l'identificateur de la
nouvelle jonction à ajouter
* elle reçoit en paramètre le type de la jonction à ajouter
*/
public String calculerId(String type) throws Exception
{
try
{
Jonction jct = new Jonction(this.fichier);
List liste = new ArrayList();
int a = 0;

liste = jct.rechercherParMotCle("type",type);
a = liste.size()+1;
if(type.equals("0"))
return "0["+ a +"]";
if(type.equals("1"))
return "1["+ a +"]";
if(type.equals("TF"))
return "TF["+ a +"]";
if(type.equals("GY"))
return "GY["+ a +"]";
return null;

271
}catch(Exception ex){return null;}
}

/**
* La méthode calculerIdModule permet de calculer l'identificateur du
module d'un GY ou d'un TF
*/
public String calculerIdModule(String type) throws Exception
{
try
{
Jonction jct = new Jonction(this.fichier);
List liste = new ArrayList();
int a = 0;

liste = jct.rechercherParMotCle("type",type);
a = liste.size()+1;
if(type.equals("TF"))
return "m"+ a;
if(type.equals("GY"))
return "r"+ a;
return null;

}catch(Exception ex){return null;}


}

/**
* La méthode calculerModule permet de calculer le module d'un GY ou
d'un TF
*/
public void calculerModule(String path) throws Exception
{
try
{
Lien l = new Lien(path + "Lien.xml");
List liste = new ArrayList();
String jonction ="", causalite = "", type = "";

liste = l.lister();
for(int j = 0; j<liste.size(); j++)
{
l = (Lien)liste.get(j);
jonction = l.getJonction();
if(jonction.startsWith(this.getId()+""))
{
causalite = l.getCausalite();
type = this.getType();
if(causalite.equals("1"))
{
if(type.equals("GY"))
this.setModule(this.getModule());
else
this.setModule("1/" + this.getModule());
}
if(causalite.equals("0"))
{
if(type.equals("TF"))
this.setModule(this.getModule());
else
this.setModule("1/" + this.getModule());
}

272
}
}
this.modifier();

}catch(Exception ex){return;}
}

/**
* La méthode ExisteInJonction permet de tester si un type d'élement
donné existe dans une jonction
*/
public int ExisteInJonction(String id,String type, String path) throws
Exception
{
try
{
Elemen elt = new Elemen(path + "Element.xml");
List liste = new ArrayList();

liste = elt.rechercherParMotCle("jonction",id);

for(int j = 0; j<liste.size(); j++)


{
elt = (Elemen)liste.get(j);
if (elt.type.equals(type))
return liste.size();
}
return 0;
}catch(Exception ex){return 0;}
}
}

/* Classe Lien.java */

package BondGraph;

import java.util.*;
import java.util.Iterator;
import java.util.List;
import java.sql.Date;
import java.lang.Double;
import org.jdom.Element;
import XML_Package.*;
import java.io.*;

public class Lien{

int id;
int modelBG;
String jonction;
String dim;
String causalite;

private String str = "";


private String fichier = "";
private Element elt = new Element("aa");
/**
* le constructeur par défaut de la classe
*/
public Lien(){
id = 1;

273
modelBG = 1;
jonction = "";
dim = "1";
causalite = "A";
}
/**
* le constructeur de la classe
*/
public Lien(String fichier){
this.fichier = fichier;
id = 1;
modelBG = 1;
jonction = "";
dim = "1";
causalite = "A";
}
/**
* le constructeur de la classe
*/
public Lien(String fichier, int id, int modelBG, String jonction,
String dim, String causalite){
this.id = id;
this.modelBG = modelBG;
this.jonction = jonction;
this.dim = dim;
this.causalite = causalite;
this.fichier = fichier;
}
/**
* la methode set de la variable fichier
*/
public void setFichier(String fichier){
this.fichier = fichier;
}
/**
* la methode set de la variable id
*/
public void setId(int id){
this.id = id;
}
/**
* la methode set de la variable modelBG
*/
public void setModelBG(int modelBG){
this.modelBG = modelBG;
}
/**
* la methode set de la variable jonction
*/
public void setJonction(String jonction){
this.jonction = jonction;
}
/**
* la methode set de la variable dim
*/
public void setDim(String dim){
this.dim = dim;
}
/**
* la methode set de la variable causalite
*/

274
public void setCausalite(String causalite){
this.causalite = causalite;
}
/**
* la methode set de la variable causalite a une laison entre jonction
*/
public boolean setCausalite(String ext1,String ext2,String
causalite,String path)throws Exception{
try{
Lien l = new Lien(path + "Lien.xml");
List liste = new ArrayList();
liste = l.rechercherParMotCle("jonction",ext1 + "," + ext2);
if((liste.size()==0) || (liste == null))
{
liste = l.rechercherParMotCle("jonction",ext2 + "," + ext1);
if(liste.size()==0 || (liste == null))
{
//Cas d'une connexion à l'aide d'un transformateur ou un
gyrateur
Jonction jc = new Jonction(path + "Jonction.xml");
List listej = new ArrayList();
String s;
//Connexion par un gyrateur
listej = jc.rechercherParMotCle("type","GY");
for(int j = 0; j<listej.size(); j++)
{
jc = (Jonction)listej.get(j);
s = jc.ConnectedWithGY("",path);
if(s.indexOf(ext1)!= -1) //ces deux jonctions sont
connectées par ce gyrateur
{
liste = l.rechercherParMotCle("jonction",ext1
+ "," + jc.getId());
if(liste.size()==0)
{
liste =
l.rechercherParMotCle("jonction",jc.getId() + "," + ext1);
l= (Lien)liste.get(0);
String u = l.getCausalite();
if(u.equals("A")){
if(causalite.equals("1"))
l.setCausalite("0");
else
l.setCausalite("1");
l.modifier();
//Affectation de la causalite au
deuxième lien
liste =
l.rechercherParMotCle("jonction",ext2 + "," + jc.getId());
l= (Lien)liste.get(0);

l.setCausalite(causalite);
l.modifier();
return true;}

}
else
{
l= (Lien)liste.get(0);

275
String u = l.getCausalite();
if(u.equals("A")){
l.setCausalite(causalite);
l.modifier();
//Affectation de la causalite au
deuxième lien
liste =
l.rechercherParMotCle("jonction",jc.getId() + "," + ext2);
l= (Lien)liste.get(0);

if(causalite.equals("1"))
l.setCausalite("0");
else
l.setCausalite("1");
l.modifier();
return true; }

}
}
//Connexion par un transformateur
listej = jc.rechercherParMotCle("type","TF");
for(int j = 0; j<listej.size(); j++)
{

jc = (Jonction)listej.get(j);
s = jc.ConnectedWithTF("",path);
if(s.indexOf(ext1)!= 0) //ces deux jonctions sont
connectées par ce transformateur
{
liste = l.rechercherParMotCle("jonction",ext1
+ "," + jc.getId());
if(liste.size()==0)
{
liste =
l.rechercherParMotCle("jonction",jc.getId() + "," + ext1);
l= (Lien)liste.get(0);
String u = l.getCausalite();
if(u.equals("A")){
if(causalite.equals("1"))
l.setCausalite("0");
else
l.setCausalite("1");
l.modifier();
//Affectation de la causalite au
deuxième lien
liste =
l.rechercherParMotCle("jonction",ext2 + "," + jc.getId());
l= (Lien)liste.get(0);

if(causalite.equals("1"))
l.setCausalite("0");
else
l.setCausalite("1");
l.modifier();
return true;}

}
else

276
{
l= (Lien)liste.get(0);
String u = l.getCausalite();
if(u.equals("A")){
l.setCausalite(causalite);
l.modifier();
//Affectation de la causalite au
deuxième lien
liste =
l.rechercherParMotCle("jonction",jc.getId() + "," + ext2);
l= (Lien)liste.get(0);

l.setCausalite(causalite);
l.modifier();
return true;}

}
}
}

}
else
{
l= (Lien)liste.get(0);
String u = l.getCausalite();
if(u.equals("A")){
if(causalite.equals("1"))
l.setCausalite("0");
else
l.setCausalite("1");
l.modifier();
return true; }
}
}
else
{ l= (Lien)liste.get(0);
String u = l.getCausalite();
if(u.equals("A")){
l.setCausalite(causalite);
l.modifier();
return true;}
}
return false;
}catch(Exception ex){return false;}

}
/**
* la methode get de la variable fichier
*/
public String getFichier(){
return this.fichier;
}
/**
* la methode get de la variable id
*/
public int getId(){
return id;
}
/**
* la methode get de la variable modelBG

277
*/
public int getModelBG(){
return modelBG;
}
/**
* la methode get de la variable jonction
*/
public String getJonction(){
return jonction;
}
/**
* la methode get de la variable dim
*/
public String getDim(){
return dim;
}
/**
* la methode get de la variable causalite
*/
public String getCausalite(){
return causalite;
}
/**
* la methode idMax de la classe
*/
public int idMax() throws Exception{
try{
XML xml= new XML();
return xml.chercher_idmax(this.fichier);
}catch(Exception ex){return 0;}
}
/**
* la methode ajouter de la classe
*/
public boolean ajouter() throws Exception{
try{
XML xml= new XML();
File file = new File(this.fichier);
if(!file.exists()) xml.creerXML(this.fichier, "Liens");
xml= new XML(this.fichier);
xml.courant = xml.addNoeud(xml.racine, "Lien", "");
//ajouter l'attribut id
xml.add_Attribut(xml.courant,"id", this.id+"");
//ajouter l'attribut modelBG
xml.add_Attribut(xml.courant,"modelBG", this.modelBG+"");
//ajouter l'attribut jonction
xml.add_Attribut(xml.courant,"jonction", this.jonction+"");
//ajouter l'element dim
xml.add_noeud(xml.courant,"dim", this.dim+"");
//ajouter l'element causalite
xml.add_noeud(xml.courant,"causalite", this.causalite+"");
xml.save(this.fichier);
return true;
}catch(Exception ex){return false;}
}
/**
* la methode supprimer de la classe
*/
public boolean supprimer() throws Exception{
File file = new File(this.fichier);
try{

278
if(file.exists()){
XML xml= new XML(this.fichier);
if(xml.search("Liens","Lien", "id", this.id+"")!=null){
xml.courant = xml.search("Liens","Lien", "id", this.id+"");
xml.racine.removeContent(xml.courant);
xml.racine.removeChild(""+xml.courant);
xml.save(this.fichier);
return true;
}
return false;
}
return false;
}catch(Exception ex){return false;}
}
/**
* la methode modifier de la classe
*/
public boolean modifier() throws Exception{
try{
File file = new File(this.fichier);
if(file.exists()){
XML xml= new XML(this.fichier);
if(xml.search("Liens","Lien", "id", this.id+"")!=null){
xml.courant = xml.search("Liens","Lien", "id", this.id+"");
//modification de l'attribut id
xml.courant.getAttribute("id").setValue(this.id+"");
//modification de l'attribut modelBG

xml.courant.getAttribute("modelBG").setValue(this.modelBG+"");
//modification de l'attribut jonction

xml.courant.getAttribute("jonction").setValue(this.jonction+"");
//modification de l'element dim
xml.courant.getChild("dim").setText(this.dim+"");
//modification de l'element causalite

xml.courant.getChild("causalite").setText(this.causalite+"");
xml.save(this.fichier);
return true;
}
return false;
}
return false;
}catch(Exception ex){return false;}
}
/**
* la methode lister de la classe (retourne une liste des objets du
fichier XML)
*/
public List lister(){
try{
File file = new File(this.fichier);
if(file.exists()){
Lien obj = new Lien(this.fichier);
List listeObjet=new ArrayList();
XML xml= new XML(this.fichier);
List liste = xml.racine.getChildren();
Iterator it = liste.iterator();//i pointe sur les elts de la
list
Element parcourir= new Element("aa");
while (it.hasNext()){

279
parcourir = (Element)it.next();
//recuperation de l'attribut id

obj.setId(Integer.parseInt(parcourir.getAttributeValue("id")));

//recuperation de l'attribut modelBG

obj.setModelBG(Integer.parseInt(parcourir.getAttributeValue("modelBG")));
//recuperation de l'attribut jonction

obj.setJonction(parcourir.getAttributeValue("jonction"));
//recuperation de l'element dim
obj.setDim(parcourir.getChildText("dim"));
//recuperation de l'element causalite
obj.setCausalite(parcourir.getChildText("causalite"));
listeObjet.add(obj);
obj=new Lien(this.fichier);
}
if(listeObjet.size() < 1) return null;
return listeObjet;
}
return null;
}catch(Exception ex){return null;}
}
/**
* la methode rechercherParId de la classe (retourne un objet qui
contien la chaine de caractaire)
*/
public Lien rechercherParId(String aRechercher){
try{
File file = new File(this.fichier);
if(file.exists())
{
Lien obj = new Lien(this.fichier);
XML xml= new XML(this.fichier);
Element parcourir= new Element("aa");

if(xml.search("Liens","Lien", "id", aRechercher)!=null)


{
parcourir = xml.search("Liens","Lien", "id", aRechercher);

obj.setId(Integer.parseInt(parcourir.getAttributeValue("id")));

obj.setModelBG(Integer.parseInt(parcourir.getAttributeValue("modelBG")));
obj.setJonction(parcourir.getAttributeValue("jonction"));
obj.setDim(parcourir.getChildText("dim"));
obj.setCausalite(parcourir.getChildText("causalite"));
return obj;
}
return null;
}
return null;
}catch(Exception ex){return null;}
}

/**
* la methode rechercherParMotCle de la classe (retourne un objet qui
contien la chaine de caractaire)
*/
public List rechercherParMotCle(String motCle, String aRechercher){
try{

280
File file = new File(this.fichier);
if(file.exists()){
Lien obj = new Lien(this.fichier);
List listeObjet=new ArrayList();
XML xml= new XML(this.fichier);
List liste = xml.racine.getChildren();
Iterator it = liste.iterator();//i pointe sur les elts de la
list
Element parcourir= new Element("aa");
boolean ok = false;
while (it.hasNext()){
parcourir = (Element)it.next();
if(motCle.equals("dim")){
if(aRechercher.equals(parcourir.getChildText("dim"))){
ok = true;
}
}
if(motCle.equals("id")){

if(aRechercher.equals(Integer.parseInt(parcourir.getAttributeValue("id"))))
{
ok = true;
}
}
if(motCle.equals("jonction")){

if(aRechercher.equals(parcourir.getAttributeValue("jonction"))){
ok = true;
}
}
if(motCle.equals("causalite")){

if(aRechercher.equals(parcourir.getChildText("causalite"))){
ok = true;
}
}

if(ok){
//recuperation de l'attribut id

obj.setId(Integer.parseInt(parcourir.getAttributeValue("id")));
//recuperation de l'attribut modelBG

obj.setModelBG(Integer.parseInt(parcourir.getAttributeValue("modelBG")));
//recuperation de l'attribut jonction

obj.setJonction(parcourir.getAttributeValue("jonction"));
//recuperation de l'element dim
obj.setDim(parcourir.getChildText("dim"));
//recuperation de l'element causalite
obj.setCausalite(parcourir.getChildText("causalite"));
listeObjet.add(obj);
obj=new Lien(this.fichier);
ok = false;
}
}
return listeObjet;
}
return null;
}catch(Exception ex){return null;}
}

281
/**
* La méthode calculerId permet de calculer l'identificateur du nouveau
lien à ajouter
*/
public int calculerId() throws Exception
{
try
{
return this.idMax()+1;

}catch(Exception ex){return 0;}


}

/**
* La méthode getExtremite permet de retourner les extrémités d'un
lien donné
*/
public String getExtremite(String path) throws Exception
{
try
{
String tmp = "";
tmp = this.getJonction();
if(tmp.indexOf(",")==-1)
{
//pour les éléments la première extrémité sera la
jonction la deuxième l'élément
Elemen elt = new Elemen (path + "Element.xml");
List liste = new ArrayList();

liste =
elt.rechercherParMotCle("lien",""+this.getId());
elt = (Elemen)liste.get(0);
tmp = elt.getType();
if((tmp.equals("Se")) || (tmp.equals("Sf")))
return elt.getId() + "," + this.getJonction();
else
return this.getJonction() + "," + elt.getId();
}
else
return tmp;
}catch(Exception ex){return null;}
}
}

/* Classe CCD.java */

package BondGraph;

import java.util.*;
import java.util.Iterator;
import java.util.List;
import java.sql.Date;
import java.lang.Double;
import org.jdom.Element;
import XML_Package.*;
import java.io.*;

public class CCD{

282
int id;
String gain;
String ext1;
String ext2;
String modelMath;
String listeOrient;
String listeTF;
String listeGY;
String listeLien;
String listeVar;
boolean bcl_Causalite;

private String str = "";


private String fichier = "";
private Element elt = new Element("aa");
/**
* le constructeur par défaut de la classe
*/
public CCD(){
id = 0;
gain = "no";
ext1 = "no";
ext2 = "no";
modelMath = "";
listeOrient = "";
listeTF = "no";
listeGY = "no";
listeLien = "";
listeVar = "";
bcl_Causalite = false;
}

/**
* le constructeur de la classe
*/
public CCD(String fichier){
this.fichier = fichier;
id = 0;
gain = "no";
ext1 = "no";
ext2 = "no";
modelMath = "";
listeOrient = "";
listeTF = "no";
listeGY = "no";
listeLien = "";
listeVar = "";
bcl_Causalite = false;
}

/**
* le constructeur de la classe
*/
public CCD(String fichier, int id, String gain, String ext1, String
ext2, String modelMath, String listeOrient,String listeTF, String listeGY,
String listeLien, String listeVar, boolean bcl_Causalite){
this.id = id;
this.gain = gain;
this.ext1 = ext1;
this.ext2 = ext2;
this.modelMath = modelMath;

283
this.listeOrient = listeOrient;
this.listeTF = listeTF;
this.listeGY = listeGY;
this.listeLien = listeLien;
this.listeVar = listeVar;
this.bcl_Causalite = bcl_Causalite;
this.fichier = fichier;
}
/**
* la methode set de la variable fichier
*/
public void setFichier(String fichier){
this.fichier = fichier;
}
/**
* la methode set de la variable id
*/
public void setId(int id){
this.id = id;
}
/**
* la methode set de la variable gain
*/
public void setGain(String gain){
this.gain = gain;
}
/**
* la methode set de la variable ext1
*/
public void setExt1(String ext1){
this.ext1 = ext1;
}
/**
* la methode set de la variable ext2
*/
public void setExt2(String ext2){
this.ext2 = ext2;
}
/**
* la methode set de la variable modelMath
*/
public void setModelMath(String modelMath){
this.modelMath = modelMath;
}
/**
* la methode set de la variable listeTF
*/
public void setListeTF(String listeTF){
this.listeTF = listeTF;
}
/**
* la methode set de la variable listeGY
*/
public void setListeGY(String listeGY){
this.listeGY = listeGY;
}
/**
* la methode set de la variable listeOrient
*/
public void setListeOrient(String listeOrient){
this.listeOrient = listeOrient;

284
}
/**
* la methode set de la variable listeLien
*/
public void setListeLien(String listeLien){
this.listeLien = listeLien;
}
/**
* la methode set de la variable listeVar
*/
public void setListeVar(String listeVar){
this.listeVar = listeVar;
}
/**
* la methode set de la variable bcl_Causalite
*/
public void setBcl_Causalite(boolean bcl_Causalite){
this.bcl_Causalite = bcl_Causalite;
}
/**
* la methode get de la variable fichier
*/
public String getFichier(){
return this.fichier;
}
/**
* la methode get de la variable id
*/
public int getId(){
return id;
}
/**
* la methode get de la variable gain
*/
public String getGain(){
return gain;
}
/**
* la methode get de la variable ext1
*/
public String getExt1(){
return ext1;
}
/**
* la methode get de la variable ext2
*/
public String getExt2(){
return ext2;
}
/**
* la methode get de la variable modelMath
*/
public String getModelMath(){
return modelMath;
}
/**
* la methode get de la variable listeOrient
*/
public String getListeOrient(){
return listeOrient;
}

285
/**
* la methode get de la variable listeTF
*/
public String getListeTF(){
return listeTF;
}
/**
* la methode get de la variable listeGY
*/
public String getListeGY(){
return listeGY;
}
/**
* la methode get de la variable listeLien
*/
public String getListeLien(){
return listeLien;
}
/**
* la methode get de la variable listeVar
*/
public String getListeVar(){
return listeVar;
}
/**
* la methode get de la variable bcl_Causalite
*/
public boolean getBcl_Causalite(){
return bcl_Causalite;
}
/**
* la methode idMax de la classe
*/
public int idMax() throws Exception{
try{
XML xml= new XML();
return xml.chercher_idmax(this.fichier);
}catch(Exception ex){return 0;}
}

/**
* la methode ajouter de la classe
*/
public boolean ajouter() throws Exception{
try{
XML xml= new XML();
File file = new File(this.fichier);
if(!file.exists()) xml.creerXML(this.fichier, "CCDs");
xml= new XML(this.fichier);
xml.courant = xml.addNoeud(xml.racine, "CCD", "");
//ajouter l'attribut id
xml.add_Attribut(xml.courant,"id", this.id+"");
//ajouter l'element gain
xml.add_noeud(xml.courant,"gain", this.gain+"");
//ajouter l'element ext1
xml.add_noeud(xml.courant,"ext1", this.ext1+"");
//ajouter l'element ext2
xml.add_noeud(xml.courant,"ext2", this.ext2+"");
//ajouter l'attribut modelMath
xml.add_Attribut(xml.courant,"modelMath", this.modelMath+"");
//ajouter l'element listeTF

286
xml.add_noeud(xml.courant,"listeTF", this.listeTF+"");
//ajouter l'element listeGY
xml.add_noeud(xml.courant,"listeGY", this.listeGY+"");
//ajouter l'element listeGY
xml.add_noeud(xml.courant,"listeOrient", this.listeOrient+"");
//ajouter l'element listeLien
xml.add_noeud(xml.courant,"listeLien", this.listeLien+"");
//ajouter l'element listeVar
xml.add_noeud(xml.courant,"listeVar", this.listeVar+"");
//ajouter l'element bcl_Causalite
xml.add_noeud(xml.courant,"bcl_Causalite", this.bcl_Causalite+"");
xml.save(this.fichier);
return true;
}catch(Exception ex){return false;}
}

/**
* la methode supprimer de la classe
*/
public boolean supprimer() throws Exception{
File file = new File(this.fichier);
try{
if(file.exists()){
XML xml= new XML(this.fichier);
if(xml.search("CCDs","CCD", "id", this.id+"")!=null){
xml.courant = xml.search("CCDs","CCD", "id", this.id+"");
xml.racine.removeContent(xml.courant);
xml.racine.removeChild(""+xml.courant);
xml.save(this.fichier);
return true;
}
return false;
}
return false;
}catch(Exception ex){return false;}
}

/**
* la methode modifier de la classe
*/
public boolean modifier() throws Exception{
try{
File file = new File(this.fichier);
if(file.exists()){
XML xml= new XML(this.fichier);
if(xml.search("CCDs","CCD", "id", this.id+"")!=null){
xml.courant = xml.search("CCDs","CCD", "id", this.id+"");
//modification de l'attribut id
xml.courant.getAttribute("id").setValue(this.id+"");
//modification de l'element gain
xml.courant.getChild("gain").setText(this.gain+"");
//modification de l'element ext1
xml.courant.getChild("ext1").setText(this.ext1+"");
//modification de l'element ext2
xml.courant.getChild("ext2").setText(this.ext2+"");
//modification de l'attribut modelMath

xml.courant.getAttribute("modelMath").setValue(this.modelMath+"");
//modification de l'element listeTF

xml.courant.getChild("listeOrient").setText(this.listeOrient+"");

287
//modification de l'element listeTF
xml.courant.getChild("listeTF").setText(this.listeTF+"");
//modification de l'element listeGY
xml.courant.getChild("listeGY").setText(this.listeGY+"");
//modification de l'element listeLien

xml.courant.getChild("listeLien").setText(this.listeLien+"");
//modification de l'element listeVar
xml.courant.getChild("listeVar").setText(this.listeVar+"");
//modification de l'element bcl_Causalite

xml.courant.getChild("bcl_Causalite").setText(this.bcl_Causalite+"");
xml.save(this.fichier);
return true;
}
return false;
}
return false;
}catch(Exception ex){return false;}
}

/**
* la methode lister de la classe (retourne une liste des objets du
fichier XML)
*/
public List lister(){
try{
File file = new File(this.fichier);
if(file.exists()){
CCD obj = new CCD(this.fichier);
List listeElmt=new ArrayList();
List listeObjet=new ArrayList();
Iterator itr;//itr pointe sur les elts de la list
Element parcourirElmt= new Element("aa");
List xmlListe= new ArrayList();

XML xml= new XML(this.fichier);


List liste = xml.racine.getChildren();
Iterator it = liste.iterator();//i pointe sur les elts de la
list
Element parcourir= new Element("aa");
while (it.hasNext()){
parcourir = (Element)it.next();

//recuperation de l'attribut id

obj.setId(Integer.parseInt(parcourir.getAttributeValue("id")));
//recuperation de l'element gain
obj.setGain(parcourir.getChildText("gain"));
//recuperation de l'element ext1
obj.setExt1(parcourir.getChildText("ext1"));
//recuperation de l'element ext2
obj.setExt2(parcourir.getChildText("ext2"));
//recuperation de l'attribut modelMath

obj.setModelMath(parcourir.getAttributeValue("modelMath"));
//recuperation de l'element listeTF
obj.setListeTF(parcourir.getChildText("listeTF"));

obj.setListeOrient(parcourir.getChildText("listeOrient"));
//recuperation de l'element listeGY

288
obj.setListeGY(parcourir.getChildText("listeGY"));
//recuperation de l'element listeLien
obj.setListeLien(parcourir.getChildText("listeLien"));
//recuperation de l'element listeVar
obj.setListeVar(parcourir.getChildText("listeVar"));
//recuperation de l'element bcl_Causalite

if(parcourir.getChildText("bcl_Causalite").equals("true"))
obj.setBcl_Causalite(true);
else
obj.setBcl_Causalite(false);
listeObjet.add(obj);
obj=new CCD(this.fichier);
}
if(listeObjet.size() < 1) return null;
return listeObjet;
}
return null;
}catch(Exception ex){return null;}
}

/**
* la methode rechercherParId de la classe (retourne un objet qui
contien la chaine de caractaire)
*/
public CCD rechercherParId(String aRechercher){
try{
File file = new File(this.fichier);
if(file.exists()){
CCD obj = new CCD(this.fichier);
List listeElmt;
Iterator itr;//itr pointe sur les elts de la list
Element parcourirElmt= new Element("aa");
List xmlListe= new ArrayList();

XML xml= new XML(this.fichier);


Element parcourir= new Element("aa");
if(xml.search("CCDs","CCD", "id", aRechercher)!=null){
parcourir = xml.search("CCDs","CCD", "id", aRechercher);
//recuperation de l'attribut id

obj.setId(Integer.parseInt(parcourir.getAttributeValue("id")));
//recuperation de l'element gain
obj.setGain(parcourir.getChildText("gain"));
//recuperation de l'element ext1
obj.setExt1(parcourir.getChildText("ext1"));
//recuperation de l'element ext2
obj.setExt2(parcourir.getChildText("ext2"));
//recuperation de l'attribut modelMath

obj.setModelMath(parcourir.getAttributeValue("modelMath"));
//recuperation de l'element listeTF
obj.setListeTF(parcourir.getChildText("listeTF"));
//recuperation de l'element listeGY
obj.setListeGY(parcourir.getChildText("listeGY"));
//recuperation de l'element listeLien
obj.setListeLien(parcourir.getChildText("listeLien"));
//recuperation de l'element listeVar
obj.setListeVar(parcourir.getChildText("listeVar"));

obj.setListeOrient(parcourir.getChildText("listeOrient"));

289
//recuperation de l'element bcl_Causalite

if(parcourir.getChildText("bcl_Causalite").equals("true"))
obj.setBcl_Causalite(true);
else
obj.setBcl_Causalite(false);
return obj;
}
return null;
}
return null;
}catch(Exception ex){return null;}
}

/**
* la methode rechercherParMotCle de la classe (retourne un objet qui
contien la chaine de caractaire)
*/
public List rechercherParMotCle(String motCle, String aRechercher){
try{
File file = new File(this.fichier);
if(file.exists()){
CCD obj = new CCD(this.fichier);
List listeElmt;
List listeObjet=new ArrayList();
Iterator itr;//itr pointe sur les elts de la list
Element parcourirElmt= new Element("aa");
List xmlListe= new ArrayList();

XML xml= new XML(this.fichier);


List liste = xml.racine.getChildren();
Iterator it = liste.iterator();//i pointe sur les elts de la
list
Element parcourir= new Element("aa");
boolean ok = false;
while (it.hasNext()){
parcourir = (Element)it.next();
if(motCle.equals("gain")){
if(aRechercher.equals(parcourir.getChildText("gain"))){
ok = true;
}
}
if(motCle.equals("ext1")){
if(aRechercher.equals(parcourir.getChildText("ext1"))){
ok = true;
}
}
if(motCle.equals("ext2")){
if(aRechercher.equals(parcourir.getChildText("ext2"))){
ok = true;
}
}
if(motCle.equals("listeTF")){

if(aRechercher.equals(parcourir.getChildText("listeTF"))){
ok = true;
}
}
if(motCle.equals("listeGY")){

if(aRechercher.equals(parcourir.getChildText("listeGY"))){

290
ok = true;
}
}
if(motCle.equals("listeLien")){

if(aRechercher.equals(parcourir.getChildText("listeLien"))){
ok = true;
}
}
if(motCle.equals("listeVar")){

if(aRechercher.equals(parcourir.getChildText("listeVar"))){
ok = true;
}
}
if(motCle.equals("bcl_Causalite")){

if(aRechercher.equals(parcourir.getChildText("bcl_Causalite"))){
ok = true;
}
}
if(ok){

//recuperation de l'attribut id

obj.setId(Integer.parseInt(parcourir.getAttributeValue("id")));
//recuperation de l'element gain
obj.setGain(parcourir.getChildText("gain"));
//recuperation de l'element ext1
obj.setExt1(parcourir.getChildText("ext1"));
//recuperation de l'element ext2
obj.setExt2(parcourir.getChildText("ext2"));
//recuperation de l'attribut modelMath

obj.setModelMath(parcourir.getAttributeValue("modelMath"));
//recuperation de l'element listeTF
obj.setListeTF(parcourir.getChildText("listeTF"));
//recuperation de l'element listeGY
obj.setListeGY(parcourir.getChildText("listeGY"));
//recuperation de l'element listeLien
obj.setListeLien(parcourir.getChildText("listeLien"));
//recuperation de l'element listeVar
obj.setListeVar(parcourir.getChildText("listeVar"));

obj.setListeOrient(parcourir.getChildText("listeOrient"));
//recuperation de l'element bcl_Causalite

if(parcourir.getChildText("bcl_Causalite").equals("true"))
obj.setBcl_Causalite(true);
else
obj.setBcl_Causalite(false);
listeObjet.add(obj);
obj=new CCD(this.fichier);
ok = false;
}
}
return listeObjet;
}
return null;
}catch(Exception ex){return null;}
}

291
/**
* La méthode calculerId permet de calculer l'identificateur du nouveau
CCD à ajouter
*/
public int calculerId() throws Exception
{
try
{
return this.idMax()+1;

}catch(Exception ex){return 0;}


}

public String inverser(String pile1)


{
String ss= "";
pile1 = pile1.substring(0,pile1.length()-1);
while(pile1.length()!=0)
{
if(pile1.lastIndexOf(",")==-1)
{
ss = ss + pile1 + ",";
return ss;
}
else

ss = ss +
pile1.substring(pile1.lastIndexOf(",")+1,pile1.length()) + ",";
pile1 = pile1.substring(0,pile1.lastIndexOf(","));
}
return ss;
}

public boolean existe(String liens) throws Exception


{
try
{
List liste = new ArrayList();
CCD chem = new CCD(this.fichier);

liens = inverser(liens);
liste = chem.rechercherParMotCle("listeLien",liens);
if(liste.size()==0) return false;
else return true;

}catch(Exception ex){return false;}


}

public String lire(String pile1)


{
if(pile1.length()== 0) return "";
pile1 = pile1.substring(0,pile1.lastIndexOf(","));
return
pile1.substring(pile1.lastIndexOf(",")+1,pile1.length());

public String depiler(String pile1)


{

292
if(pile1.length()== 0) return "";
pile1 = pile1.substring(0,pile1.lastIndexOf(","));
return pile1.substring(0,pile1.lastIndexOf(",")+1);

//Cette méthode permet de calculer le gain d'un chemin direct


public String calculerGain(String path) throws Exception
{
try
{
int n0 = 0,n1 = 0,signe = 1;
String liens = "",orient = "",vars = "",l1 = "",l2
= "";
String r1 = "",r2 = "",v1 = "",v2 ="",tmp= "",gain
= "",s = "",ss = "";
Lien l = new Lien(path + "Lien.xml");
Jonction jct = new Jonction(path + "Jonction.xml");

liens = this.getListeLien();
orient = this.getListeOrient();
vars = this.getListeVar();
gain = "";
l1= lire(liens);
r1 = lire(orient);
v1 = lire(vars);
vars = depiler(vars);
liens = depiler(liens);
orient = depiler(orient);
while(liens.length()!= 0)
{
l2 = lire(liens);
r2 = lire(orient);
v2 = lire(vars);

if(!r1.equals(r2))
{
l = l.rechercherParId(l2);
tmp = l.getExtremite(path);
tmp = tmp.substring(0,tmp.indexOf(","));
if(tmp.startsWith("0") &&
(v2.equals("f")))
n0++;
if(tmp.startsWith("1") &&
(v2.equals("e")))
n1++;
}
vars = depiler(vars);
liens = depiler(liens);
orient = depiler(orient);
l1 = l2;
v1 = v2;
r1 = r2;
}

signe = (int)Math.pow(-1,n0+n1);
tmp = this.getListeTF();

if(!tmp.equals("no"))
{

293
while(tmp.length()!=0)
{

s = lire(tmp);
jct = jct.rechercherParId(s);
ss = jct.getModule();
if(!ss.startsWith("1/"))
jct.calculerModule(path);
gain = jct.getModule() + "*";
tmp = depiler(tmp);
}
}
tmp = this.getListeGY();

if(!tmp.equals("no"))
{
while(tmp.length()!=0)
{
s = lire(tmp);
jct = jct.rechercherParId(s);
ss = jct.getModule();
if(!ss.startsWith("1/"))

jct.calculerModule(path);
gain = jct.getModule() + "*";
tmp = depiler(tmp);
}
}
if(gain.length()!=0)
gain =
gain.substring(0,gain.lastIndexOf("*"));

if(signe == -1)
gain = "-" + gain;
if(gain.length()==1)
gain = "-1";
if(gain.length()==0)
gain = "1";
s = this.getGain();
if(s.equals("no"))
{
this.setGain(gain);
this.modifier();
}
return gain;
}catch(Exception ex){return null;}
}
}

/* Classe BoucleCausale.java */

package BondGraph;

import java.util.*;
import java.util.Iterator;
import java.util.List;
import java.sql.Date;
import java.lang.Double;
import org.jdom.Element;
import XML_Package.*;
import java.io.*;

294
public class BoucleCausale{

int id;
String gain;
String ext1;
String ext2;
String modelMath;
int cheminAller;
int cheminRetour;
boolean bcl_algebrique;
String BclDisjointe;

private String str = "";


private String fichier = "";
private Element elt = new Element("aa");

/**
* le constructeur par défaut de la classe
*/
public BoucleCausale(){
id = 1;
gain = "no";
ext1 = "";
ext2 = "";
modelMath = "no";
cheminAller = 1;
cheminRetour = 1;
bcl_algebrique = false;
BclDisjointe = "no";
}

/**
* le constructeur de la classe
*/
public BoucleCausale(String fichier){
this.fichier = fichier;
id = 1;
gain = "no";
ext1 = "";
ext2 = "";
modelMath = "";
cheminAller = 1;
cheminRetour = 1;
bcl_algebrique = false;
BclDisjointe = "no";
}

/**
* le constructeur de la classe
*/
public BoucleCausale(String fichier, int id, String gain, String ext1,
String ext2, String modelMath, int cheminAller, int cheminRetour, boolean
bcl_algebrique, String BclDisjointe){
this.id = id;
this.gain = gain;
this.ext1 = ext1;
this.ext2 = ext2;
this.modelMath = modelMath;
this.cheminAller = cheminAller;
this.cheminRetour = cheminRetour;

295
this.bcl_algebrique = bcl_algebrique;
this.BclDisjointe = BclDisjointe;
this.fichier = fichier;
}

/**
* la methode set de la variable fichier
*/
public void setFichier(String fichier){
this.fichier = fichier;
}
/**
* la methode set de la variable id
*/
public void setId(int id){
this.id = id;
}
/**
* la methode set de la variable gain
*/
public void setGain(String gain){
this.gain = gain;
}
/**
* la methode set de la variable ext1
*/
public void setExt1(String ext1){
this.ext1 = ext1;
}
/**
* la methode set de la variable ext2
*/
public void setExt2(String ext2){
this.ext2 = ext2;
}
/**
* la methode set de la variable modelMath
*/
public void setModelMath(String modelMath){
this.modelMath = modelMath;
}
/**
* la methode set de la variable cheminAller
*/
public void setCheminAller(int cheminAller){
this.cheminAller = cheminAller;
}
/**
* la methode set de la variable cheminRetour
*/
public void setCheminRetour(int cheminRetour){
this.cheminRetour = cheminRetour;
}
/**
* la methode set de la variable bcl_algebrique
*/
public void setBcl_algebrique(boolean bcl_algebrique){
this.bcl_algebrique = bcl_algebrique;
}
/**
* la methode set de la variable BclDisjointe

296
*/
public void setBclDisjointe(String BclDisjointe){
this.BclDisjointe = BclDisjointe;
}
/**
* la methode get de la variable fichier
*/
public String getFichier(){
return this.fichier;
}
/**
* la methode get de la variable id
*/
public int getId(){
return id;
}
/**
* la methode get de la variable gain
*/
public String getGain(){
return gain;
}
/**
* la methode get de la variable ext1
*/
public String getExt1(){
return ext1;
}
/**
* la methode get de la variable ext2
*/
public String getExt2(){
return ext2;
}
/**
* la methode get de la variable modelMath
*/
public String getModelMath(){
return modelMath;
}
/**
* la methode get de la variable cheminAller
*/
public int getCheminAller(){
return cheminAller;
}
/**
* la methode get de la variable cheminRetour
*/
public int getCheminRetour(){
return cheminRetour;
}
/**
* la methode get de la variable bcl_algebrique
*/
public boolean getBcl_algebrique(){
return bcl_algebrique;
}
/**
* la methode get de la variable BclDisjointe
*/

297
public String setBclDisjointe(){
return BclDisjointe;
}
/**
* la methode idMax de la classe
*/
public int idMax() throws Exception{
try{
XML xml= new XML();
return xml.chercher_idmax(this.fichier);
}catch(Exception ex){return 0;}

/**
* la methode ajouter de la classe
*/
public boolean ajouter() throws Exception{
try{
XML xml= new XML();
File file = new File(this.fichier);
if(!file.exists()) xml.creerXML(this.fichier, "BoucleCausales");
xml= new XML(this.fichier);
xml.courant = xml.addNoeud(xml.racine, "BoucleCausale", "");
//ajouter l'attribut id
xml.add_Attribut(xml.courant,"id", this.id+"");
//ajouter l'element gain
xml.add_noeud(xml.courant,"gain", this.gain+"");
//ajouter l'element ext1
xml.add_noeud(xml.courant,"ext1", this.ext1+"");
//ajouter l'element ext2
xml.add_noeud(xml.courant,"ext2", this.ext2+"");
//ajouter l'attribut modelMath
xml.add_Attribut(xml.courant,"modelMath", this.modelMath+"");
//ajouter l'element cheminAller
xml.add_noeud(xml.courant,"cheminAller", this.cheminAller+"");
//ajouter l'element cheminRetour
xml.add_noeud(xml.courant,"cheminRetour", this.cheminRetour+"");
//ajouter l'element bcl_algebrique
xml.add_noeud(xml.courant,"bcl_algebrique",
this.bcl_algebrique+"");
//ajouter l'element BclDisjointe
xml.add_noeud(xml.courant,"BclDisjointe", this.BclDisjointe+"");
xml.save(this.fichier);
return true;
}catch(Exception ex){return false;}
}

/**
* la methode supprimer de la classe
*/
public boolean supprimer() throws Exception{
File file = new File(this.fichier);
try{
if(file.exists()){
XML xml= new XML(this.fichier);
if(xml.search("BoucleCausales","BoucleCausale", "id",
this.id+"")!=null){
xml.courant = xml.search("BoucleCausales","BoucleCausale",
"id", this.id+"");
xml.racine.removeContent(xml.courant);

298
xml.racine.removeChild(""+xml.courant);
xml.save(this.fichier);
return true;
}
return false;
}
return false;
}catch(Exception ex){return false;}
}

/**
* la methode modifier de la classe
*/
public boolean modifier() throws Exception{
try{
File file = new File(this.fichier);
if(file.exists()){
XML xml= new XML(this.fichier);
if(xml.search("BoucleCausales","BoucleCausale", "id",
this.id+"")!=null){
xml.courant = xml.search("BoucleCausales","BoucleCausale",
"id", this.id+"");
//modification de l'attribut id
xml.courant.getAttribute("id").setValue(this.id+"");
//modification de l'element gain
xml.courant.getChild("gain").setText(this.gain+"");
//modification de l'element ext1
xml.courant.getChild("ext1").setText(this.ext1+"");
//modification de l'element ext2
xml.courant.getChild("ext2").setText(this.ext2+"");
//modification de l'attribut modelMath

xml.courant.getAttribute("modelMath").setValue(this.modelMath+"");
//modification de l'element cheminAller

xml.courant.getChild("cheminAller").setText(this.cheminAller+"");
//modification de l'element cheminRetour

xml.courant.getChild("cheminRetour").setText(this.cheminRetour+"");
//modification de l'element bcl_algebrique

xml.courant.getChild("bcl_algebrique").setText(this.bcl_algebrique+"");
//modification de l'element bcl_algebrique

xml.courant.getChild("BclDisjointe").setText(this.BclDisjointe+"");
xml.save(this.fichier);
return true;
}
return false;
}
return false;
}catch(Exception ex){return false;}
}

/**
* la methode lister de la classe (retourne une liste des objets du
fichier XML)
*/
public List lister(){
try{
File file = new File(this.fichier);

299
if(file.exists()){
BoucleCausale obj = new BoucleCausale(this.fichier);
List listeElmt=new ArrayList();
List listeObjet=new ArrayList();
Iterator itr;//itr pointe sur les elts de la list
Element parcourirElmt= new Element("aa");
List xmlListe= new ArrayList();

XML xml= new XML(this.fichier);


List liste = xml.racine.getChildren();
Iterator it = liste.iterator();//i pointe sur les elts de la
list
Element parcourir= new Element("aa");
while (it.hasNext()){
parcourir = (Element)it.next();
//recuperation de l'attribut id

obj.setId(Integer.parseInt(parcourir.getAttributeValue("id")));
//recuperation de l'element gain
obj.setGain(parcourir.getChildText("gain"));
//recuperation de l'element ext1
obj.setExt1(parcourir.getChildText("ext1"));
//recuperation de l'element ext2
obj.setExt2(parcourir.getChildText("ext2"));
//recuperation de l'attribut modelMath

obj.setModelMath(parcourir.getAttributeValue("modelMath"));
//recuperation de l'element cheminAller

obj.setCheminAller(Integer.parseInt(parcourir.getChildText("cheminAller")))
;
//recuperation de l'element cheminRetour

obj.setCheminRetour(Integer.parseInt(parcourir.getChildText("cheminRetour")
));
//recuperation de l'element BclDisjointe

obj.setBclDisjointe(parcourir.getChildText("BclDisjointe"));
//recuperation de l'element bcl_algebrique

if(parcourir.getChildText("bcl_algebrique").equals("true"))
obj.setBcl_algebrique(true);
else
obj.setBcl_algebrique(false);
listeObjet.add(obj);
obj=new BoucleCausale(this.fichier);
}
if(listeObjet.size() < 1) return null;
return listeObjet;
}
return null;
}catch(Exception ex){return null;}
}

/**
* la methode rechercherParId de la classe (retourne un objet qui
contien la chaine de caractaire)
*/
public BoucleCausale rechercherParId(String aRechercher){
try{
File file = new File(this.fichier);

300
if(file.exists()){
BoucleCausale obj = new BoucleCausale(this.fichier);
List listeElmt;
Iterator itr;//itr pointe sur les elts de la list
Element parcourirElmt= new Element("aa");
List xmlListe= new ArrayList();

XML xml= new XML(this.fichier);


Element parcourir= new Element("aa");
if(xml.search("BoucleCausales","BoucleCausale", "id",
aRechercher)!=null){
parcourir = xml.search("BoucleCausales","BoucleCausale",
"id", aRechercher);

//recuperation de l'attribut id

obj.setId(Integer.parseInt(parcourir.getAttributeValue("id")));
//recuperation de l'element gain
obj.setGain(parcourir.getChildText("gain"));
//recuperation de l'element ext1
obj.setExt1(parcourir.getChildText("ext1"));
//recuperation de l'element ext2
obj.setExt2(parcourir.getChildText("ext2"));
//recuperation de l'attribut modelMath

obj.setModelMath(parcourir.getAttributeValue("modelMath"));
//recuperation de l'element cheminAller

obj.setCheminAller(Integer.parseInt(parcourir.getChildText("cheminAller")))
;
//recuperation de l'element cheminRetour

obj.setCheminRetour(Integer.parseInt(parcourir.getChildText("cheminRetour")
));
//recuperation de l'element BclDisjointe

obj.setBclDisjointe(parcourir.getChildText("BclDisjointe"));
//recuperation de l'element bcl_algebrique

if(parcourir.getChildText("bcl_algebrique").equals("true"))
obj.setBcl_algebrique(true);
else
obj.setBcl_algebrique(false);
return obj;
}
return null;
}
return null;
}catch(Exception ex){return null;}
}

/**
* la methode rechercherParMotCle de la classe (retourne un objet qui
contien la chaine de caractaire)
*/
public List rechercherParMotCle(String motCle, String aRechercher){
try{
File file = new File(this.fichier);
if(file.exists()){
BoucleCausale obj = new BoucleCausale(this.fichier);
List listeElmt;

301
List listeObjet=new ArrayList();
Iterator itr;//itr pointe sur les elts de la list
Element parcourirElmt= new Element("aa");
List xmlListe= new ArrayList();

XML xml= new XML(this.fichier);


List liste = xml.racine.getChildren();
Iterator it = liste.iterator();//i pointe sur les elts de la
list
Element parcourir= new Element("aa");
boolean ok = false;
while (it.hasNext()){
parcourir = (Element)it.next();
if(motCle.equals("gain")){
if(aRechercher.equals(parcourir.getChildText("gain"))){
ok = true;
}
}
if(motCle.equals("ext1")){
if(aRechercher.equals(parcourir.getChildText("ext1"))){
ok = true;
}
}
if(motCle.equals("ext2")){
if(aRechercher.equals(parcourir.getChildText("ext2"))){
ok = true;
}
}
if(motCle.equals("cheminAller")){

if(aRechercher.equals(parcourir.getChildText("cheminAller"))){
ok = true;
}
}
if(motCle.equals("cheminRetour")){

if(aRechercher.equals(parcourir.getChildText("cheminRetour"))){
ok = true;
}
}
if(motCle.equals("bcl_algebrique")){

if(aRechercher.equals(parcourir.getChildText("bcl_algebrique"))){
ok = true;
}
}
if(ok){

//recuperation de l'attribut id

obj.setId(Integer.parseInt(parcourir.getAttributeValue("id")));
//recuperation de l'element gain
obj.setGain(parcourir.getChildText("gain"));
//recuperation de l'element ext1
obj.setExt1(parcourir.getChildText("ext1"));
//recuperation de l'element ext2
obj.setExt2(parcourir.getChildText("ext2"));
//recuperation de l'attribut modelMath

obj.setModelMath(parcourir.getAttributeValue("modelMath"));
//recuperation de l'element cheminAller

302
obj.setCheminAller(Integer.parseInt(parcourir.getChildText("cheminAller")))
;
//recuperation de l'element cheminRetour

obj.setCheminRetour(Integer.parseInt(parcourir.getChildText("cheminRetour")
));
//recuperation de l'element BclDisjointe

obj.setBclDisjointe(parcourir.getChildText("BclDisjointe"));
//recuperation de l'element bcl_algebrique

if(parcourir.getChildText("bcl_algebrique").equals("true"))
obj.setBcl_algebrique(true);
else
obj.setBcl_algebrique(false);
listeObjet.add(obj);
obj=new BoucleCausale(this.fichier);
ok = false;
}
}
return listeObjet;
}
return null;
}catch(Exception ex){return null;}
}

/**
* La méthode calculerId permet de calculer l'identificateur de la
nouvelle boucle à ajouter
*/
public int calculerId() throws Exception
{
try
{
return this.idMax()+1;

}catch(Exception ex){return 0;}


}

/**
* La méthode calculerGain permet de calculer le gain d'une boucle
causale
*/
public void calculerGain(String path) throws Exception
{
try
{
String gain = this.getGain();
if(gain.equals("no"))
{
Elemen elt = new Elemen (path + "Element.xml");
CCD chemin = new CCD (path + "CCD.xml");
String tmp = "", s = "", ss = "";
boolean negative = false;

gain = "";
//Calcul du gain des extrémités de la boucle
elt = elt.rechercherParId(this.getExt1());
elt.calculerGain(path);
gain = elt.getGain();

303
elt = elt.rechercherParId(this.getExt2());
elt.calculerGain(path);
gain = gain + " * " + elt.getGain();
//Calcul du gain du parcours d'aller
chemin =
chemin.rechercherParId(this.getCheminAller() + "");
chemin.calculerGain(path);
s = chemin.getGain();
if(s.startsWith("-"))
{
negative = true;
s = s.substring(1,s.length());
if(!s.equals("1"))
gain = gain + " * " + s;
}
else
if(!s.equals("1"))
gain = gain + " * " + chemin.getGain();
//Calcul du gain du parcours de retour
chemin =
chemin.rechercherParId(this.getCheminRetour() + "");
s = chemin.getListeVar();
while(s.length()!=0) //inverser la variable suivie
{
tmp = s.substring(0,s.indexOf(","));
if(tmp.equals("e"))
ss = ss + "f,";
else
ss = ss + "e,";
s = s.substring(s.indexOf(",")+1,s.length());
}
chemin.setListeVar(ss);
s = chemin.calculerGain(path);
if(s.startsWith("-"))
{
s = s.substring(1,s.length());
if(negative)
gain = gain + " * " + s;

else
{
if(!s.equals("1"))
gain = "-" + gain + s;
else
gain = "-" + gain;
}
}
else
{
if(!s.equals("1"))
gain = gain + " * " + chemin.getGain();
if(negative)
gain = "-" + gain;
}
this.setGain(gain);
this.modifier();
}
}catch(Exception ex){return;}
}
public String lire(String pile1)
{

304
if(pile1.length()== 0) return "";
pile1 = pile1.substring(0,pile1.lastIndexOf(","));
return
pile1.substring(pile1.lastIndexOf(",")+1,pile1.length());

public String depiler(String pile1)


{
if(pile1.length()== 0) return "";
pile1 = pile1.substring(0,pile1.lastIndexOf(","));
return pile1.substring(0,pile1.lastIndexOf(",")+1);

public boolean existe(String sMarque,String s)


{
while(sMarque.length()>0)
{
if(s.equals(lire(sMarque)))
return true;
sMarque = depiler(sMarque);
}

return false;
}

/**
* La méthode calculerDisjoint permet de calculer les boucles
disjointes à cette boucle
*/

public void calculerDisjoint(String path) throws Exception


{
try
{
CCD chemin = new CCD(path + "CCD.xml");
BoucleCausale boucle = new BoucleCausale(path +
"BoucleCausale.xml");
List liste = new ArrayList();
String tmp = "",s= "", ss = "",lien1 = "",lienA =
"",lienR = "",disj="";
String varA = "",varR = "",vars1 = "",l1 = "",v1 =
"",vars2 = "",lien2 = "",l = "",v = "",p = "",pp="";
boolean Ndisjoint = false;
int id1;

liste = boucle.lister();
tmp = this.getCheminAller()+"";
chemin = chemin.rechercherParId(tmp);
lienA = chemin.getListeLien();
varA = chemin.getListeVar();
tmp = this.getCheminRetour() + "";
chemin = chemin.rechercherParId(tmp);
lienR = chemin.getListeLien();
s = chemin.getListeVar();
while(s.length()!=0) //inverser la variable suivie
{
tmp = s.substring(0,s.indexOf(","));
if(tmp.equals("e"))
ss = ss + "f,";

305
else
ss = ss + "e,";
s = s.substring(s.indexOf(",")+1,s.length());
}
varR = ss;
for(int j = 0; j<liste.size(); j++)
{
boucle = (BoucleCausale)liste.get(j);
id1 = boucle.getId();Ndisjoint = false;
if(id1!= this.getId())
{
//Comparer lienA avec le chemin d'aller
tmp = boucle.getCheminAller() + "";
chemin = chemin.rechercherParId(tmp);
lien1 = chemin.getListeLien();
vars1 = chemin.getListeVar();
p = lienA;
pp = varA;
while(p.length()!=0)
{
l= p.substring(0,p.indexOf(","));
v = pp.substring(0,pp.indexOf(","));
s= lien1;
ss = vars1;
while(s.length()!=0)
{
l1= s.substring(0,s.indexOf(","));
v1 =
ss.substring(0,ss.indexOf(","));
if((l1.equals(l)) &&
(v1.equals(v)))
{
Ndisjoint = true;break;
}
s =
s.substring(s.indexOf(",")+1,s.length());
ss =
ss.substring(ss.indexOf(",")+1,ss.length());

}
if(Ndisjoint)
break;

p =
p.substring(p.indexOf(",")+1,p.length());
pp =
pp.substring(pp.indexOf(",")+1,pp.length());
}
if(!Ndisjoint)
{
//Comparer lienA avec le chemin de
retour
tmp = boucle.getCheminRetour() + "";
chemin = chemin.rechercherParId(tmp);
lien2 = chemin.getListeLien();
//on recupere la liste des variables
suivie dans le chemin de retour de la boucle
s = chemin.getListeVar();
while(s.length()!=0) //inverser la
variable suivie
{

306
tmp =
s.substring(0,s.indexOf(","));
if(tmp.equals("e"))
ss = ss + "f,";
else
ss = ss + "e,";
s =
s.substring(s.indexOf(",")+1,s.length());
}
vars2 = ss;
p = lienA;
pp = varA;
while(p.length()!=0)
{
l= p.substring(0,p.indexOf(","));
v =
pp.substring(0,pp.indexOf(","));
s= lien2;
ss = vars2;
while(s.length()!=0)
{
l1=
s.substring(0,s.indexOf(","));
v1 =
ss.substring(0,ss.indexOf(","));
if((l1.equals(l)) &&
(v1.equals(v)))
{
Ndisjoint =
true;break;
}
s =
s.substring(s.indexOf(",")+1,s.length());
ss =
ss.substring(ss.indexOf(",")+1,ss.length());

}
if(Ndisjoint)
break;

p =
p.substring(p.indexOf(",")+1,p.length());
pp =
pp.substring(pp.indexOf(",")+1,pp.length());
}
if(!Ndisjoint)
{
//Comparer lienR avec le chemin
d'aller
p = lienR;
pp = varR;
while(p.length()!=0)
{
l=
p.substring(0,p.indexOf(","));
v =
pp.substring(0,pp.indexOf(","));
s= lien1;
ss = vars1;
while(s.length()!=0)
{

307
l1=
s.substring(0,s.indexOf(","));
v1 =
ss.substring(0,ss.indexOf(","));
if((l1.equals(l)) &&
(v1.equals(v)))
{
Ndisjoint =
true;break;
}
s =
s.substring(s.indexOf(",")+1,s.length());
ss =
ss.substring(ss.indexOf(",")+1,ss.length());

}
if(Ndisjoint)
break;

p =
p.substring(p.indexOf(",")+1,p.length());
pp =
pp.substring(pp.indexOf(",")+1,pp.length());
}

//Comparer lienR avec le chemin de


retour
if(!Ndisjoint)
{
p = lienR;
pp = varR;
while(p.length()!=0)
{
l=
p.substring(0,p.indexOf(","));
v =
pp.substring(0,pp.indexOf(","));
s = lien2;
ss = vars2;
while(s.length()!=0)
{
l1=
s.substring(0,s.indexOf(","));
v1 =
ss.substring(0,ss.indexOf(","));

if((l1.equals(l)) && (v1.equals(v)))


{
Ndisjoint
= true;break;
}
s =
s.substring(s.indexOf(",")+1,s.length());
ss =
ss.substring(ss.indexOf(",")+1,ss.length());

}
if(Ndisjoint)
break;

308
p =
p.substring(p.indexOf(",")+1,p.length());
pp =
pp.substring(pp.indexOf(",")+1,pp.length());
}

}
}
if(!Ndisjoint)
disj = disj + id1 + ",";
}

}
if(disj.length()!=0)
{
this.setBclDisjointe(disj);
this.modifier();
}

}catch(Exception ex){return;}
}
}

/* Classe CCI.java */

package BondGraph;

import java.util.*;
import java.util.Iterator;
import java.util.List;
import java.sql.Date;
import java.lang.Double;
import org.jdom.Element;
import XML_Package.*;
import java.io.*;

public class CCI{

int id;
String gain;
String ext1;
String ext2;
String listePassif;
String listeCCD;
String modelMath;

private String str = "";


private String fichier = "";
private Element elt = new Element("aa");
/**
* le constructeur par défaut de la classe
*/
public CCI(){
id = 1;
gain = "no";
ext1 = "";
ext2 = "";
listePassif = "";

309
listeCCD = "";
modelMath = "";
}
/**
* le constructeur de la classe
*/
public CCI(String fichier){
this.fichier = fichier;
id = 1;
gain = "no";
ext1 = "";
ext2 = "";
listePassif = "";
listeCCD = "";
modelMath = "";
}
/**
* le constructeur de la classe
*/
public CCI(String fichier, int id, String gain, String ext1, String
ext2, String listePassif, String listeCCD, String modelMath){
this.id = id;
this.gain = gain;
this.ext1 = ext1;
this.ext2 = ext2;
this.listePassif = listePassif;
this.listeCCD = listeCCD;
this.modelMath = modelMath;
this.fichier = fichier;
}
/**
* la methode set de la variable fichier
*/
public void setFichier(String fichier){
this.fichier = fichier;
}
/**
* la methode set de la variable id
*/
public void setId(int id){
this.id = id;
}
/**
* la methode set de la variable gain
*/
public void setGain(String gain){
this.gain = gain;
}
/**
* la methode set de la variable ext1
*/
public void setExt1(String ext1){
this.ext1 = ext1;
}
/**
* la methode set de la variable ext2
*/
public void setExt2(String ext2){
this.ext2 = ext2;
}
/**

310
* la methode set de la variable listePassif
*/
public void setListePassif(String listePassif){
this.listePassif = listePassif;
}
/**
* la methode set de la variable listeCCD
*/
public void setListeCCD(String listeCCD){
this.listeCCD = listeCCD;
}
/**
* la methode set de la variable modelMath
*/
public void setModelMath(String modelMath){
this.modelMath = modelMath;
}
/**
* la methode get de la variable fichier
*/
public String getFichier(){
return this.fichier;
}
/**
* la methode get de la variable id
*/
public int getId(){
return id;
}
/**
* la methode get de la variable gain
*/
public String getGain(){
return gain;
}
/**
* la methode get de la variable ext1
*/
public String getExt1(){
return ext1;
}
/**
* la methode get de la variable ext2
*/
public String getExt2(){
return ext2;
}
/**
* la methode get de la variable listePassif
*/
public String getListePassif(){
return listePassif;
}
/**
* la methode get de la variable listeCCD
*/
public String getListeCCD(){
return listeCCD;
}
/**
* la methode get de la variable modelMath

311
*/
public String getModelMath(){
return modelMath;
}
/**
* la methode idMax de la classe
*/
public int idMax() throws Exception{
try{
XML xml= new XML();
return xml.chercher_idmax(this.fichier);
}catch(Exception ex){return 0;}

/**
* la methode ajouter de la classe
*/
public boolean ajouter() throws Exception{
try{
XML xml= new XML();
File file = new File(this.fichier);
if(!file.exists()) xml.creerXML(this.fichier, "CCIs");
xml= new XML(this.fichier);
xml.courant = xml.addNoeud(xml.racine, "CCI", "");
//ajouter l'attribut id
xml.add_Attribut(xml.courant,"id", this.id+"");
//ajouter l'element gain
xml.add_noeud(xml.courant,"gain", this.gain+"");
//ajouter l'element ext1
xml.add_noeud(xml.courant,"ext1", this.ext1+"");
//ajouter l'element ext2
xml.add_noeud(xml.courant,"ext2", this.ext2+"");
//ajouter l'element listePassif
xml.add_noeud(xml.courant,"listePassif", this.listePassif+"");
//ajouter l'element listeCCD
xml.add_noeud(xml.courant,"listeCCD", this.listeCCD+"");
//ajouter l'attribut modelMath
xml.add_Attribut(xml.courant,"modelMath", this.modelMath+"");
xml.save(this.fichier);
return true;
}catch(Exception ex){return false;}
}

/**
* la methode supprimer de la classe
*/
public boolean supprimer() throws Exception{
File file = new File(this.fichier);
try{
if(file.exists()){
XML xml= new XML(this.fichier);
if(xml.search("CCIs","CCI", "id", this.id+"")!=null){
xml.courant = xml.search("CCIs","CCI", "id", this.id+"");
xml.racine.removeContent(xml.courant);
xml.racine.removeChild(""+xml.courant);
xml.save(this.fichier);
return true;
}
return false;
}

312
return false;
}catch(Exception ex){return false;}

/**
* la methode modifier de la classe
*/
public boolean modifier() throws Exception{
try{
File file = new File(this.fichier);
if(file.exists()){
XML xml= new XML(this.fichier);
if(xml.search("CCIs","CCI", "id", this.id+"")!=null){
xml.courant = xml.search("CCIs","CCI", "id", this.id+"");
//modification de l'attribut id
xml.courant.getAttribute("id").setValue(this.id+"");
//modification de l'element gain
xml.courant.getChild("gain").setText(this.gain+"");
//modification de l'element ext1
xml.courant.getChild("ext1").setText(this.ext1+"");
//modification de l'element ext2
xml.courant.getChild("ext2").setText(this.ext2+"");
//modification de l'element listePassif

xml.courant.getChild("listePassif").setText(this.listePassif+"");
//modification de l'element listeCCD
xml.courant.getChild("listeCCD").setText(this.listeCCD+"");
//modification de l'attribut modelMath

xml.courant.getAttribute("modelMath").setValue(this.modelMath+"");
xml.save(this.fichier);
return true;
}
return false;
}
return false;
}catch(Exception ex){return false;}
}

/**
* la methode lister de la classe (retourne une liste des objets du
fichier XML)
*/
public List lister(){
try{
File file = new File(this.fichier);
if(file.exists()){
CCI obj = new CCI(this.fichier);
List listeElmt=new ArrayList();
List listeObjet=new ArrayList();
Iterator itr;//itr pointe sur les elts de la list
Element parcourirElmt= new Element("aa");
List xmlListe= new ArrayList();

XML xml= new XML(this.fichier);


List liste = xml.racine.getChildren();
Iterator it = liste.iterator();//i pointe sur les elts de la
list
Element parcourir= new Element("aa");
while (it.hasNext()){

313
parcourir = (Element)it.next();
//recuperation de l'attribut id

obj.setId(Integer.parseInt(parcourir.getAttributeValue("id")));
//recuperation de l'element gain
obj.setGain(parcourir.getChildText("gain"));
//recuperation de l'element ext1
obj.setExt1(parcourir.getChildText("ext1"));
//recuperation de l'element ext2
obj.setExt2(parcourir.getChildText("ext2"));
//recuperation de l'element listePassif

obj.setListePassif(parcourir.getChildText("listePassif"));
//recuperation de l'element listeCCD
obj.setListeCCD(parcourir.getChildText("listeCCD"));
//recuperation de l'attribut modelMath

obj.setModelMath(parcourir.getAttributeValue("modelMath"));
listeObjet.add(obj);
obj=new CCI(this.fichier);
}
if(listeObjet.size() < 1) return null;
return listeObjet;
}
return null;
}catch(Exception ex){return null;}
}

/**
* la methode rechercherParId de la classe (retourne un objet qui
contien la chaine de caractaire)
*/
public CCI rechercherParId(String aRechercher){
try{
File file = new File(this.fichier);
if(file.exists()){
CCI obj = new CCI(this.fichier);
List listeElmt;
Iterator itr;//itr pointe sur les elts de la list
Element parcourirElmt= new Element("aa");
List xmlListe= new ArrayList();

XML xml= new XML(this.fichier);


Element parcourir= new Element("aa");
if(xml.search("CCIs","CCI", "id", aRechercher)!=null){
parcourir = xml.search("CCIs","CCI", "id", aRechercher);
//recuperation de l'attribut id

obj.setId(Integer.parseInt(parcourir.getAttributeValue("id")));
//recuperation de l'element gain
obj.setGain(parcourir.getChildText("gain"));
//recuperation de l'element ext1
obj.setExt1(parcourir.getChildText("ext1"));
//recuperation de l'element ext2
obj.setExt2(parcourir.getChildText("ext2"));
//recuperation de l'element listePassif

obj.setListePassif(parcourir.getChildText("listePassif"));
//recuperation de l'element listeCCD
obj.setListeCCD(parcourir.getChildText("listeCCD"));
//recuperation de l'attribut modelMath

314
obj.setModelMath(parcourir.getAttributeValue("modelMath"));
return obj;
}
return null;
}
return null;
}catch(Exception ex){return null;}
}

/**
* la methode rechercherParMotCle de la classe (retourne un objet qui
contien la chaine de caractaire)
*/
public List rechercherParMotCle(String motCle, String aRechercher){
try{
File file = new File(this.fichier);
if(file.exists()){
CCI obj = new CCI(this.fichier);
List listeElmt;
List listeObjet=new ArrayList();
Iterator itr;//itr pointe sur les elts de la list
Element parcourirElmt= new Element("aa");
List xmlListe= new ArrayList();

XML xml= new XML(this.fichier);


List liste = xml.racine.getChildren();
Iterator it = liste.iterator();//i pointe sur les elts de la
list
Element parcourir= new Element("aa");
boolean ok = false;
while (it.hasNext()){
parcourir = (Element)it.next();
if(motCle.equals("gain")){
if(aRechercher.equals(parcourir.getChildText("gain"))){
ok = true;
}
}
if(motCle.equals("ext1")){
if(aRechercher.equals(parcourir.getChildText("ext1"))){
ok = true;
}
}
if(motCle.equals("ext2")){
if(aRechercher.equals(parcourir.getChildText("ext2"))){
ok = true;
}
}
if(motCle.equals("listePassif")){

if(aRechercher.equals(parcourir.getChildText("listePassif"))){
ok = true;
}
}
if(motCle.equals("listeCCD")){

if(aRechercher.equals(parcourir.getChildText("listeCCD"))){
ok = true;
}
}
if(ok){

315
//recuperation de l'attribut id

obj.setId(Integer.parseInt(parcourir.getAttributeValue("id")));
//recuperation de l'element gain
obj.setGain(parcourir.getChildText("gain"));
//recuperation de l'element ext1
obj.setExt1(parcourir.getChildText("ext1"));
//recuperation de l'element ext2
obj.setExt2(parcourir.getChildText("ext2"));
//recuperation de l'element listePassif

obj.setListePassif(parcourir.getChildText("listePassif"));
//recuperation de l'element listeCCD
obj.setListeCCD(parcourir.getChildText("listeCCD"));
//recuperation de l'attribut modelMath

obj.setModelMath(parcourir.getAttributeValue("modelMath"));
listeObjet.add(obj);
obj=new CCI(this.fichier);
ok = false;
}
}
return listeObjet;
}
return null;
}catch(Exception ex){return null;}
}

/**
* La méthode calculerId permet de calculer l'identificateur du nouveau
CCI à ajouter
*/

public int calculerId() throws Exception


{
try
{
return this.idMax()+1;

}catch(Exception ex){return 0;}


}

/**
* La méthode calculerGain permet de calculer le gain d'un CCI
*/

public void calculerGain(String path) throws Exception


{
try
{
String gain = this.getGain();
if(gain.equals("no"))
{
Elemen elt = new Elemen (path + "Element.xml");
CCD chemin = new CCD (path + "CCD.xml");
String tmp = "", s = "", ss = "",tmp2 = "";
boolean negative = false,effort = true;

gain = "";

316
//Calcul du gain des élements passifs qui composent
le chemin
s = this.getListePassif();
while(s.length()!=0)
{
tmp = s.substring(0,s.indexOf(","));
elt = elt.rechercherParId(tmp);
elt.calculerGain(path);
gain = elt.getGain() + " * ";

s = s.substring(s.indexOf(",")+1,s.length());
}
gain = gain.substring(0,gain.length()-3);
//Calcul du gain des CCD qui composent le chemin
s = this.getListeCCD();
while(s.length()!=0)
{
tmp = s.substring(0,s.indexOf(","));
chemin = chemin.rechercherParId(tmp);
if(effort)
chemin.calculerGain(path);
else
{
ss = "";
tmp2 = chemin.getListeVar();
while(tmp2.length()!=0) //inverser la
variable suivie
{
tmp =
tmp2.substring(0,tmp2.indexOf(","));
if(tmp.equals("e"))
ss = ss + "f,";
else
ss = ss + "e,";
tmp2 =
tmp2.substring(tmp2.indexOf(",")+1,tmp2.length());
}
chemin.setListeVar(ss);
}
ss = chemin.calculerGain(path);
if(ss.startsWith("-"))
{
if(negative)
negative = false;
else
negative = true;
ss = ss.substring(1,ss.length());
if(!ss.equals("1"))
gain = gain + " * " + ss;
}
else
if(!ss.equals("1"))
gain = gain + " * " +
chemin.getGain();
s = s.substring(s.indexOf(",")+1,s.length());
effort = false;
}
if(negative)
gain = "-" + gain;
this.setGain(gain);

317
this.modifier();

}
}catch(Exception ex){return;}
}
}

/* Classe Vecteur.java */

package BondGraph;

import java.util.*;
import java.util.Iterator;
import java.util.List;
import java.sql.Date;
import java.lang.Double;
import org.jdom.Element;
import XML_Package.*;
import java.io.*;

public class Vecteur{


String id;
String modelMath;
String ve;
String vs;

private String str = "";


private String fichier = "";
private Element elt = new Element("aa");
/**
* le constructeur par défaut de la classe
*/
public Vecteur(){
id = "";
modelMath = "";
ve = "";
vs = "";
}
/**
* le constructeur de la classe
*/
public Vecteur(String fichier){
this.fichier = fichier;
id = "";
modelMath = "";
ve = "";
vs = "";
}
/**
* le constructeur de la classe
*/
public Vecteur(String fichier, String id, String modelMath, String ve,
String vs){
this.id = id;
this.modelMath = modelMath;
this.ve = ve;
this.vs = vs;
this.fichier = fichier;
}
/**
* la methode set de la variable fichier

318
*/
public void setFichier(String fichier){
this.fichier = fichier;
}
/**
* la methode set de la variable id
*/
public void setId(String id){
this.id = id;
}
/**
* la methode set de la variable modelMath
*/
public void setModelMath(String modelMath){
this.modelMath = modelMath;
}
/**
* la methode set de la variable ve
*/
public void setVe(String ve){
this.ve = ve;
}
/**
* la methode set de la variable vs
*/
public void setVs(String vs){
this.vs = vs;
}
/**
* la methode get de la variable fichier
*/
public String getFichier(){
return this.fichier;
}
/**
* la methode get de la variable id
*/
public String getId(){
return id;
}
/**
* la methode get de la variable modelMath
*/
public String getModelMath(){
return modelMath;
}
/**
* la methode get de la variable ve
*/
public String getVe(){
return ve;
}
/**
* la methode get de la variable vs
*/
public String getVs(){
return vs;
}
/**
* la methode idMax de la classe
*/

319
public int idMax() throws Exception{
try{
XML xml= new XML();
return xml.chercher_idmax(this.fichier);
}catch(Exception ex){return 0;}
}

/**
* la methode ajouter de la classe
*/
public boolean ajouter() throws Exception{
try{
XML xml= new XML();
File file = new File(this.fichier);
if(!file.exists()) xml.creerXML(this.fichier, "Vecteurs");
xml= new XML(this.fichier);
xml.courant = xml.addNoeud(xml.racine, "Vecteur", "");
//ajouter l'attribut id
xml.add_Attribut(xml.courant,"id", this.id+"");
//ajouter l'attribut modelMath
xml.add_Attribut(xml.courant,"modelMath", this.modelMath+"");
//ajouter l'element ve
xml.add_noeud(xml.courant,"ve", this.ve+"");
//ajouter l'element vs
xml.add_noeud(xml.courant,"vs", this.vs+"");
xml.save(this.fichier);
return true;
}catch(Exception ex){return false;}
}

/**
* la methode supprimer de la classe
*/
public boolean supprimer() throws Exception{
File file = new File(this.fichier);
try{
if(file.exists()){
XML xml= new XML(this.fichier);
if(xml.search("Vecteurs","Vecteur", "id", this.id+"")!=null){
xml.courant = xml.search("Vecteurs","Vecteur", "id",
this.id+"");
xml.racine.removeContent(xml.courant);
xml.racine.removeChild(""+xml.courant);
xml.save(this.fichier);
return true;
}
return false;
}
return false;
}catch(Exception ex){return false;}
}

/**
* la methode modifier de la classe
*/
public boolean modifier() throws Exception{
try{
File file = new File(this.fichier);
if(file.exists()){
XML xml= new XML(this.fichier);
if(xml.search("Vecteurs","Vecteur", "id", this.id+"")!=null){

320
xml.courant = xml.search("Vecteurs","Vecteur", "id",
this.id+"");
//modification de l'attribut id
xml.courant.getAttribute("id").setValue(this.id+"");
//modification de l'attribut modelMath

xml.courant.getAttribute("modelMath").setValue(this.modelMath+"");
//modification de l'element ve
xml.courant.getChild("ve").setText(this.ve+"");
//modification de l'element vs
xml.courant.getChild("vs").setText(this.vs+"");
xml.save(this.fichier);
return true;
}
return false;
}
return false;
}catch(Exception ex){return false;}
}

/**
* la methode lister de la classe (retourne une liste des objets du
fichier XML)
*/
public List lister(){
try{
File file = new File(this.fichier);
if(file.exists()){
Vecteur obj = new Vecteur(this.fichier);
List listeElmt=new ArrayList();
List listeObjet=new ArrayList();
Iterator itr;//itr pointe sur les elts de la list
Element parcourirElmt= new Element("aa");
List xmlListe= new ArrayList();

XML xml= new XML(this.fichier);


List liste = xml.racine.getChildren();
Iterator it = liste.iterator();//i pointe sur les elts de la
list
Element parcourir= new Element("aa");
while (it.hasNext()){
parcourir = (Element)it.next();
//recuperation de l'attribut id
obj.setId(parcourir.getAttributeValue("id"));
//recuperation de l'attribut modelMath

obj.setModelMath(parcourir.getAttributeValue("modelMath"));
//recuperation de l'element ve
obj.setVe(parcourir.getChildText("ve"));
//recuperation de l'element vs
obj.setVs(parcourir.getChildText("vs"));
listeObjet.add(obj);
obj=new Vecteur(this.fichier);
}
if(listeObjet.size() < 1) return null;
return listeObjet;
}
return null;
}catch(Exception ex){return null;}
}

321
/**
* la methode rechercherParId de la classe (retourne un objet qui
contien la chaine de caractaire)
*/
public Vecteur rechercherParId(String aRechercher){
try{
File file = new File(this.fichier);
if(file.exists()){
Vecteur obj = new Vecteur(this.fichier);
List listeElmt;
Iterator itr;//itr pointe sur les elts de la list
Element parcourirElmt= new Element("aa");
List xmlListe= new ArrayList();
XML xml= new XML(this.fichier);
Element parcourir= new Element("aa");
if(xml.search("Vecteurs","Vecteur", "id", aRechercher)!=null){
parcourir = xml.search("Vecteurs","Vecteur", "id",
aRechercher);
//recuperation de l'attribut id
obj.setId(parcourir.getAttributeValue("id"));
//recuperation de l'attribut modelMath

obj.setModelMath(parcourir.getAttributeValue("modelMath"));
//recuperation de l'element ve
obj.setVe(parcourir.getChildText("ve"));
//recuperation de l'element vs
obj.setVs(parcourir.getChildText("vs"));
return obj;
}
return null;
}
return null;
}catch(Exception ex){return null;}
}

/**
* la methode rechercherParMotCle de la classe (retourne un objet qui
contien la chaine de caractaire)
*/
public List rechercherParMotCle(String motCle, String aRechercher){
try{
File file = new File(this.fichier);
if(file.exists()){
Vecteur obj = new Vecteur(this.fichier);
List listeElmt;
List listeObjet=new ArrayList();
Iterator itr;//itr pointe sur les elts de la list
Element parcourirElmt= new Element("aa");
List xmlListe= new ArrayList();
XML xml= new XML(this.fichier);
List liste = xml.racine.getChildren();
Iterator it = liste.iterator();//i pointe sur les elts de la
list
Element parcourir= new Element("aa");
boolean ok = false;
while (it.hasNext()){
parcourir = (Element)it.next();
if(motCle.equals("ve")){
if(aRechercher.equals(parcourir.getChildText("ve"))){
ok = true;
}

322
}
if(motCle.equals("vs")){
if(aRechercher.equals(parcourir.getChildText("vs"))){
ok = true;
}
}
if(ok){
//recuperation de l'attribut id
obj.setId(parcourir.getAttributeValue("id"));
//recuperation de l'attribut modelMath

obj.setModelMath(parcourir.getAttributeValue("modelMath"));
//recuperation de l'element ve
obj.setVe(parcourir.getChildText("ve"));
//recuperation de l'element vs
obj.setVs(parcourir.getChildText("vs"));
listeObjet.add(obj);
obj=new Vecteur(this.fichier);
ok = false;
}
}
return listeObjet;
}
return null;
}catch(Exception ex){return null;}
}
}

/* Classe EquaEtat.java */

package BondGraph;

import java.util.*;
import java.util.Iterator;
import java.util.List;
import java.sql.Date;
import java.lang.Double;
import org.jdom.Element;
import XML_Package.*;
import java.io.*;

public class EquaEtat{

String id;
String modelMath;

private String str = "";


private String fichier = "";
private Element elt = new Element("aa");
/**
* le constructeur par défaut de la classe
*/
public EquaEtat(){
id = "";
modelMath = "";
}
/**
* le constructeur de la classe
*/
public EquaEtat(String fichier){

323
this.fichier = fichier;
id = "";
modelMath = "";
}
/**
* le constructeur de la classe
*/
public EquaEtat(String fichier, String id, String modelMath){
this.id = id;
this.modelMath = modelMath;
this.fichier = fichier;
}
/**
* la methode set de la variable fichier
*/
public void setFichier(String fichier){
this.fichier = fichier;
}
/**
* la methode set de la variable id
*/
public void setId(String id){
this.id = id;
}
/**
* la methode set de la variable modelMath
*/
public void setModelMath(String modelMath){
this.modelMath = modelMath;
}
/**
* la methode get de la variable fichier
*/
public String getFichier(){
return this.fichier;
}
/**
* la methode get de la variable id
*/
public String getId(){
return id;
}
/**
* la methode get de la variable modelMath
*/
public String getModelMath(){
return modelMath;
}
/**
* la methode idMax de la classe
*/
public int idMax() throws Exception{
try{
XML xml= new XML();
return xml.chercher_idmax(this.fichier);
}catch(Exception ex){return 0;}
}

/**
* la methode ajouter de la classe
*/

324
public boolean ajouter() throws Exception{
try{
XML xml= new XML();
File file = new File(this.fichier);
if(!file.exists()) xml.creerXML(this.fichier, "EquaEtats");
xml= new XML(this.fichier);
xml.courant = xml.addNoeud(xml.racine, "EquaEtat", "");
//ajouter l'attribut id
xml.add_Attribut(xml.courant,"id", this.id+"");
//ajouter l'attribut modelMath
xml.add_Attribut(xml.courant,"modelMath", this.modelMath+"");
xml.save(this.fichier);
return true;
}catch(Exception ex){return false;}

/**
* la methode supprimer de la classe
*/
public boolean supprimer() throws Exception{
File file = new File(this.fichier);
try{
if(file.exists()){
XML xml= new XML(this.fichier);
if(xml.search("EquaEtats","EquaEtat", "id", this.id+"")!=null){
xml.courant = xml.search("EquaEtats","EquaEtat", "id",
this.id+"");
xml.racine.removeContent(xml.courant);
xml.racine.removeChild(""+xml.courant);
xml.save(this.fichier);
return true;
}
return false;
}
return false;
}catch(Exception ex){return false;}

/**
* la methode modifier de la classe
*/
public boolean modifier() throws Exception{
try{
File file = new File(this.fichier);
if(file.exists()){
XML xml= new XML(this.fichier);
if(xml.search("EquaEtats","EquaEtat", "id", this.id+"")!=null){
xml.courant = xml.search("EquaEtats","EquaEtat", "id",
this.id+"");
//modification de l'attribut id
xml.courant.getAttribute("id").setValue(this.id+"");
//modification de l'attribut modelMath

xml.courant.getAttribute("modelMath").setValue(this.modelMath+"");
xml.save(this.fichier);
return true;
}
return false;
}

325
return false;
}catch(Exception ex){return false;}

/**
* la methode lister de la classe (retourne une liste des objets du
fichier XML)
*/
public List lister(){
try{
File file = new File(this.fichier);
if(file.exists()){
EquaEtat obj = new EquaEtat(this.fichier);
List listeElmt=new ArrayList();
List listeObjet=new ArrayList();
Iterator itr;//itr pointe sur les elts de la list
Element parcourirElmt= new Element("aa");
List xmlListe= new ArrayList();

XML xml= new XML(this.fichier);


List liste = xml.racine.getChildren();
Iterator it = liste.iterator();//i pointe sur les elts de la
list
Element parcourir= new Element("aa");
while (it.hasNext()){
parcourir = (Element)it.next();
//recuperation de l'attribut id
obj.setId(parcourir.getAttributeValue("id"));
//recuperation de l'attribut modelMath

obj.setModelMath(parcourir.getAttributeValue("modelMath"));
listeObjet.add(obj);
obj=new EquaEtat(this.fichier);
}
if(listeObjet.size() < 1) return null;
return listeObjet;
}
return null;
}catch(Exception ex){return null;}

/**
* la methode rechercherParId de la classe (retourne un objet qui
contien la chaine de caractaire)
*/
public EquaEtat rechercherParId(String aRechercher){
try{
File file = new File(this.fichier);
if(file.exists()){
EquaEtat obj = new EquaEtat(this.fichier);
List listeElmt;
Iterator itr;//itr pointe sur les elts de la list
Element parcourirElmt= new Element("aa");
List xmlListe= new ArrayList();

XML xml= new XML(this.fichier);


Element parcourir= new Element("aa");
if(xml.search("EquaEtats","EquaEtat", "id",
aRechercher)!=null){

326
parcourir = xml.search("EquaEtats","EquaEtat", "id",
aRechercher);
//recuperation de l'attribut id
obj.setId(parcourir.getAttributeValue("id"));
//recuperation de l'attribut modelMath

obj.setModelMath(parcourir.getAttributeValue("modelMath"));
return obj;
}
return null;
}
return null;
}catch(Exception ex){return null;}

/**
* la methode rechercherParMotCle de la classe (retourne un objet qui
contien la chaine de caractaire)
*/
public List rechercherParMotCle(String motCle, String aRechercher){
try{
File file = new File(this.fichier);
if(file.exists()){
EquaEtat obj = new EquaEtat(this.fichier);
List listeElmt;
List listeObjet=new ArrayList();
Iterator itr;//itr pointe sur les elts de la list
Element parcourirElmt= new Element("aa");
List xmlListe= new ArrayList();

XML xml= new XML(this.fichier);


List liste = xml.racine.getChildren();
Iterator it = liste.iterator();//i pointe sur les elts de la
list
Element parcourir= new Element("aa");
boolean ok = false;
while (it.hasNext()){
parcourir = (Element)it.next();
if(ok){
//recuperation de l'attribut id
obj.setId(parcourir.getAttributeValue("id"));
//recuperation de l'attribut modelMath

obj.setModelMath(parcourir.getAttributeValue("modelMath"));
listeObjet.add(obj);
obj=new EquaEtat(this.fichier);
ok = false;
}
}
return listeObjet;
}
return null;
}catch(Exception ex){return null;}

}
}

/* Classe MTF.java */

package BondGraph;

327
import java.util.*;
import java.util.Iterator;
import java.util.List;
import java.sql.Date;
import java.lang.Double;
import org.jdom.Element;
import XML_Package.*;
import java.io.*;
package BondGraph;

public class MTF{

String id;
String modelMath;
private String str = "";
private String fichier = "";
private Element elt = new Element("aa");
/**
* le constructeur par défaut de la classe
*/
public MTF(){
id = "";
modelMath = "";
}
/**
* le constructeur de la classe
*/
public MTF(String fichier){
this.fichier = fichier;
id = ""; //
modelMath = ""; //
}
/**
* le constructeur de la classe
*/
public MTF(String fichier, String id, String modelMath){
this.id = id;
this.modelMath = modelMath;
this.fichier = fichier;
}
/**
* la methode set de la variable fichier
*/
public void setFichier(String fichier){
this.fichier = fichier;
}
/**
* la methode set de la variable id
*/
public void setId(String id){
this.id = id;
}

/**
* la methode set de la variable modelMath
*/
public void setModelMath(String modelMath){
this.modelMath = modelMath;
}

328
/**
* la methode get de la variable fichier
*/
public String getFichier(){
return this.fichier;
}

/**
* la methode get de la variable id
*/
public String getId(){
return id;
}

/**
* la methode get de la variable modelMath
*/
public String getModelMath(){
return modelMath;
}

/**
* la methode idMax de la classe
*/
public int idMax() throws Exception{
try{
XML xml= new XML();
return xml.chercher_idmax(this.fichier);
}catch(Exception ex){return 0;}
}

/**
* la methode ajouter de la classe
*/

public boolean ajouter() throws Exception{


try{
XML xml= new XML();
File file = new File(this.fichier);
if(!file.exists()) xml.creerXML(this.fichier, "MTFs");
xml= new XML(this.fichier);
xml.courant = xml.addNoeud(xml.racine, "MTF", "");
//ajouter l'attribut id
xml.add_Attribut(xml.courant,"id", this.id+"");
//ajouter l'attribut modelMath
xml.add_Attribut(xml.courant,"modelMath", this.modelMath+"");
xml.save(this.fichier);
return true;
}catch(Exception ex){return false;}
}

/**
* la methode supprimer de la classe
*/

public boolean supprimer() throws Exception{


File file = new File(this.fichier);
try{
if(file.exists()){
XML xml= new XML(this.fichier);
if(xml.search("MTFs","MTF", "id", this.id+"")!=null){

329
xml.courant = xml.search("MTFs","MTF", "id", this.id+"");
xml.racine.removeContent(xml.courant);
xml.racine.removeChild(""+xml.courant);
xml.save(this.fichier);
return true;
}
return false;
}
return false;
}catch(Exception ex){return false;}
}

/**
* la methode modifier de la classe
*/

public boolean modifier() throws Exception{


try{
File file = new File(this.fichier);
if(file.exists()){
XML xml= new XML(this.fichier);
if(xml.search("MTFs","MTF", "id", this.id+"")!=null){
xml.courant = xml.search("MTFs","MTF", "id", this.id+"");
//modification de l'attribut id
xml.courant.getAttribute("id").setValue(this.id+"");
//modification de l'attribut modelMath

xml.courant.getAttribute("modelMath").setValue(this.modelMath+"");
xml.save(this.fichier);
return true;
}
return false;
}
return false;
}catch(Exception ex){return false;}
}

/**
* la methode lister de la classe (retourne une liste des objets du
fichier XML)
*/

public List lister(){


try{
File file = new File(this.fichier);
if(file.exists()){
MTF obj = new MTF(this.fichier);
List listeElmt=new ArrayList();
List listeObjet=new ArrayList();
Iterator itr;//itr pointe sur les elts de la list
Element parcourirElmt= new Element("aa");
List xmlListe= new ArrayList();
XML xml= new XML(this.fichier);
List liste = xml.racine.getChildren();
Iterator it = liste.iterator();//i pointe sur les elts de la
list
Element parcourir= new Element("aa");
while (it.hasNext()){
parcourir = (Element)it.next();
//recuperation de l'attribut id
obj.setId(parcourir.getAttributeValue("id"));

330
//recuperation de l'attribut modelMath

obj.setModelMath(parcourir.getAttributeValue("modelMath"));
listeObjet.add(obj);
obj=new MTF(this.fichier);
}
if(listeObjet.size() < 1) return null;
return listeObjet;
}
return null;
}catch(Exception ex){return null;}
}

/**
* la methode rechercherParId de la classe (retourne un objet qui
contien la chaine de caractaire)
*/

public MTF rechercherParId(String aRechercher){


try{
File file = new File(this.fichier);
if(file.exists()){
MTF obj = new MTF(this.fichier);
List listeElmt;
Iterator itr;//itr pointe sur les elts de la list
Element parcourirElmt= new Element("aa");
List xmlListe= new ArrayList();
XML xml= new XML(this.fichier);
Element parcourir= new Element("aa");
if(xml.search("MTFs","MTF", "id", aRechercher)!=null){
parcourir = xml.search("MTFs","MTF", "id", aRechercher);
//recuperation de l'attribut id
obj.setId(parcourir.getAttributeValue("id"));
//recuperation de l'attribut modelMath

obj.setModelMath(parcourir.getAttributeValue("modelMath"));
return obj;
}
return null;
}
return null;
}catch(Exception ex){return null;}
}

/**
* la methode rechercherParMotCle de la classe (retourne un objet qui
contien la chaine de caractaire)
*/

public List rechercherParMotCle(String motCle, String aRechercher){


try{
File file = new File(this.fichier);
if(file.exists()){
MTF obj = new MTF(this.fichier);
List listeElmt;
List listeObjet=new ArrayList();
Iterator itr;//itr pointe sur les elts de la list
Element parcourirElmt= new Element("aa");
List xmlListe= new ArrayList();
XML xml= new XML(this.fichier);
List liste = xml.racine.getChildren();

331
Iterator it = liste.iterator();//i pointe sur les elts de la
list
Element parcourir= new Element("aa");
boolean ok = false;
while (it.hasNext()){
parcourir = (Element)it.next();
if(ok){
//recuperation de l'attribut id
obj.setId(parcourir.getAttributeValue("id"));

//recuperation de l'attribut modelMath

obj.setModelMath(parcourir.getAttributeValue("modelMath"));
listeObjet.add(obj);
obj=new MTF(this.fichier);
ok = false;
}
}
return listeObjet;
}
return null;
}catch(Exception ex){return null;}

}
}

332