Algorithme utilisé pour les différentes procédures


FONCTION Hauteur_normale(debit : réel, diametre : indéfini, pente : indéfini, K : réel) : réel

Déclaration des variables
theta_normale : réel        'Angle correspondant a la hauteur normale
epsilon : réel                  'Erreur commise dans le calcul de theta

Initialisation
theta_normale = 0.01
epsilon = 0.2

Calcul de l'angle normal par itération
Faire Tant que epsilon > 0.1

Fin de la boucle

Hauteur_normale = (diametre / 2000) * (1 - Cos(theta_normale / 2))

Fin de la fonction


FONCTION Hauteur_critique(debit : réel, diametre : indéfini) : réel

Déclaration des variables
theta_critique : réel        'Angle correspondant a la hauteur critique
epsilon : réel                 'Precision sur la hauteur critique calculee

Initialisation
theta_critique = 0
epsilon = 0.2

Calcul de l'angle critique par itération
Faire Tant que epsilon > 0.1

Fin de la boucle

Formule de la hauteur critique en FONCTION de theta
Hauteur_critique = (diametre / 2000) * (1 - Cos(theta_critique / 2))

Fin de la fonction


Fonction précisant pour un point donné connaissant sa hauteur d'eau la classe de l'écoulement (en fait signe de dh/dx)

FONCTION classe_ecoulement(troncon As linktype, hauteur_d_eau : indéfini) : réel

Déclaration des variables
h_nor, h_cri, h : réel

Calcul de la hauteur normale
h_nor = Hauteur_normale(troncon.Design_flow, troncon.Design_Diameter, troncon.slope, troncon.K)

Calcul de la hauteur critique
h_cri = Hauteur_critique(troncon.Design_flow, troncon.Design_Diameter) h = hauteur_d_eau

On identifie la classe de l'écoulement, ce qui nous donne le signe de dh/dx
(Voir cours de M Suzanne tome 2, p51)
Si (h_nor > h_cri) Alors

Sinon

Fin de la boucle

Fin de la fonction


FONCTION lambda(strickler : réel, diametre : indéfini)

Détermination simple de lambda

lambda = 8 * g * 4 ^ (1 / 3) / (strickler ^ 2) / (diametre / 1000) ^ (1 / 3)

Fin de la fonction


FONCTION prix(diam : indéfini)

Donne le prix du mètre linéaire de conduite

Si (diam = 300) Alors
     prix = cal.val(5)
End Si

Si (diam = 400) Alors
     prix = cal.val(6)
End Si

Si (diam = 500) Alors
     prix = cal.val(7)
End Si

Si (diam = 600) Alors
     prix = cal.val(8)
End Si

Si (diam = 800) Alors
     prix = cal.val(9)
End Si

Si (diam = 1000) Alors
     prix = cal.val(10)
End Si

Si (diam = 1200) Alors
     prix = cal.val(11)
End Si

Si (diam = 1500) Alors
     prix = cal.val(12)
End Si

Si (diam = 1800) Alors
     prix = cal.val(13)
End Si

Si (diam = 2000) Alors
     prix = cal.val(14)
End Si

Fin de la fonction


FONCTION lambda_colebrook(collecteur As linktype)

Donne Lambda en fonction de la formule de Colebrook White

Déclaration des variables
epsilon : réel

Utilisation de la formule de Colebrook

epsilon = 0.2
lambda_colebrook = 0.1
FaireTant que epsilon > 0.1

Fin de la boucle

Fin de la fonction


FONCTION Energie_specifique(debit : réel, diametre : indéfini, hauteur_d_eau : indéfini)

Déclaration des variables
theta : réel         'angle correspondant à la hauteur d'eau

theta = 2 * Arccos(1 - (hauteur_d_eau / (diametre / 2000)))
Energie_specifique = hauteur_d_eau + 2 * (debit ^ 2) / g / ((diametre / 2000) ^ 4) / (theta - Sin(theta)) ^ 2

Fin de la fonction


FONCTION Perte_d_energie(debit : réel, diametre : indéfini, K : réel, hauteur_d_eau : indéfini)

Déclaration des variables
theta As Single          'angle correspondant à la hauteur d'eau

theta = 2 * Arccos(1 - hauteur_d_eau / (diametre / 2000)) Perte_d_energie = 2 ^ (10 / 3) * (debit ^ 2) / (K ^ 2 * ((diametre / 2000) ^ (16 / 3)) * ((1 - (Sin(theta)) / theta) ^ (4 / 3)) * ((theta - Sin(theta)) ^ 2))

Fin de la fonction


Procédure abscisse_amont(troncon As linktype, hauteur_aval : indéfini, abscisse_aval : indéfini, absi : indéfini, h_amont : indéfini, delta_h : réel)
fonction calculant en écoulement à surface libre

Déclaration des variables
pde_moyenne : réel       Perte d'energie moyenne
pdc_singuliere : réel

h_amont = hauteur_aval + classe_ecoulement(troncon, hauteur_aval) * delta_h

pde_moyenne = 0.5 * (Perte_d_energie(troncon.Design_flow, troncon.Design_Diameter, troncon.K, hauteur_aval) + Perte_d_energie(troncon.Design_flow, troncon.Design_Diameter, troncon.K, h_amont))

absi = abscisse_aval + (Energie_specifique(troncon.Design_flow, troncon.Design_Diameter, h_amont)

Energie_specifique(troncon.Design_flow, troncon.Design_Diameter, hauteur_aval)) / (troncon.slope - pde_moyenne)

pdc_singuliere = Int((absi - abscisse_aval) * troncon.n_regard / troncon.Length) * pdc(troncon.Design_flow, troncon.Design_Diameter, h_amont, cal.val(1))

absi = abscisse_aval + (Energie_specifique(troncon.Design_flow, troncon.Design_Diameter, h_amont) + pdc_singuliere - Energie_specifique(troncon.Design_flow, troncon.Design_Diameter, hauteur_aval)) / (troncon.slope - pde_moyenne)

Fin de la procédure


FONCTION charge_amont(troncon As linktype, charge_aval : indéfini, n_sauvegarde : réel)

fonction calculant en écoulement en charge la hauteurs d'eau et la charge en un point situé à l'amont.

Déclaration des variables

pdc_lineaire : réel
pdc_singuliere : réel

pdc_lineaire = lambda(troncon.K, troncon.Design_Diameter) * (troncon.Design_flow ^ 2) / 2 / g / (PI * ((troncon.Design_Diameter / 1000) ^ 2) / 4) * troncon.Length / (n_sauvegarde - 1)

pdc_singuliere = troncon.n_regard / (n_sauvegarde - 1) * cal.val(2) * (troncon.Design_flow ^ 2) / 2 / g / (PI * ((troncon.Design_Diameter / 1000) ^ 2) / 4)

charge_amont = charge_aval + pdc_lineaire + pdc_singuliere

Fin de la fonction


Procédure lignes_troncon(troncon As linktype, hauteur_av : indéfini, delta_h : réel)

Calcule pour un tronçon uniquement

Déclaration des variables

hauteur_controle : réel
hauteur_d_eau(1 To 1000) : indéfini
charge(1 To 1000) : indéfini
abscisse_troncon(1 To 1000) : indéfini
i, ka, fin, q, arret : entier
h_nor, absc_controle, perte_charge As Variant
longueur : réel

Il faut initialiser les tableaux
Pour ka variant de 1 à 1000
        hauteur_d_eau(ka) = troncon.Design_Diameter
        abscisse_troncon(ka) = 0
        charge(ka) = 0

Fin de la boucle

Remplissage premiere valeur

       hauteur_d_eau(1) = hauteur_av
       hauteur_controle = hauteur_av
       charge(1) = Energie_specifique(troncon.Design_flow, troncon.Design_Diameter, hauteur_av) + troncon.Downstream_level        abscisse_troncon(1) = 0
       absc_controle = 0
       i = 1
      arret = 500

Début du calcul

Pour q variant de 1 à arret
      Si (0.95 * troncon.Design_Diameter < hauteur_controle)  Alors
              Contrôle du passage en charge
              charge(i + 1) = charge_amont(troncon, charge(i), n_sauvegarde)
              hauteur_controle = charge(i + 1) - troncon.Downstream_level - (troncon.Design_flow ^ 2) / 2 / g / (PI *               ((troncon.Design_Diameter / 1000) ^ 2) / 4)
              abscisse_troncon(i + 1) = abscisse_troncon(i) + troncon.Length / (n_sauvegarde - 1)
              troncon.statut = "Ecoulement en charge"
      Sinon
             En surface libre
             h_nor = Hauteur_normale(troncon.Design_flow, troncon.Design_Diameter, troncon.slope, troncon.K)
             Si (Abs(hauteur_d_eau(i) - h_nor) > delta_h) Alors
                     Contrôle la distance par rapport la hauteur normale
                     Call abscisse_amont(troncon, hauteur_d_eau(i), abscisse_troncon(i), abscisse_troncon(i + 1), hauteur_d_eau(i + 1),                      delta_h)    
                     hauteur_controle = hauteur_d_eau(i + 1)
                     charge(i + 1) = Energie_specifique(troncon.Design_flow, troncon.Design_Diameter, hauteur_d_eau(i + 1)) +                      abscisse_troncon(i + 1) * troncon.slope + troncon.Downstream_level
             End Si
             Si (Abs(hauteur_d_eau(i) - h_nor) < delta_h) Alors
                      hauteur_d_eau(i + 1) = h_nor
                      abscisse_troncon(i + 1) = abscisse_troncon(i) + troncon.Length / (n_sauvegarde - 1)
                      perte_charge = (troncon.Length - abscisse_troncon(i)) * troncon.n_regard / troncon.Length * pdc(troncon.Design_flow,                       troncon.Design_Diameter, h_nor, cal.val(1))
                      charge(i + 1) = Energie_specifique(troncon.Design_flow, troncon.Design_Diameter, hauteur_d_eau(i + 1)) +                       troncon.Downstream_level + abscisse_troncon(i + 1) * troncon.slope
                      troncon.statut = "hauteur d'eau passe par la hauteur normale"
             End Si   
      End Si
      absc_controle = abscisse_troncon(i + 1) i = i + 1
      longueur = troncon.Length
      Si ((absc_controle > longueur) Or (absc_controle = longueur)) Alors
            Contrôle fin de tronçon
            q = arret + 1
      Sinon 
            q = q + 1
      End Si
      fin = i
Fin de la boucle

Maintenant il faut sauvegarder les valeurs

troncon.charge(1) = charge(1)
troncon.hauteur_eau(1) = hauteur_d_eau(1)
troncon.vitesse(1) = vitesse(troncon.Design_flow, troncon.Design_Diameter, troncon.hauteur_eau(1))

Contrôle des vitesses
Si (troncon.vitesse(1) > general.Vmax) Alors
      troncon.statut = "trop fortes vitesses"
Fin de la boucle

For ka = 1 To (n_sauvegarde - 2)
      i = 2
      Boucle qui permet de déterminer le numéro du segment de sauvegarde par rapport au point calculé
      Tant que (ka * (troncon.Length / (n_sauvegarde - 1)) > abscisse_troncon(i))
             i = i + 1
      Wend
      troncon.charge(ka + 1) = charge(i - 1)
      troncon.hauteur_eau(ka + 1) = hauteur_d_eau(i - 1)
      troncon.vitesse(ka + 1) = vitesse(troncon.Design_flow, troncon.Design_Diameter, troncon.hauteur_eau(ka + 1))
      Contrôle des vitesses
      Si (troncon.vitesse(ka + 1) > general.Vmax) Alors
            troncon.statut = "trop fortes vitesses"
      End Si
Fin de la boucle

troncon.charge(n_sauvegarde) = charge(fin)
troncon.hauteur_eau(n_sauvegarde) = hauteur_d_eau(fin)
troncon.vitesse(n_sauvegarde) = vitesse(troncon.Design_flow, troncon.Design_Diameter, troncon.hauteur_eau(n_sauvegarde))

Contrôle des vitesses
Si (troncon.vitesse(n_sauvegarde) > general.Vmax) Alors
     troncon.statut = "trop fortes vitesses"
Fin de la boucle

Call cout_collecteur(troncon, type_sol)

Fin de la procédure


Procédure initialise()


cal.n = 19

Coefficient Perte de charge dans le regard à surface libre
cal.val(1) = 0.5
Coefficient Perte de charge dans le regard en charge
cal.val(2) = 1.5
Coefficient Perte de charge au niveau d'une jonction
cal.val(3) = 1.5
Rugosité
cal.val(4) = 0.005
Coût d'un tuyau de diamètre 300mm (F/m)
cal.val(5) = 100
Coût d'un tuyau de diamètre 400mm (F/m)
cal.val(6) = 100
Coût d'un tuyau de diamètre 500mm (F/m)
cal.val(7) = 100
Coût d'un tuyau de diamètre 600mm (F/m)
cal.val(8) = 100
Coût d'un tuyau de diamètre 800mm (F/m)
cal.val(9) = 100
Coût d'un tuyau de diamètre 1000mm (F/m)
cal.val(10) = 100
Coût d'un tuyau de diamètre 1200mm (F/m)
cal.val(11) = 100
Coût d'un tuyau de diamètre 1500mm (F/m)
cal.val(12) = 100
Coût d'un tuyau de diamètre 1800mm (F/m)
cal.val(13) = 100
Coût d'un tuyau de diamètre 2000mm (F/m)
cal.val(14) = 100
Coût d'une tranchée pour sol 1 (F/m3)"
cal.val(15) = 100
Coût d'une tranchée pour sol 2 (F/m3)"
cal.val(16) = 100
Coût d'une tranchée pour sol 3 (F/m3)"
cal.val(17) = 100
Condition de débordement (par rapport au sol) (m)"
cal.val(18) = 0
Distance moyenne séparant deux regards
cal.val(19) = 70

cal_ref = cal

Fin de la procédure


Procédure lien_simple(troncon_am As linktype, troncon_av As linktype)

Déclaration des variables
hauteur_av, diametre : réel
charge_av : indéfini
hauteur_am : réel
charge_am : réel

Initialisation
hauteur_av = troncon_av.hauteur_eau(n_sauvegarde)
charge_av = troncon_av.charge(n_sauvegarde)
diametre = troncon_av.Design_Diameter

Contrôle charge/surface libre
Si (0.95 * diametre < hauteur_av) Alors
        charge_am = charge_av + cal.val(1) * (troncon_av.Design_flow ^ 2) / 2 / g / (PI * ((troncon_av.Design_Diameter / 1000) ^ 2) / 4)         Attention perte de charge au convergent uniquement
        hauteur_am = charge_am
        Si (0.95 * diametre < hauteur_am) Alors
                 hauteur_am = troncon_am.Design_Diameter
        End Si
Sinon
        hauteur_am = Hauteur_critique(troncon_am.Design_flow, troncon_am.Design_Diameter)
        charge_am = hauteur_am + pdc(troncon_am.Design_flow, troncon_am.Design_Diameter, hauteur_am, 1) +         troncon_am.Downstream_level
Fin de la boucle

troncon_am.hauteur_eau(1) = hauteur_am troncon_am.charge(1) = charge_am

Fin de la procédure


FONCTION pdc(debit : réel, diametre : indéfini, hauteur_d_eau : indéfini, coeff : réel)

Déclaration des variables
theta : réel   Angle correspondant à la hauteur d'eau

theta = 2 * Arccos(1 - hauteur_d_eau / (diametre / 2000)) pdc = coeff * 2 * (debit ^ 2) / g / ((diametre / 2000) ^ 4) / (theta - Sin(theta)) ^ 2

Fin de la fonction


Sub cout_collecteur(troncon As linktype, type_sol : entier)
Donne le cout d'un seul collecteur

Déclaration des variables
Dim volume : réel

volume = ((node(nom_noeud(troncon, 1)).TN - troncon.Downstream_level) + (node(nom_noeud(troncon, 2)).TN - troncon.Upstream_level)) / 2 * troncon.Length * (2 * troncon.Design_Diameter)

troncon.cout = prix(troncon.Design_Diameter) * troncon.Length + volume * prix_sol(type_sol)

Fin de la procédure


Fonction prix_sol(type_sol : entier)

Si (type_sol = 1) Alors
       prix_sol = cal.val(15)
End Si

Si (type_sol = 2) Alors
       prix_sol = cal.val(16)
End Si

Si (type_sol = 3) Alors
      prix_sol = cal.val(17)
End Si

Fin de la fonction


Procédure Sub calcul()
Subroutine de calcul

Déclaration des variables
diametre, radier_am, radier_av, longueur, pente : réel
i, j, ka, l, q, controle : entier
list() : entier
premier, nb_amont, indice, ordre_max, precedent, cons : entier
message1, message2 : Indéfini
ReDim list(1 To (NbNode - 1)) : entier controle = 0

Contrôle des pentes
For i = 1 To NbNode - 1
        Si link(i).slope > pente_critique(link(i).Design_flow, link(i).Design_Diameter, link(i).K) Alors
              MsgBox "Attention écoulement torrentiel"
              message1 = node(i).Name
              message2 = node(nom_noeud(link(i), 1)).Name
             MsgBox "modifier le troncon de" + message1 + "à" + message2 controle = 1
       End Si
Fin de la boucle

Recherche premier tronçon (exutoire)
Si (controle = 0) Alors
        For i = 1 To NbNode
              Si (node(i).NetWork_Position = 3) Alors
                       Indice du noeud exutoire
                       premier = i
              End Si
        Next
        Indice du noeud amont de l'exutoire soit du premier troncon
        premier = node(premier).Up_Node(1)
        i = 1
        Do Tant que (i < (NbNode - 1))
               Si (nom_noeud(link(i), 1) = premier) Alors
                          cons = i
               Sinon
                           i = i + 1
               End Si
        precedent = cons
Fin de la boucle

On donne l'ordre 1 au premier troncon
link(premier).ordre = 1

Initialisons:
For i = 1 To NbNode - 1
          list(i) = 0
Fin de la boucle

nb_amont = 1
list(1) = premier
j = 1
ordre_max = NbNode - 1

Mise en ordre des troncons

For j = 2 To ordre_max
         Si (nb_amont <> 0) Alors
                  For l = 1 To nb_amont
                            fonction inverse ordre: à un ordre donne les tronçons correspondant
                            q = 0
                            For i = 1 To NbNode - 1
                                      list(i) = 0
                            Next
                            ka = 1
                            i = 1
                            Faire Tant que i < NbNode
                                    Si (link(i).ordre = j - 1) Alors
                                              list(ka) = i
                                              ka = ka + 1
                                              i = i + 1
                                    Sinon
                                             i = i + 1
                                    End Si
                             Loop
'fin de cette FONCTION

indice = list(l)
i = 1
Faire Tant que (i < NbNode)
          Faire Tant que (nom_noeud(link(i), 1) <> indice)
                   En effet indice= à l'indice du noueud amont de ce collecteur
                   i = i + 1
          Exit
          Faire Loop
                 q = q + 1
                 link(i).ordre = j
          Exit
          Faire Loop
                Next nb_amont = q
          Else
                ordre_max = j - 1
          End Si
Next

Vérification de non débordement
Call lignes_troncon(link(premier), hauteur_aval, 0.01)

For i = 1 To n_sauvegarde
          Si (link(premier).charge(i) > (i - 1) / (n_sauvegarde - 1) * (node(nom_noeud(link(premier), 2)).TN -           node(nom_noeud(link(premier), 1)).TN) + node(nom_noeud(link(premier), 1)).TN + val(18)) Alors
                     link(premier).statut = "débordement"
          End Si
Next

Boucle sur les ordres
For ka = 2 To ordre_max
         For i = 1 To NbNode - 1
                 list(i) = 0 Next i = 1 q = 0
                 Fonction inverse ordre: à un ordre donne les tronçons correspondants
                 Faire Tant que i < NbNode
                          Si (link(i).ordre = ka) Alors
                                  q = q + 1
                                  list(q) = i
                                  i = i + 1
                          Else
                                  i = i + 1
                          End Si
                  Loop
                  Fin de cette Fonction
                  Comptons le nombre de troncon pour cet ordre =q
                  i = 1
                  Faire Tant que i < NbNode
                         Faire Tant que list(i) <> 0
                              i = i + 1
                         Loop
                   Loop
          Fin
          on a i tronçons=q
          For j = 1 To q
                      indice = list(j)
                      precedent = nom_noeud(link(indice), 1) 'donne l'indice du troncon précedent (aval)link(indice)
                      MsgBox "calcul tourne7"
                      Si (node(precedent).NbUp = 1) Alors
                             Call lien_simple(link(indice), link(precedent))
                             Call lignes_troncon(link(indice), link(indice).hauteur_eau(1), 0.01) ' verification de non débordement
                             For l = 1 To n_sauvegarde
                                   Si (link(indice).charge(l) > (l - 1) / (n_sauvegarde - 1) * (node(nom_noeud(link(indice), 2)).TN -                                    node(nom_noeud(link(indice), 1)).TN) + node(nom_noeud(link(indice), 1)).TN + val(18)) Alors
                                             link(indice).statut = "débordement"
                                    End Si
                             Next
                      End Si
                      Si (node(precedent).NbUp <> 1) Alors
                             Call lien_jonction(link(indice), link(precedent))
                             Call lignes_troncon(link(indice), link(indice).hauteur_eau(1), 0.01) ' verification de non débordement
                              For l = 1 To n_sauvegarde
                                   Si (link(indice).charge(l) > (l - 1) / (n_sauvegarde - 1) * (node(nom_noeud(link(indice), 2)).TN -                                    node(nom_noeud(link(indice), 1)).TN) + node(nom_noeud(link(indice), 1)).TN + val(18)) Alors
                                            link(indice).statut = "débordement"            
                                    End Si
                              Next
                      End Si
              Next
       Next
Fin de la boucle

Fin de la procédure


Procédure Sub lien_jonction(troncon_am As linktype, troncon_av As linktype)

Déclaration des variables
hauteur_av : indéfini
charge_av : indefini
hauteur_am : indéfini
charge_am : réel

Initialisation
hauteur_av = troncon_av.hauteur_eau(n_sauvegarde)
charge_av = troncon_av.charge(n_sauvegarde)

Contrôle charge/surface libre
Si (0.95 * troncon_av.Design_Diameter < hauteur_av) Alors
        charge_am = charge_av + (cal.val(1) + cal.val(3)) * (troncon_av.Design_flow ^ 2) / 2 / g / (PI * ((troncon_av.Design_Diameter /         1000) ^ 2) / 4)
        Attention perte de charge au convergent uniquement
        hauteur_am = charge_am
        Si (0.95 * troncon_am.Design_Diameter < hauteur_am) Alors
              hauteur_am = troncon_am.Design_Diameter
        End Si
Sinon
        hauteur_am = Hauteur_critique(troncon_am.Design_flow, troncon_am.Design_Diameter)
        charge_am = hauteur_am + pdc(troncon_am.Design_flow, troncon_am.Design_Diameter, hauteur_am, 1) +         troncon_am.Downstream_level
Fin de la boucle

troncon_am.hauteur_eau(1) = hauteur_am
troncon_am.charge(1) = charge_am

Fin de la procédure


Fonction Arccos#(X#)

Si Abs(X#) > 1 Alors
       "Erreur"       
       MsgBox matherror, 48,

Si X# = -1 Alors
       Arccos# = PI

Si X# = 1 Alors
      Arccos# = 2 * PI

Si Abs(X#) < 1 Alors
      Arccos# = Atn(-X# / Sqr(-X# * X# + 1)) + 2 * Atn(1)

Fin de la fonction


Fonction nom_noeud(troncon As linktype, var : entier)
Var precise si on s occupe du noeud amont ou aval

Déclaration des variables
i: entier
nom : liste de 10 réels

Si (var = 1) Alors
       'Noeud aval
       nom = troncon.NodeTo
Else
      'Noeud amont
        nom = troncon.NodeFrom
Fin de la boucle

i = 1

Faire Tant que (i < (NbNode + 1))
       Si (nom = node(i).Name) Alors
              nom_noeud = i i = i + 1
       Sinon
              i = i + 1
       End Si
Fin de la boucle

Fin de la fonction


Fonction pente_critique(debit : réel, diametre : indéfini, K : réel)

Déclaration des variables
theta_critique : réel  Angle correspondant à la hauteur critique
epsilon : réel     Precision sur la hauteur critique calculée

theta_critique = 0
epsilon = 0.2

Faire Tant que (epsilon > 0.1)
       theta_critique = theta_critique + 0.01
       Equation donnant la hauteur critique
       epsilon = 16 * debit ^ 2 * Sin(theta_critique / 2) - g * (diametre / 2000) ^ 6 * (theta_critique - Sin(theta_critique)) ^ 3
Loop

pente_critique = (2 ^ (10 / 3)) * (debit ^ 2) / (K ^ 2) / ((diametre / 2000) ^ (16 / 3)) / ((1 - (Sin(theta_critique)) / theta_critique) ^ (4 / 3)) / ((theta_critique - Sin(theta_critique)) ^ 2)

Fin de la fonction


FONCTION vitesse(debit : réel, diametre : indéfini, hauteur_d_eau : réel)

Déclaration des variables
theta : réel

Si (0.95 * diametre <= hauteur_d_eau) Alors
       contrôle passage en charge
       vitesse = debit / (PI / 4 * (diametre / 1000) ^ 2)
Fin de la boucle

Si (0.95 * diametre > hauteur_d_eau) Alors
       theta = 2 * Arccos(1 - hauteur_d_eau / (diametre / 2000))
       vitesse = debit / (((diametre / 2000) ^ 2) / 2 * (theta - Sin(theta)))
Fin de la boucle

Fin de la fonction


Procédure diametre_calcule(numero : entier)

Calcul du diamètre nécessaire
link(numero).Calc_Diameter = 2 * (2 ^ (3 / 4) / link(numero).K / PI / (link(numero).slope) ^ (1 / 2) * link(numero).Design_flow) ^ (4 / 11)

Calcul du collecteur nécessaire
link(numero).Design_Diameter = design(numero)

Fin de la procédure