Changeset 93248 in spip-zone


Ignore:
Timestamp:
Nov 27, 2015, 11:12:14 AM (4 years ago)
Author:
dorch@…
Message:

Corrections de bugs (voir http://sic.g-eau.net/mantis/changelog_page.php?version_id=139 pour les détails)

  • 0001204: [Courbe de remous] Erreur de saisie : le champ incriminé n'est pas spécifié
  • 0001203: [Courbe de remous] Saisie d'une pente nulle : 0 n'est pas accepter
  • 0001202: [Courbe de remous] La hauteur normale est à zéro quand la pente est nulle
  • 0001002: [Section] Message d'erreur en debug sur les déclaration des classes section
  • 0000987: [Courbe de remous] Erreur de calcul de la hauteur normale et critique
Location:
_plugins_/hydraulic/trunk
Files:
20 edited

Legend:

Unmodified
Added
Removed
  • _plugins_/hydraulic/trunk/formulaires/courbe_remous.html

    r68473 r93248  
    55//Permet d'afficher ou cacher les champs correspondant à une section.
    66function afficher_cacher() {
    7         var section = getSelectValue('choix_section_cr');
    8         // On récupère tous le formulaire
    9         var f = document.getElementById("form_courbe_remous");
     7    var section = getSelectValue('choix_section_cr');
     8    // On récupère tous le formulaire
     9    var f = document.getElementById("form_courbe_remous");
    1010    if(f) {
    11                 // On récupère seulement les lignes <tr> du formulaire stocké dans f
    12                 var champs = f.getElementsByTagName("tr");
    13                 // On parcourt tous les <tr> du formulaire
    14                 for(var i=0, n=champs.length; i<n; i++) {
    15                         // Si le champ appartient à la section choisis , alors on l'affiche.
    16                         if((champs[i].getAttribute("id") != null) &&((champs[i].getAttribute("id")).substr(0,2) == section)){
    17                                 document.getElementById((champs[i].getAttribute("id"))).style.display='table-row';
    18                         }
    19                         // Sinon si il appartient aux autres sections, alors on le masque
    20                         else if((champs[i].getAttribute("id") != null) &&((champs[i].getAttribute("id")).substr(0,1) == 'F')) {
    21                                 document.getElementById((champs[i].getAttribute("id"))).style.display='none';
    22                         }
     11        // On récupère seulement les lignes <tr> du formulaire stocké dans f
     12        var champs = f.getElementsByTagName("tr");
     13        // On parcourt tous les <tr> du formulaire
     14        for(var i=0, n=champs.length; i<n; i++) {
     15            // Si le champ appartient à la section choisis , alors on l'affiche.
     16            if((champs[i].getAttribute("id") != null) &&((champs[i].getAttribute("id")).substr(0,2) == section)){
     17                document.getElementById((champs[i].getAttribute("id"))).style.display='table-row';
     18            }
     19            // Sinon si il appartient aux autres sections, alors on le masque
     20            else if((champs[i].getAttribute("id") != null) &&((champs[i].getAttribute("id")).substr(0,1) == 'F')) {
     21                document.getElementById((champs[i].getAttribute("id"))).style.display='none';
     22            }
    2323
    24                 }
    25         }
     24        }
     25    }
    2626}
    2727</script>
    28 
     28<div class="formulaire_spip form_courbe_remous">
    2929<form method="post" action="#ENV{action}" id="form_courbe_remous">
    3030   #ACTION_FORMULAIRE{#ENV{action}}
     
    3535         </tr>
    3636
    37                         <tr id="type_section_choix_cr">
    38                                 <td align="right">
    39                                         <:hydraulic:choix_section:> :
    40                                 </td>                                   
     37            <tr id="type_section_choix_cr">
     38                <td align="right">
     39                    <:hydraulic:choix_section:>
     40                </td>
    4141
    42                                 <!-- On génére les options du select, correspondant aux types de section -->
    43                                 <td>
    44                                         <select name="crTypeSection" id="choix_section_cr" onChange="afficher_cacher();">
    45                                         <BOUCLE_selectOptions(POUR){tableau #ENV{mes_saisies}}>
    46                                                 #SET{test, #VALEUR|table_valeur{0}|decoupeIdSection}
    47                                                 <BOUCLE_choixSection(CONDITION){si #CLE|substr{0,1}|== {'F'}}>
    48                                                         <option value="#CLE" [(#ENV{crTypeSection}|=={#CLE}|?{'selected',''})]>#GET{test}</option>
    49                                                 </BOUCLE_choixSection>
    50                                         </BOUCLE_selectOptions>
    51                                         </select>
    52                  
    53                                         [<div class='hyd_erreur'>(#ENV**{erreurs}|table_valeur{[(#VALEUR|table_valeur{0})]})</div>]
    54                                 </td>
    55                                                
    56                         </tr>
     42                <!-- On génére les options du select, correspondant aux types de section -->
     43                <td>
     44                    <select name="crTypeSection" id="choix_section_cr" onChange="afficher_cacher();">
     45                    <BOUCLE_selectOptions(POUR){tableau #ENV{mes_saisies}}>
     46                        #SET{test, #VALEUR|table_valeur{0}|decoupeIdSection}
     47                        <BOUCLE_choixSection(CONDITION){si #CLE|substr{0,1}|== {'F'}}>
     48                            <option value="#CLE" [(#ENV{crTypeSection}|=={#CLE}|?{'selected',''})]>#GET{test}</option>
     49                        </BOUCLE_choixSection>
     50                    </BOUCLE_selectOptions>
     51                    </select>
     52
     53                    [<div class='hyd_erreur'>(#ENV**{erreurs}|table_valeur{[(#VALEUR|table_valeur{0})]})</div>]
     54                </td>
     55
     56            </tr>
    5757
    5858            <BOUCLE_fieldChamps(POUR){tableau #ENV{mes_saisies}}>
    5959
    60                                  #SET{id_fieldset, #CLE}
    61                                
    62                                 <!-- Fieldset des champs-->
    63                                  <tr id="#GET{id_fieldset}_field" style="display:[(#CLE|match{^([(#ENV{crTypeSection})]|Caract_bief|Cond_lim|Param_calc)$}|?{'table-row','none'})];">   
    64                                          <td colspan="2"><div class="hyd_formulaire_chapitre">[(#VALEUR|table_valeur{0}|traduction_hydraulic)]</div></td>
    65                                 </tr>
    66                                
    67                                 <BOUCLE_champsLib(POUR){tableau (#VALEUR|table_valeur{1})}>
    68                                        
    69                                         <!-- Tous les champs d'un seul fieldset -->                                     
    70                                         <tr id="#GET{id_fieldset}_[(#CLE)]" style="display:[(#GET{id_fieldset}|match{^([(#ENV{crTypeSection})]|Caract_bief|Cond_lim|Param_calc)$}|?{'table-row','none'})];">
    71                                                 <td align="right" width="65%">
    72                                                         [(#VALEUR|table_valeur{0}|traduction_hydraulic)] :     
    73                                                 </td>
    74                                                
    75                                                 <td width="35%">
    76                                                    <input type="text" value="[(#ENV{#GET{id_fieldset}_[(#CLE)]})]" maxlength="30" name="#GET{id_fieldset}_[(#CLE)]">
    77                                                    [<div class='hyd_erreur'>(#ENV**{erreurs}|table_valeur{#GET{id_fieldset}_[(#CLE)]_cr})</div>]
    78                                                 </td>
    79                                                
    80                                         </tr>
    81                                        
    82                                 </BOUCLE_champsLib>
     60                 #SET{id_fieldset, #CLE}
    8361
    84                         </BOUCLE_fieldChamps>
     62                <!-- Fieldset des champs-->
     63                 <tr id="#GET{id_fieldset}_field" style="display:[(#CLE|match{^([(#ENV{crTypeSection})]|c_bief|Cond_lim|Param_calc)$}|?{'table-row','none'})];">
     64                     <td colspan="2"><div class="hyd_formulaire_chapitre">[(#VALEUR|table_valeur{0}|traduction_hydraulic)]</div></td>
     65                </tr>
     66
     67                <BOUCLE_champsLib(POUR){tableau (#VALEUR|table_valeur{1})}>
     68
     69                    <!-- Tous les champs d'un seul fieldset -->
     70                    <tr id="#GET{id_fieldset}_[(#CLE)]" style="display:[(#GET{id_fieldset}|match{^([(#ENV{crTypeSection})]|c_bief|Cond_lim|Param_calc)$}|?{'table-row','none'})];" [(#ENV**{erreurs}|table_valeur{#GET{id_fieldset}_[(#CLE)]}|oui) class="hyd_erreur"]>
     71                        <td align="right" width="65%">
     72                            [(#VALEUR|table_valeur{0}|traduction_hydraulic)]
     73                        </td>
     74
     75                        <td width="35%" >
     76                           [<span class='hyd_erreur'>(#ENV**{erreurs}|table_valeur{#GET{id_fieldset}_[(#CLE)]})</span>]
     77                           <input type="text" value="[(#ENV{#GET{id_fieldset}_[(#CLE)]})]" maxlength="30" name="#GET{id_fieldset}_[(#CLE)]">
     78                        </td>
     79
     80                    </tr>
     81
     82                </BOUCLE_champsLib>
     83
     84            </BOUCLE_fieldChamps>
    8585
    8686         <tr>
     
    9393   </table>
    9494</form>
    95 
     95</div>
    9696[<div class='hydraulic_resultat'>(#ENV*{message_ok})</div>]
  • _plugins_/hydraulic/trunk/formulaires/courbe_remous.php

    r68484 r93248  
    3434    $fieldset_champs = caract_communes();
    3535
    36     $fieldset_champs['Caract_bief'] = array(
    37                                            'caract_bief',
    38                                            array(
    39                                                  'rKs'    =>array('coef_strickler',50),
    40                                                  'rLong'  =>array('longueur_bief', 50),
    41                                                  'rIf'    =>array('pente_fond', 0.005),
    42                                                  'rYBerge'=>array('h_berge',1)
    43                                                 )
    44                                        );
    45 
    4636    $fieldset_champs['Cond_lim']    = array(
    4737                                           'condition_limite',
    4838                                           array(
    49                                                  'rQ'     =>array('debit_amont', 2),
    50                                                  'rYaval' =>array('h_aval_imposee', 0.6),
    51                                                  'rYamont'=>array('h_amont_imposee', 0.15)
     39                                                 'rQ'     =>array('debit_amont',2,'op'),
     40                                                 'rYaval' =>array('h_aval_imposee',0.6,'pn'),
     41                                                 'rYamont'=>array('h_amont_imposee',0.15,'pn')
    5242                                                )
    5343                                       );
     
    5646                                           'param_calcul',
    5747                                           array(
    58                                                  'rDx'    =>array('pas_discret', 5),
    59                                                  'rPrec'  =>array('precision_calc', 0.001)
     48                                                 'rDx'    =>array('pas_discret',5,'op'),
     49                                                 'rPrec'  =>array('precision_calc',0.001,'op')
    6050                                                )
    6151                                       );
     
    6555}
    6656
    67 // Définition des champs obligatoires pour le formulaire.
    68 function champs_obligatoires() {
     57// Définition des champs à lire dans le formulaire
     58function getChamps() {
    6959
    7060    $tSaisie = mes_saisies_section();
    7161    $sTypeSection = _request('crTypeSection');
    72     $tChOblig = array();
     62    $tData = array();
    7363
    7464    foreach($tSaisie as $IdFS=>$FieldSet) {
     
    7767            // ... alors on parcourt notre deuxième tableau en ajoutant les champs nécessaires.
    7868            foreach($FieldSet[1] as $Cle=>$Champ) {
    79                 if((!isset($Champ[2])) || (isset($Champ[2]) && $Champ[2])) {
    80                     $tChOblig[] = $IdFS.'_'.$Cle;
    81                 }
     69                $tData[$IdFS.'_'.$Cle] = _request($IdFS.'_'.$Cle);
     70                $tCtrl[$IdFS.'_'.$Cle] = $Champ[2];
    8271            }
    8372        }
    8473    }
    85     return $tChOblig;
    86 }
     74    return array($tData,$tCtrl);
     75}
     76
    8777
    8878function formulaires_courbe_remous_charger_dist() {
     
    9484    );
    9585
    96         // On charge tous les champs avec leur valeur
     86    // On charge tous les champs avec leur valeur
    9787    foreach($tSaisie_section as $CleFD=>$FieldSet) {
    9888        foreach($FieldSet[1] as $Cle=>$Champ) {
    99                         $valeurs[$CleFD.'_'.$Cle] = $Champ[1];
     89            $valeurs[$CleFD.'_'.$Cle] = $Champ[1];
    10090        }
    10191    }
     
    10696function formulaires_courbe_remous_verifier_dist(){
    10797    $erreurs = array();
    108     $datas = array();
    109     $tChOblig= champs_obligatoires();
    110 
    111     // On vérifie que les champs obligatoires sont bien là :
    112     foreach($tChOblig as $obligatoire) {
    113         if (!_request($obligatoire)) {
    114             $erreurs[$obligatoire] = _T('hydraulic:champ_obligatoire');}
    115         else {
    116             $datas[$obligatoire] = _request($obligatoire);
    117         }
    118     }
    119 
    120         // Gestion des valeurs négatives
    121     foreach($datas as $champ=>$data) {
    122         if ($data < 0) $erreurs[$champ] = _T('hydraulic:valeur_positive');
    123     }
    124 
    125         // On compte s'il y a des erreurs. Si oui, alors on affiche un message
    126     if (count($erreurs)) {
    127         $erreurs['message_erreur'] = _T('hydraulic:saisie_erreur');
    128     }
    129 
    130     return $erreurs;
     98    list($tData,$tCtrl) = getChamps();
     99    include_spip('hyd_inc/formulaire');
     100    return hyd_formulaires_verifier($tData,$tCtrl);
    131101}
    132102
     
    145115    $crTypeSection = _request('crTypeSection');
    146116
    147         // On récupère tous les champs utiles, à savoir les champs fixes, et les champs appartenant à la section choisie
     117    // On récupère tous les champs utiles, à savoir les champs fixes, et les champs appartenant à la section choisie
    148118    foreach($tSaisie as $IdFS=>$FieldSet) {
    149119        if((substr($IdFS,0,1) != 'F') || ($IdFS == $crTypeSection)){
    150120            foreach($FieldSet[1] as $Cle=>$Champ) {
    151                                 $tChUtil[] = $IdFS.'_'.$Cle;
     121                $tChUtil[] = $IdFS.'_'.$Cle;
    152122            }
    153123        }
     
    179149    // Contrôle du nombre de pas d'espace maximum
    180150    $iPasMax = 1000;
    181     if($Caract_bief_rLong / $Param_calc_rDx > $iPasMax) {
    182         $Param_calc_rDx = $Caract_bief_rLong / $iPasMax;
     151    if($c_bief_rLong / $Param_calc_rDx > $iPasMax) {
     152        $Param_calc_rDx = $c_bief_rLong / $iPasMax;
    183153        $oLog->Add(_T('hydraulic:pas_nombre').' > '.$iPasMax.' => '._T('hydraulic:pas_ajustement').$Param_calc_rDx.' m');
    184154    }
    185     //spip_log(array($Cond_lim_rYaval,$Caract_bief_rKs,$Cond_lim_rQ,$Caract_bief_rLong,$Caract_bief_rIf,$Param_calc_rDx,$Param_calc_rPrec),'hydraulic');
     155    //spip_log(array($Cond_lim_rYaval,$c_bief_rKs,$Cond_lim_rQ,$c_bief_rLong,$c_bief_rIf,$Param_calc_rDx,$Param_calc_rPrec),'hydraulic');
    186156
    187157    // Enregistrement des paramètres dans les classes qui vont bien
    188     $oParam= new cParam($Caract_bief_rKs,$Cond_lim_rQ,$Caract_bief_rIf,$Param_calc_rPrec,$Caract_bief_rYBerge,$Cond_lim_rYaval,$Param_calc_rDx,$Caract_bief_rLong);
    189 
    190         // Création d'un objet de type Section selon la section choisie.
     158    $oParam= new cParam($c_bief_rKs,$Cond_lim_rQ,$c_bief_rIf,$Param_calc_rPrec,$c_bief_rYBerge,$Cond_lim_rYaval,$Param_calc_rDx,$c_bief_rLong);
     159
     160    // Création d'un objet de type Section selon la section choisie.
    191161    switch($crTypeSection) {
    192162        case 'FT':
     
    300270    }
    301271    // Hauteur critique
    302     $oGraph->AddSerie(
    303         'h_critique',
    304         $trX,
    305         $oSection->rHautCritique,  // La cote du fond sera calculée à partir de la pente fournie dans GetGraph
    306         '#ff0000',
    307         'lineWidth:2');
     272    if(is_numeric($oSection->rHautCritique)) {
     273        $oGraph->AddSerie(
     274            'h_critique',
     275            $trX,
     276            $oSection->rHautCritique,  // La cote du fond sera calculée à partir de la pente fournie dans GetGraph
     277            '#ff0000',
     278            'lineWidth:2');
     279    }
    308280    // Hauteur normale
    309     $oGraph->AddSerie(
    310         'h_normale',
    311         $trX,
    312         $oSection->rHautNormale,  // La cote du fond sera calculée à partir de la pente fournie dans GetGraph
    313         '#a4c537',
    314         'lineWidth:2');
     281    if(is_numeric($oSection->rHautNormale)) {
     282        $oGraph->AddSerie(
     283            'h_normale',
     284            $trX,
     285            $oSection->rHautNormale,  // La cote du fond sera calculée à partir de la pente fournie dans GetGraph
     286            '#a4c537',
     287            'lineWidth:2');
     288    }
    315289
    316290    // Décalage des données par rapport au fond
    317     $oGraph->Decal(0, $Caract_bief_rIf, $Caract_bief_rLong);
     291    $oGraph->Decal(0, $c_bief_rIf, $c_bief_rLong);
    318292
    319293    // Récupération du graphique
    320294    $echo .= $oGraph->GetGraph('courbe_remous',400,600);
     295
    321296
    322297    $echo .= $sLog;
     
    338313                <th scope="col">Froude</th>
    339314            </tr>
    340                 <th></th>
    341315        </thead>
    342316        <tbody>';
     
    348322        $echo.='"><td>'.format_nombre($rX,$oParam->iPrec).'</td>';
    349323        if(isset($tr['X1']) && !(($cle = array_search($rX,$tr['X1'])) === false)) {
    350                         // On formalise les résultats, avec le nombre de chiffres aprés la virgule adéquat
     324            // On formalise les résultats, avec le nombre de chiffres aprés la virgule adéquat
    351325            $echo .= '<td>'.format_nombre($tr['Y1'][$cle],$oParam->iPrec).'</td>';
    352326            $echo .= '<td>'.format_nombre($oSection->Calc('Fr', $tr['Y1'][$cle]),$oParam->iPrec).'</td>';
  • _plugins_/hydraulic/trunk/hyd_inc/affiche_resultats.php

    r68473 r93248  
    11<?php
     2
    23/**
    34 * Renvoie un tableau formaté à partir d'un array à deux dimensions
  • _plugins_/hydraulic/trunk/hyd_inc/cache.php

    r56649 r93248  
    4545
    4646function CacheCleanAll() {
    47    $dp = opendir(HYD_CACHE_DIRECTORY);
    48    while($file = readdir($dp)) {
    49       if($file !== '.' and $file != '..') {
    50          unlink(HYD_CACHE_DIRECTORY."/".$file);
    51       }
    52    }
     47    $dp = opendir(HYD_CACHE_DIRECTORY);
     48    while($file = readdir($dp)) {
     49        if($file !== '.' and $file != '..') {
     50            unlink(HYD_CACHE_DIRECTORY."/".$file);
     51        }
     52    }
    5353}
    5454
    5555function format_nombre($nombre,$dec) {
    56    return number_format($nombre, $dec, ',', ' ');
     56    if($nombre === false) {
     57        return _T('hydraulic:non_calcule');
     58    } else {
     59        return number_format($nombre, $dec, '.', ' ');
     60    }
    5761}
    5862
  • _plugins_/hydraulic/trunk/hyd_inc/formulaire.php

    r56649 r93248  
    11<?php
    22
    3 function hyd_get_champ(&$champ) {
    4    if(isset($_POST[$champ[0]]) && $_POST[$champ[0]]!='') {
    5       $champ[2]=$_POST[$champ[0]];
    6    }
    7 }
     3/**
     4 * Vérification de la validité des champs des formulaires du plugin
     5 * @param $data tableau des données du formulaire
     6 * @param $ctrl codes des contrôles à appliquer sur les données
     7 * @author David Dorchies
     8 * @date 22/11/2015
     9 */
     10function hyd_formulaires_verifier($tData,$tCtrl) {
    811
    9 /**
    10  * Affiche
    11  * @param
    12  * @return
    13  */
    14 function hyd_form_affiche(&$champs) {
    15 $aff='<form action="'.$_SERVER['PHP_SELF'].'?'.$_SERVER['QUERY_STRING'].'&var_mode=calcul" method="post"><table>';
    16    foreach($champs as &$champ) {
    17       hyd_get_champ($champ);
    18       $aff.='<tr><td align="right">'.$champ[1].' :</td><td><input name="'.$champ[0].
    19          '" type="text" size="30" maxlength="30" value="'.$champ[2].'"></td></tr>';
    20    }
    21    $aff.='<tr><td></td><td><input type="submit" value=" Calculer la courbe de remous"></td></tr>';
    22    $aff.='</table></form>';
    23    return $aff;
     12    foreach($tCtrl as $Cle=>$Ctrl) {
     13        $tData[$Cle] = trim(str_replace(',','.',$tData[$Cle]));
     14        if(strpos($Ctrl,'o')!==false & (!isset($tData[$Cle]) | $tData[$Cle]=="")) {
     15            // Champ obligatoire
     16            $erreurs[$Cle] = _T('hydraulic:erreur_obligatoire');
     17        } elseif(!preg_match('#^[-+]?[0-9]*\.?[0-9]+([eE][-+]?[0-9]+)?$#', $tData[$Cle]) & $tData[$Cle]!="") {
     18            // Valeurs numériques obligatoires dans tous les cas
     19            $erreurs[$Cle] = _T('hydraulic:erreur_non_numerique');
     20        } else {
     21            // Conversion des champs en valeur réelle
     22            $tData[$Cle] =  floatval($tData[$Cle]);
     23            if(strpos($Ctrl,'p')!==false & strpos($Ctrl,'n')!==false & $tData[$Cle] < 0) {
     24                // Contrôles des valeurs qui doivent être positives ou nulles
     25                $erreurs[$Cle] = _T('hydraulic:erreur_val_positive_nulle');
     26            } elseif(strpos($Ctrl,'p')!==false & strpos($Ctrl,'n')===false & $tData[$Cle] <= 0) {
     27                // Contrôles des valeurs qui doivent être strictement positives
     28                $erreurs[$Cle] = _T('hydraulic:erreur_val_positive');
     29            }
     30        }
     31    }
     32
     33    // On compte s'il y a des erreurs. Si oui, alors on affiche un message
     34    if (count($erreurs)) {
     35        $erreurs['message_erreur'] = _T('hydraulic:saisie_erreur');
     36    }
     37
     38    return $erreurs;
    2439}
    2540
  • _plugins_/hydraulic/trunk/hyd_inc/log.class.php

    r56649 r93248  
    3131   }
    3232
    33    public function Add($sTxt) {
    34       $this->txt .= '<li>'.$sTxt.'</li>';
     33   public function Add($sTxt,$bErr=false) {
     34      $this->txt .= '<li';
     35      if($bErr) {$this->txt .= ' class="hyd_erreur"';}
     36      $this->txt .= '>'.$sTxt.'</li>';
    3537   }
    3638
  • _plugins_/hydraulic/trunk/hyd_inc/section.class.php

    r83413 r93248  
    105105        $this->oLog = &$oLog;
    106106        $this->CalcGeo('B');
    107         spip_log($this,'hydraulic');
     107        //~ spip_log($this,'hydraulic');
    108108    }
    109109
     
    143143    public function Calc($sDonnee, $rY = false) {
    144144        if($rY!==false && $rY!=$this->rY) {
    145             //spip_log('Calc('.$sDonnee.') rY='.$rY,'hydraulic');
     145            //~ spip_log('Calc('.$sDonnee.') rY='.$rY.' => $this->rY','hydraulic');
    146146            $this->rY = $rY;
    147147            // On efface toutes les données dépendantes de Y pour forcer le calcul
    148148            $this->Reset(false);
    149149        }
    150 
    151         if(!isset($this->arCalc[$sDonnee])) {
     150        //~ spip_log($this->arCalc,'hydraulic');
     151        if(!isset($this->arCalc[$sDonnee]) | !$this->arCalc[$sDonnee]) {
    152152            // La donnée a besoin d'être calculée
    153153            switch($sDonnee) {
     
    216216            }
    217217        }
    218         //spip_log('Calc('.$sDonnee.')='.$this->arCalc[$sDonnee],'hydraulic');
     218        //~ spip_log('Calc('.$sDonnee.')='.$this->arCalc[$sDonnee],'hydraulic');
    219219        return $this->arCalc[$sDonnee];
    220220    }
     221
     222
    221223
    222224    /**
     
    233235        if(!isset($this->arCalcGeo[$sDonnee])) {
    234236            // La donnée a besoin d'être calculée
    235             spip_log('CalcGeo('.$sDonnee.') rY='.$this->oP->rYB,'hydraulic');
     237            //spip_log('CalcGeo('.$sDonnee.') rY='.$this->oP->rYB,'hydraulic');
    236238            $this->Swap(true); // On mémorise les données hydrauliques en cours
    237239            $this->Reset(false);
     
    264266                    $this->arCalcGeo[$sDonnee] = $this->CalcHsc();
    265267            }
    266         }
    267         $this->Swap(false); // On restitue les données hydrauliques en cours
    268         //spip_log('CalcGeo('.$sDonnee.')='.$this->arCalcGeo[$sDonnee],'hydraulic');
     268            //~ spip_log('CalcGeo('.$sDonnee.',rY='.$this->oP->rYB.')='.$this->arCalcGeo[$sDonnee],'hydraulic');
     269            $this->Swap(false); // On restitue les données hydrauliques en cours
     270        }
    269271        return $this->arCalcGeo[$sDonnee];
    270272    }
     
    275277     */
    276278    protected function CalcS($rY) {
     279        //~ spip_log('section->CalcS(rY='.$rY.')='.($rY*$this->rLargeurBerge),'hydraulic');
    277280        return $rY*$this->rLargeurBerge;
    278281    }
     
    283286    * @return Le périmètre hydraulique
    284287    */
    285     protected function CalcP($rY) {
     288    protected function CalcP($rY=0) {
     289        //~ spip_log('section->CalcP(rY='.$rY.')='.(2*$rY),'hydraulic');
    286290        return 2*$rY;
    287291    }
     
    436440        $oHautCritique = new cHautCritique($this, $this->oP);
    437441        if(!$this->rHautCritique = $oHautCritique->Newton($this->oP->rYB) or !$oHautCritique->HasConverged()) {
    438          $this->oLog->Add(_T('hydraulic:h_critique').' : '._T('hydraulic:newton_non_convergence'));
     442         $this->oLog->Add(_T('hydraulic:h_critique').' : '._T('hydraulic:newton_non_convergence'),true);
    439443      }
    440444      return $this->rHautCritique;
     
    446450    */
    447451    private function CalcYn() {
    448         $oHautNormale= new cHautNormale($this, $this->oP);
    449         if(!$this->rHautNormale = $oHautNormale->Newton($this->CalcGeo('Yc')) or !$oHautNormale->HasConverged()) {
    450             $this->oLog->Add(_T('hydraulic:h_normale').' : '._T('hydraulic:newton_non_convergence'));
     452        if($this->oP->rIf <= 0) {
     453            $this->rHautNormale = false;
     454            $this->oLog->Add(_T('hydraulic:h_normale_pente_neg_nul'),true);
     455        } else {
     456            $oHautNormale= new cHautNormale($this, $this->oP);
     457            if(!$this->rHautNormale = $oHautNormale->Newton($this->CalcGeo('Yc')) or !$oHautNormale->HasConverged()) {
     458                $this->oLog->Add(_T('hydraulic:h_normale').' : '._T('hydraulic:newton_non_convergence'),true);
     459            }
    451460        }
    452461        return $this->rHautNormale;
     
    489498        // Choisir une valeur initiale du bon côté de la courbe
    490499        if($this->Calc('Fr') < 1) {
    491                         // Ecoulement fluvial, on cherche la conjuguée à partir du tirant d'eau torrentiel
    492                         $rY0 = $this->Calc('Yt');
    493                 }
    494                 else {
    495                         // Ecoulement torrentiel, on cherche la conjuguée à partir du tirant d'eau fluvial
    496                         $rY0 = $this->Calc('Yf');
    497                 }
     500            // Ecoulement fluvial, on cherche la conjuguée à partir du tirant d'eau torrentiel
     501            $rY0 = $this->Calc('Yt');
     502        }
     503        else {
     504            // Ecoulement torrentiel, on cherche la conjuguée à partir du tirant d'eau fluvial
     505            $rY0 = $this->Calc('Yf');
     506        }
    498507        if(!$Yco = $oHautConj->Newton($rY0) or !$oHautConj->HasConverged()) {
    499             $this->oLog->Add(_T('hydraulic:h_conjuguee').' : '._T('hydraulic:newton_non_convergence'));
     508            $this->oLog->Add(_T('hydraulic:h_conjuguee').' : '._T('hydraulic:newton_non_convergence'),true);
    500509        }
    501510        return $Yco;
     
    563572        $this->Swap(true); // On mémorise les données hydrauliques en cours
    564573        for($rY=0;$rY<$this->oP->rYB+$rPas/2;$rY+=$rPas) {
    565             spip_log('DessinCoordonnees rY='.$rY,'hydraulic');
     574            //~ spip_log('DessinCoordonnees rY='.$rY,'hydraulic');
    566575            $tPoints['x'][] = $this->Calc('B',$rY)/2;
    567576            $tPoints['y'][] = $rY;
     
    599608        // Calcul de la fonction
    600609        if($this->oSn->Calc('S',$rX)!=0) {
    601             $rFn = (pow($this->oP->rQ,2)/pow($this->oSn->Calc('S',$rX),2)*($this->oSn->Calc('B',$rX)/$this->oSn->Calc('S',$rX)/$this->oP->rG)-1);
     610            $rFn = (pow($this->oP->rQ,2)*$this->oSn->Calc('B',$rX)/pow($this->oSn->Calc('S',$rX),3)/$this->oP->rG-1);
    602611        }
    603612        else {
    604613            $rFn = INF;
    605614        }
    606         //spip_log('cHautCritique:CalcFn('.$rX.')='.$rFn,'hydraulic');
     615        //~ spip_log('cHautCritique:CalcFn('.$rX.')='.$rFn,'hydraulic');
    607616        return $rFn;
    608617    }
     
    706715        // Calcul de la fonction
    707716        $rFn = $this->rY - $rX + ($this->rS2-pow($this->oSn->Calc('S',$rX),-2))*$this->rQ2G;
    708         spip_log('cHautCorrespondante:CalcFn('.$rX.')='.$rFn,'hydraulic');
     717        //~ spip_log('cHautCorrespondante:CalcFn('.$rX.')='.$rFn,'hydraulic');
    709718        return $rFn;
    710719    }
     
    722731            $rDer = INF;
    723732        }
    724         spip_log('cHautCorrespondante:CalcDer('.$rX.')='.$rDer,'hydraulic');
     733        //~ spip_log('cHautCorrespondante:CalcDer('.$rX.')='.$rDer,'hydraulic');
    725734        return $rDer;
    726735    }
     
    770779        // Réinitialisation des paramètres hydrauliques de oSn avec l'appel $this->oSn->Calc('S',$rX)
    771780        if($this->rS > 0 && $this->oSn->Calc('S',$rX) > 0) {
    772                         $rFn = $this->rQ2 * (1 / $this->rS - 1 / $this->oSn->Calc('S'));
    773                         $rFn += $this->rG * ($this->rSYg - $this->oSn->Calc('SYg'));
    774                 }
    775                 else {
    776                         $rFn = -INF;
    777                 }
    778         spip_log('cHautConjuguee:CalcFn('.$rX.')='.$rFn,'hydraulic');
     781            $rFn = $this->rQ2 * (1 / $this->rS - 1 / $this->oSn->Calc('S'));
     782            $rFn += $this->rG * ($this->rSYg - $this->oSn->Calc('SYg'));
     783        }
     784        else {
     785            $rFn = -INF;
     786        }
     787        //~ spip_log('cHautConjuguee:CalcFn('.$rX.')='.$rFn,'hydraulic');
    779788        return $rFn;
    780789    }
     
    793802            $rDer = -INF;
    794803        }
    795         spip_log('cHautConjuguee:CalcDer('.$rX.')='.$rDer,'hydraulic');
     804        //~ spip_log('cHautConjuguee:CalcDer('.$rX.')='.$rDer,'hydraulic');
    796805        return $rDer;
    797806    }
  • _plugins_/hydraulic/trunk/hyd_inc/section.php

    r68473 r93248  
    55 */
    66
    7 /*      Copyright 2012 David Dorchies <dorch@dorch.fr>, Médéric Dulondel
     7/*      Copyright 2012, 2015 David Dorchies <dorch@dorch.fr>, Médéric Dulondel
    88 *
    99 *      This program is free software; you can redistribute it and/or modify
     
    2323 */
    2424
     25
    2526/*
    26  * Caractéristiques des différents types de section.
     27 * Caractéristiques communes aux calculs sur les sections :
     28 * - Caractéristiques des différents types de section
     29 * - Caractéristiques du bief
    2730 */
    2831function caract_communes() {
     32    // Tableau niveau 1 : Composantes
     33    // pour chaque variable, a clé est le nom de la variable dans le formulaire, et la valeur contient un tableau avec le code de langue, la valeur par défaut et les tests de de vérification à effectuer sur le champ (o : obligatoire, p : positif, n : nul)
    2934
    3035    $caract_com = array(
     
    3237            'def_section_trap',
    3338            array(
    34                 'rLargeurFond'  =>array('largeur_fond',2.5),
    35                 'rFruit'        =>array('fruit', 0.56)
     39                'rLargeurFond'  =>array('largeur_fond',2.5,'opn'),
     40                'rFruit'        =>array('fruit', 0.56,'opn')
    3641            )
    3742        ),
     
    4045            'def_section_rect',
    4146            array(
    42                 'rLargeurBerge'  =>array('largeur_fond',2.5),
     47                'rLargeurBerge'  =>array('largeur_fond',2.5,'op'),
    4348            )
    4449        ),
     
    4752            'def_section_circ',
    4853            array(
    49                 'rD'  =>array('diametre',2)
     54                'rD'  =>array('diametre',2,'op')
    5055            )
    5156        ),
     
    5459            'def_section_parab',
    5560            array(
    56                 'rk' =>array('coef',0.5),
    57                 'rLargeurBerge' =>array('largeur_berge', 4)
     61                'rk' =>array('coef',0.5,'op'),
     62                'rLargeurBerge' =>array('largeur_berge',4,'op')
    5863            )
    5964        )
    6065    );
    6166
     67    $caract_com['c_bief'] = array(
     68       'caract_bief',
     69       array(
     70             'rKs'    =>array('coef_strickler',50,'op'),
     71             'rLong'  =>array('longueur_bief',50,'op'),
     72             'rIf'    =>array('pente_fond',0.005,'opn'),
     73             'rYBerge'=>array('h_berge',1,'opn')
     74            )
     75   );
     76
    6277    return $caract_com;
    6378}
    6479
     80
     81
    6582?>
  • _plugins_/hydraulic/trunk/hyd_inc/sectionCirc.class.php

    r68484 r93248  
    9696    /**
    9797     * Calcul du périmètre mouillé.
     98     * @param $rY Uniquement présent car la méthode parent a cet argument
    9899     * @return B
    99100     */
    100      protected function CalcP() {
     101     protected function CalcP($rY=0) {
    101102        if($this->rY > $this->oP->rYB and !$this->bSnFermee) {
    102103            // On n'ajoute pas le périmètre dans le cas d'une fente de Preissmann
     
    110111    /**
    111112     * Calcul de la surface mouillée.
     113     * @param $rY Uniquement présent car la méthode parent a cet argument
    112114     * @return S
    113115     */
    114     protected function CalcS() {
     116    protected function CalcS($rY=0) {
    115117        if($this->rY > $this->oP->rYB) {
    116118            return $this->CalcGeo('S') + parent::CalcS($this->rY-$this->oP->rYB);
     
    163165     * Calcul de la distance du centre de gravité de la section à la surface libre
    164166     * multiplié par la surface hydraulique
     167     * @param $rY Uniquement présent car la méthode parent a cet argument
    165168     * @return S x Yg
    166169     */
    167     protected function CalcSYg() {
     170    protected function CalcSYg($rY=0) {
    168171        $SYg = sin($this->Calc('Alpha'))-pow(sin($this->Calc('Alpha')),3) / 3 - $this->Calc('Alpha') * cos($this->Calc('Alpha'));
    169172        $SYg = pow($this->rD,3) / 8 * $SYg;
     
    174177     * Calcul de la dérivée de la distance du centre de gravité de la section à la surface libre
    175178     * multiplié par la surface hydraulique
     179     * @param $rY Uniquement présent car la méthode parent a cet argument
    176180     * @return S x Yg
    177181     */
    178     protected function CalcSYgder() {
     182    protected function CalcSYgder($rY=0) {
    179183        $cos = cos($this->Calc('Alpha'));
    180184        $sin = sin($this->Calc('Alpha'));
  • _plugins_/hydraulic/trunk/hyd_inc/sectionPuiss.class.php

    r68473 r93248  
    6363    /**
    6464     * Calcul du périmètre mouillé.
     65     * @param $rY Uniquement présent car la méthode parent à cet argument
    6566     * @return B
    6667     */
    67      protected function CalcP() {
     68     protected function CalcP($rY=0) {
    6869        $n=100; /// Le nombre de partie pour le calcul de l'intégrale
    6970        $rLambda2 = pow($this->Calc('Alpha'),2);
     
    8182    /**
    8283     * Calcul de la surface mouillée.
     84     * @param $rY Uniquement présent car la méthode parent a cet argument
    8385     * @return S
    8486     */
    85     protected function CalcS() {
     87    protected function CalcS($rY=0) {
    8688        return $this->Calc('Alpha')*pow($this->rY, $this->rk+1)/($this->rk+1);
    8789    }
     
    107109     * Calcul de la distance du centre de gravité de la section à la surface libre
    108110     * multiplié par la surface hydraulique
     111     * @param $rY Uniquement présent car la méthode parent a cet argument
    109112     * @return S x Yg
    110113     */
    111     protected function CalcSYg() {
     114    protected function CalcSYg($rY=0) {
    112115        return $this->Calc('Alpha')*pow($this->rY, $this->rk+2)/(($this->rk+1)*($this->rk+2));
    113116    }
     
    115118     * Calcul de la dérivée distance du centre de gravité de la section à la surface libre
    116119     * multiplié par la surface hydraulique
     120     * @param $rY Uniquement présent car la méthode parent a cet argument
    117121     * @return S x Yg
    118122     */
    119     protected function CalcSYgder() {
     123    protected function CalcSYgder($rY=0) {
    120124        $SYg = $this->Calc('dAlpha')*pow($this->rY, $this->rk+2) + $this->Calc('Alpha')*pow($this->rY, $this->rk+1)*($this->rk+2);
    121125        return $SYg/(($this->rk+1)*($this->rk+2));
    122126    }
    123 
    124127}
    125128?>
  • _plugins_/hydraulic/trunk/hyd_inc/sectionRectang.class.php

    r68484 r93248  
    3636    }
    3737
    38     protected function CalcP() {
     38    /**
     39     * Calcul du périmètre mouillé
     40     * @param $rY Uniquement présent car la méthode parent à cet argument
     41     * @return Périmètre mouillé (m)
     42     */
     43    protected function CalcP($rY=0) {
    3944        return $this->rLargeurBerge+parent::CalcP($this->rY);
    4045    }
    4146
    42     protected function CalcS() {
     47    /**
     48     * Calcul de la surface mouillée
     49     * @param $rY Uniquement présent car la méthode parent à cet argument
     50     * @return Surface mouillée (m2)
     51     */
     52    protected function CalcS($rY=0) {
    4353        return parent::CalcS($this->rY);
    4454    }
     
    4757     * Calcul de la distance du centre de gravité de la section à la surface libre
    4858     * multiplié par la section
     59     * @param $rY Uniquement présent car la méthode parent à cet argument
    4960     * @return SYg
    5061     */
    51     protected function CalcSYg() {
     62    protected function CalcSYg($rY=0) {
    5263        return parent::CalcSYg($this->rY);
    5364    }
     
    5667     * Calcul de la dérivée de la distance du centre de gravité de la section à la surface libre
    5768     * multiplié par la section
     69     * @param $rY Uniquement présent car la méthode parent à cet argument
    5870     * @return Dérivée de SYg par rapport à Y
    5971     */
    60     protected function CalcSYgder() {
     72    protected function CalcSYgder($rY=0) {
    6173        return parent::CalcSYgder($this->rY);
    6274    }
  • _plugins_/hydraulic/trunk/hyd_inc/sectionTrapez.class.php

    r68473 r93248  
    4949    }
    5050
    51     protected function CalcP() {
     51    /**
     52     * Calcul du périmètre mouillé
     53     * @param $rY Uniquement présent car la méthode parent à cet argument
     54     * @return Périmètre mouillé (m)
     55     */
     56    protected function CalcP($rY=0) {
    5257        if($this->rY > $this->oP->rYB) {
    53             return $this->CalcGeo('P') + parent::CalcP($this->rY-$this->oP->rYB);
     58            $P = $this->CalcGeo('P') + parent::CalcP($this->rY-$this->oP->rYB);
    5459        }
    5560        else {
    56             return $this->rLargeurFond+2*sqrt(1+pow($this->rFruit,2))*$this->rY;
     61            $P = $this->rLargeurFond+2*sqrt(1+pow($this->rFruit,2))*$this->rY;
    5762        }
     63        //~ spip_log('Trapez->CalcP(rY='.$this->rY.')='.$P,'hydraulic');
     64        return $P;
    5865    }
    5966
    60     protected function CalcS() {
     67
     68    /**
     69     * Calcul de la surface mouillée
     70     * @param $rY Uniquement présent car la méthode parent à cet argument
     71     * @return Surface mouillée (m2)
     72     */
     73    protected function CalcS($rY=0) {
    6174        if($this->rY > $this->oP->rYB) {
    62             return $this->CalcGeo('S') + parent::CalcS($this->rY-$this->oP->rYB);
     75            $S = $this->CalcGeo('S') + parent::CalcS($this->rY-$this->oP->rYB);
    6376        }
    6477        else {
    65             return $this->rY*($this->rLargeurFond+$this->rFruit*$this->rY);
     78            $S = $this->rY*($this->rLargeurFond+$this->rFruit*$this->rY);
    6679        }
     80        //~ spip_log('Trapez->CalcS(rY='.$this->rY.')='.$S,'hydraulic');
     81        return $S;
    6782    }
    6883
     
    109124     * Calcul de la distance du centre de gravité de la section à la surface libre
    110125     * multiplié par la surface hydraulique
     126     * @param $rY Uniquement présent car la méthode parent à cet argument
    111127     * @return S x Yg
    112128     */
    113     protected function CalcSYg() {
     129    protected function CalcSYg($rY=0) {
    114130        return ($this->rLargeurFond / 2 + $this->rFruit * $this->rY / 3) * pow($this->rY,2);
    115131    }
     
    118134     * Calcul de la dérivée de la distance du centre de gravité de la section à la surface libre
    119135     * multiplié par la surface hydraulique
     136     * @param $rY Uniquement présent car la méthode parent à cet argument
    120137     * @return S x Yg
    121138     */
    122     protected function CalcSYgder() {
     139    protected function CalcSYgder($rY=0) {
    123140        $SYg = $this->rFruit / 3 * pow($this->rY,2);
    124141        $SYg += ($this->rLargeurFond / 2 + $this->rFruit * $this->rY / 3) * 2 * $this->rY;
  • _plugins_/hydraulic/trunk/hydraulic.css.html

    r68473 r93248  
    3737    /*font-size: 12px;*/
    3838    list-style-type: disc;
     39    margin-left: 1em;
    3940}
     41
     42.hyd_erreur {
     43    background-color: #FBE3E4;
     44}
     45
    4046
    4147.hyd_erreur {
     
    107113
    108114.varACal {
    109     background: #919191;
    110     color: white;
    111115    font-weight: bold;
    112116}
  • _plugins_/hydraulic/trunk/lang/hydraulic_en.php

    r68484 r93248  
    33$GLOBALS[$GLOBALS['idx_lang']] = array(
    44    // A
    5     'abscisse'        => "Abscissa",
    6     'arret_calcul'    => "Calculation stopped: Critical elevation reached at abscissa",
    7     'acier_lamine'    => "Rolled steel - Smooth concrete",
     5    'abscisse'          => "Abscissa",
     6    'arret_calcul'      => "Calculation stopped: Critical elevation reached at abscissa",
     7    'acier_lamine'      => "Rolled steel - Smooth concrete",
    88    // B
    9     'berge'           => "Embankment",
     9    'berge'             => "Embankment",
    1010    // C
    11     'calcul_caract'   => "The calculation has the following characteristics:",
    12     'calcul_remous'   => "Calculation of backwater curve",
    13     'calculer_remous' => "Calculate the backwater curve",
    14     'caract_bief'     => "Features reach",
    15     'coef_strickler'  => "Strickler coefficient (m<sup>1/3</sup>s<sup>-1</sup>)",
    16     'condition_limite'=> "Boundary conditions",
    17     'calcul_fluvial'  => "Downstream boundary condition >= Critical elevation : calculation of subcritical part from downstream",
    18     'calcul_torrentiel'=> "Uptream boundary condition <= Critical elevation : calculation of supercritical part from upstream",
    19     'champ_obligatoire'=> "This field is required",
    20     'choix_materiau'  => "Choice of material",
    21     'caract'          => "Characteristics",
     11    'calcul_caract'     => "The calculation has the following characteristics:",
     12    'calcul_remous'     => "Calculation of backwater curve",
     13    'calculer_remous'   => "Calculate the backwater curve",
     14    'caract_bief'       => "Features reach",
     15    'coef_strickler'    => "Strickler coefficient (m<sup>1/3</sup>s<sup>-1</sup>)",
     16    'condition_limite'  => "Boundary conditions",
     17    'calcul_fluvial'    => "Downstream boundary condition >= Critical elevation : calculation of subcritical part from downstream",
     18    'calcul_torrentiel' => "Uptream boundary condition <= Critical elevation : calculation of supercritical part from upstream",
     19    'choix_materiau'    => "Choice of material",
     20    'caract'            => "Characteristics",
     21    'calculer'          => "Compute",
    2222    'calculer_lechapt_calmon' => "Calculation with Lechapt and Calmon formula",
    23     'calcul_val'      => "Value to calculate",
    24     'choix_section'   => "Choice of section",
    25     'caract_globale'  => "Overall characteristics",
    26     'charge_spe'      => "Specific head (m)",
     23    'calcul_val'        => "Value to calculate",
     24    'choix_section'     => "Choice of section type",
     25    'caract_globale'    => "Overall characteristics",
     26    'charge_spe'        => "Specific head (m)",
    2727    'choix_donnee_calc' => "Choice of the data to compute",
    28     'charge_critique' => "Critical head (m)",
    29     'cote_eau'        => "Water level (m)",
    30         'coef'                    => "Coefficient",
    31     'cunge'           => "Cunge 1980",
     28    'charge_critique'   => "Critical head (m)",
     29    'cote_eau'          => "Water level (m)",
     30    'coef'              => "Coefficient",
     31    'cunge'             => "Cunge 1980",
    3232    // D
    33     'debit_amont'     => "Upstream flow (m<sup>3</sup>/s)",
    34     'def_section_trap'=> "Definition of trapezoidal section",
    35     'def_section_rect'=> "Definition of rectangular section",
    36     'def_section_circ'=> "Definition of circular section",
    37     'def_section_parab'=> "Definition of parabolic section",
    38     'diametre'        => "Diameter (m)",
    39         'donnee_calc'     => "Data to compute",
    40     'debit'           => "Flow (m<sup>3</sup>/s)",
     33    'debit_amont'       => "Upstream flow (m<sup>3</sup>/s)",
     34    'def_section_trap'  => "Definition of trapezoidal section",
     35    'def_section_rect'  => "Definition of rectangular section",
     36    'def_section_circ'  => "Definition of circular section",
     37    'def_section_parab' => "Definition of parabolic section",
     38    'diametre'          => "Diameter (m)",
     39    'donnee_calc'       => "Data to compute",
     40    'debit'             => "Flow (m<sup>3</sup>/s)",
     41    // E
     42    'erreur_obligatoire' => "This field is required",
     43    'erreur_non_numerique' => "This field must be numeric",
     44    'erreur_val_positive' => "This value must be strictly positive",
     45    'erreur_val_positive_nulle' => "This value must be positive or null",
    4146     // F
    4247    'flag_erreur_calcul'=> "Calculation error",
    43     'flag_débit_nul'    => "No flow",
     48    'flag_debit_nul'    => "No flow",
    4449    'flag_libre_den'    => "Libre dénoyé",
    4550    'flag_libre_noy'    => "Libre noyé",
     
    4954    'flag_surverse_den' => "Surverse dénoyée",
    5055    'flag_surverse_noy' => "Surverse noyée",
    51     'fond'            => "Bottom",
    52     'fruit'           => "Bank slope (m/m)",
    53     'fixer_val'       => "Fixed parameter",
     56    'fond'              => "Bottom",
     57    'fruit'             => "Bank slope (m/m)",
     58    'fixer_val'         => "Fixed parameter",
    5459    'fonte_beton_corrosive' =>"Unlined cast iron - Coarse concrete (corrosive water)",
    5560    'fonte_beton_ncorrosive' => "Cast steel or uncoated - Concrete coarse (somewhat corrosive water)",
     
    5762    'fonte_revt_bitume' => "Cast iron or steel coating bitumen - Concrete centrifuged",
    5863    'fonte_revt_centrifuge' => "Cast iron or steel coating centrifuged",
    59         'froud'           => "Froude number",
    60     'force_tract'     => "Tractive force (Pa)",
     64    'froud'             => "Froude number",
     65    'force_tract'       => "Tractive force (Pa)",
    6166    // H
    62     'h_amont_imposee' => "Water level imposed at the upstream (m)",
    63     'h_aval_imposee'  => "Downstream water level imposed (m)",
    64     'h_berge'         => "Embankment elevation (m)",
    65     'h_critique'      => "Critical elevation",
    66     'h_normale'       => "Normal elevation"
    67 ,   'h_pelle'         => "Gate elevation (m)",
    68         //I
    69     'impulsion'       => "Impulse (N)",
     67    'h_amont_imposee'   => "Water level imposed at upstream (m)",
     68    'h_aval_imposee'    => "Water level imposed at downstream (m)",
     69    'h_berge'           => "Embankment elevation (m)",
     70    'h_conjuguee'       => "Conjuguate water level",
     71    'h_critique'        => "Critical water level",
     72    'h_normale'         => "Normal water level",
     73    'h_normale_pente_neg_nul' => "The bottom slope is null or negative, the normal elevation is infinite",
     74    'h_pelle'           => "Sill elevation (m)",
     75    // I
     76    'impulsion'         => "Impulse (N)",
    7077    // L
    71     'largeur_fond'    => "Width at bottom (m)",
    72     'largeur_berge'   => "Width at embankment level",
     78    'largeur_fond'      => "Width at bottom (m)",
     79    'largeur_berge'     => "Width at embankment level",
    7380    'ligne_eau_fluviale'  => "Subcritical water profile",
    7481    'ligne_eau_torrentielle'  => "Supercritical water profile",
    75     'log_titre'       => "Calculation's log",
    76     'longueur_bief'   => "Length of reach (m)",
    77         'larg_miroir'     => "Surface width (m)",
    78         'loi_debit'       => "Flow equation",
    79     //N
     82    'log_titre'         => "Calculation's log",
     83    'longueur_bief'     => "Length of reach (m)",
     84    'larg_miroir'       => "Surface width (m)",
     85    'loi_debit'         => "Flow equation",
     86    // N
    8087    'newton_non_convergence' => "Non-convergence of the calculation (Newton's method)",
     88    'non_calcule'       => "not calculated",
    8189    // O
    82     'ordonnee'        => "Ordinate",
    83     'or_cemagref88'   => "Déversoir/Orifice Cemagref 88",
    84     'or_cemagref02'   => "Déversoir/Orifice Cemagref 02",
     90    'ordonnee'          => "Ordinate",
     91    'or_cemagref88'     => "Déversoir/Orifice Cemagref 88",
     92    'or_cemagref02'     => "Déversoir/Orifice Cemagref 02",
    8593    // P
    86     'param_calcul'    => "Calculation parameters",
    87     'param_fixes'     => "Fixed parameters",
    88     'pas_ajustement'  => "adjustement of space step to ",
    89     'pas_discret'     => "Discretization step (m)",
    90     'pas_nombre'      => "Number of space step",
    91     'pente_fond'      => "Bottom slope (m/m)",
    92     'precision_calc'  => "Accuracy of calculation and display of dimensions (m)",
     94    'param_calcul'      => "Calculation parameters",
     95    'param_fixes'       => "Fixed parameters",
     96    'pas_ajustement'    => "adjustement of space step to ",
     97    'pas_discret'       => "Discretization step (m)",
     98    'pas_nombre'        => "Number of space step",
     99    'pente_fond'        => "Bottom slope (m/m)",
     100    'precision_calc'    => "Accuracy of calculation and display of dimensions (m)",
    93101    'pas_calcul_depuis_aval' => "Downstream boundary condition < Critical elevation : no possible calculation from downstream",
    94102    'pas_calcul_depuis_amont' => "Upstream boundary condition < Critical elevation : no possible calculation from upstream",
    95     'pas_var' => "With a variation step of",
    96     'pvc' => "PVC - Polyethylene",
    97     'param_Q' => "Q: Flow (m&#179; / s)",
    98     'param_D' => "D: Pipe diameter (m)",
    99     'param_J' => "J: Head drop (m)",
    100     'param_Lg' => "Lg: Pipe length (m)",
    101     'param_L'         => "Largeur (m)",
    102     'param_W'         => "Ouverture (m)",
    103     'param_C'         => "Coefficient de débit",
    104     'param_CS'        => "Coefficient de débit de la surverse",
    105     'param_H'         => "Hauteur de la pelle (surverse)",
    106     'param_LF'        => "Largeur au fond (m)",
    107     'param_CR'        => "Coefficient de débit partie rectangulaire",
    108     'param_CR'        => "Coefficient de débit partie triangulaire",
    109     'param_F'     => "Fruit (m/m)",
    110     'param_ZM'        => "Cote de l'eau à l'amont (m)",
    111     'param_ZV'        => "Côte de l'eau à l'aval (m)",
    112     'precision' => "Display accuracy (m)",
    113         'perim_mouille'   => "Wetted perimeter",
    114     'perte_charge'    => "Head loss (m)",
     103    'pas_var'           => "With a variation step of",
     104    'pvc'               => "PVC - Polyethylene",
     105    'param_Q'           => "Q: Flow (m&#179; / s)",
     106    'param_D'           => "D: Pipe diameter (m)",
     107    'param_J'           => "J: Head drop (m)",
     108    'param_Lg'          => "Lg: Pipe length (m)",
     109    'param_L'           => "Largeur (m)",
     110    'param_W'           => "Ouverture (m)",
     111    'param_C'           => "Coefficient de débit",
     112    'param_CS'          => "Coefficient de débit de la surverse",
     113    'param_H'           => "Hauteur de la pelle (surverse)",
     114    'param_LF'          => "Largeur au fond (m)",
     115    'param_CR'          => "Coefficient de débit partie rectangulaire",
     116    'param_CT'          => "Coefficient de débit partie triangulaire",
     117    'param_F'           => "Fruit (m/m)",
     118    'param_ZM'          => "Cote de l'eau à l'amont (m)",
     119    'param_ZV'          => "Côte de l'eau à l'aval (m)",
     120    'precision'         => "Display accuracy (m)",
     121    'perim_mouille'     => "Wetted perimeter",
     122    'perte_charge'      => "Head loss (m)",
    115123    //R
    116     'rayon_hyd'       => "Hydraulic radius",
    117     'rugosite_nc'     => "Roughness (Strickler m<sup>1/3</sup>s<sup>-1</sup>)",
     124    'rayon_hyd'         => "Hydraulic radius",
     125    'rugosite_nc'       => "Roughness (Strickler m<sup>1/3</sup>s<sup>-1</sup>)",
    118126    //S
    119     'saisie_erreur'   => "Your entry contains errors!",
    120     'section_trap'    => "Trapezoidal Section",
    121     'section_rect'    => "Rectangular Section",
    122     'section_circ'    => "Circular Section",
    123     'section_parab'   => "Parabolic Section",
    124     'seuil_rect'      => "Seuil Rectangulaire",
    125     'seuil_trap'      => "Seuil Trapézoïdal",
    126         'surf_mouille'    => "Wetted area m<sup>2</sup>",
    127     's_cemagref88'    => "Vanne de fond/Seuil Cemagref 88",
    128     's_denoye'        => "Seuil dénoyé",
    129     's_noye'          => "Seuil noyé",
    130     's_cemagref02'    => "Vanne de fond/Seuil Cemagref 02",
     127    'saisie_erreur'     => "Your entry contains errors!",
     128    'section_trap'      => "Trapezoidal",
     129    'section_rect'      => "Rectangular",
     130    'section_circ'      => "Circular",
     131    'section_parab'     => "Parabolic",
     132    'seuil_rect'        => "Seuil Rectangulaire",
     133    'seuil_trap'        => "Seuil Trapézoïdal",
     134    'surf_mouille'      => "Wetted area m<sup>2</sup>",
     135    's_cemagref88'      => "Vanne de fond/Seuil Cemagref 88",
     136    's_denoye'          => "Seuil dénoyé",
     137    's_noye'            => "Seuil noyé",
     138    's_cemagref02'      => "Vanne de fond/Seuil Cemagref 02",
    131139    //T
    132     'tirant_eau'         => "Draft (m)",
    133     'type_materiau' => "Type of material",
    134     'tuyau_lisse1' => "Hydraulically smooth pipe - 0.05 &#8804; D &#8804; 0.2 ",
    135     'tuyau_lisse2' => "Hydraulically smooth pipe - 0.25 &#8804; D &#8804; 1 ",
    136     'type_section' => "Type of section",
    137         'tirant_eau_crit' => "Critical depth (m)",
    138     'tirant_eau_norm' => "Normal depth (m)",
    139     'tirant_eau_fluv' => "supercritical depth (m)",
    140     'tirant_eau_torr' => "subcritical depth (m)",
    141     'tirant_eau_conj' => "Conjugate depth (m)",
     140    'tirant_eau'        => "Draft (m)",
     141    'tirant_eau_conj'   => "Conjugate depth (m)",
     142    'tirant_eau_crit'   => "Critical depth (m)",
     143    'tirant_eau_fluv'   => "supercritical depth (m)",
     144    'tirant_eau_norm'   => "Normal depth (m)",
     145    'tirant_eau_torr'   => "subcritical depth (m)",
     146    'tuyau_lisse1'      => "Hydraulically smooth pipe - 0.05 &#8804; D &#8804; 0.2 ",
     147    'tuyau_lisse2'      => "Hydraulically smooth pipe - 0.25 &#8804; D &#8804; 1 ",
     148    'type_ecoulement'   => "Type of flow",
     149    'type_materiau'     => "Type of material",
     150    'type_section'      => "Type of section",
    142151    //V
    143     'valeur_positive' => "This value must be strictly positive",
    144     'valeur_positive_nulle' => "",
    145     'valeurs'         => "Valeurs",
    146     'val_min'         => "From minimum value",
    147     'val_max'         => "To maximum value",
    148     'vanne_rect'      => "Vanne Rectangulaire",
    149     'vanne_trap'      => "Vanne Trapézoïdale",
    150     'varier_val'      => "Parameter to vary ",
    151         'vit_moy'         => "Average speed (m/s)",
    152     'var_lin'         => "Linear variation of specific head (m/m)",
    153     'v_denoye'        => "Vanne dénoyé",
    154     'v_noye'          => "Vanne noyé",
     152    'valeurs'           => "Values",
     153    'val_min'           => "From minimum value",
     154    'val_max'           => "To maximum value",
     155    'vanne_circ'        => "Circular gate",
     156    'vanne_rect'        => "Rectangular gate",
     157    'vanne_trap'        => "Trapezoidal gate",
     158    'varier_val'        => "Parameter to vary ",
     159    'vit_moy'           => "Average speed (m/s)",
     160    'var_lin'           => "Linear variation of specific head (m/m)",
     161    'v_denoye'          => "Free flow gate",
     162    'v_noye'            => "Submerged flow gate",
    155163
    156164);
  • _plugins_/hydraulic/trunk/lang/hydraulic_fr.php

    r68484 r93248  
    33$GLOBALS[$GLOBALS['idx_lang']] = array(
    44    // A
    5     'abscisse'        => "Abscisse",
    6     'arret_calcul'    => "Arrêt du calcul : Hauteur critique atteinte à l'abscisse",
    7     'acier_lamine'    => "Acier laminé - Béton lisse",
    8     //
    9     'berge'           => "Berge",
     5    'abscisse'          => "Abscisse",
     6    'arret_calcul'      => "Arrêt du calcul : Hauteur critique atteinte à l'abscisse",
     7    'acier_lamine'      => "Acier laminé - Béton lisse",
     8    // B
     9    'berge'             => "Berge",
    1010    // C
    11     'calcul_caract'   => "Le calcul a les caractéristiques suivantes :",
    12     'calcul_remous'   => "Calcul d'une courbe de remous",
    13     'calculer_remous' => "Calculer la courbe de remous",
    14     'caract_bief'     => "Caractéristiques du bief",
    15     'coef_strickler'  => "Coefficient de Strickler (m<sup>1/3</sup>s<sup>-1</sup>)",
    16     'condition_limite'=> "Conditions aux limites",
    17     'calcul_fluvial'  => "Condition limite aval >= Hauteur critique : calcul de la partie fluviale à partir de l'aval",
    18     'calcul_torrentiel'=> "Condition limite amont <= Hauteur critique : calcul de la partie torrentielle à partir de l'amont",
    19     'champ_obligatoire'=> "Ce champ est obligatoire",
    20     'choix_materiau'  => "Choix du matériau",
    21     'caract'          => "Caractéristiques",
     11    'calcul_caract'     => "Le calcul a les caractéristiques suivantes :",
     12    'calcul_remous'     => "Calcul d'une courbe de remous",
     13    'calculer_remous'   => "Calculer la courbe de remous",
     14    'caract_bief'       => "Caractéristiques du bief",
     15    'coef_strickler'    => "Coefficient de Strickler (m<sup>1/3</sup>s<sup>-1</sup>)",
     16    'condition_limite'  => "Conditions aux limites",
     17    'calcul_fluvial'    => "Condition limite aval >= Hauteur critique : calcul de la partie fluviale à partir de l'aval",
     18    'calcul_torrentiel' => "Condition limite amont <= Hauteur critique : calcul de la partie torrentielle à partir de l'amont",
     19    'choix_materiau'    => "Choix du matériau",
     20    'caract'            => "Caractéristiques",
     21    'calculer'          => "Calculer",
    2222    'calculer_lechapt_calmon' => "Calcul avec la formule de Lechapt et Calmon",
    23     'calcul_val'      => "Paramètre à calculer",
    24     'choix_section'   => "Choix de la section",
    25     'caract_globale'  => "Caractéristiques globales",
    26     'charge_spe'      => "La charge spécifique (m)",
     23    'calcul_val'        => "Paramètre à calculer",
     24    'choix_section'     => "Choix du type de section",
     25    'caract_globale'    => "Caractéristiques globales",
     26    'charge_spe'        => "La charge spécifique (m)",
    2727    'choix_donnee_calc' => "Choix de la donnée à calculer",
    28     'charge_critique' => "La charge critique (m)",
    29     'cote_eau'        => "Cote de l'eau (m)",
    30     'coef'            => "Coefficient",
    31     'cunge'           => "Cunge 1980",
     28    'charge_critique'   => "La charge critique (m)",
     29    'cote_eau'          => "Cote de l'eau (m)",
     30    'coef'              => "Coefficient",
     31    'cunge'             => "Cunge 1980",
    3232    // D
    33     'debit_amont'     => "Débit amont (m<sup>3</sup>/s)",
    34     'def_section_trap'=> "Définition de la section trapézoïdale",
    35     'def_section_rect'=> "Définition de la section rectangulaire",
    36     'def_section_circ'=> "Définition de la section circulaire",
    37     'def_section_parab'=> "Définition de la section parabolique",
    38     'diametre'        => "Diamètre (m)",
    39     'donnee_calc'     => "Donnée à calculer",
    40     'debit'           => "Débit (m<sup>3</sup>/s)",
     33    'debit_amont'       => "Débit amont (m<sup>3</sup>/s)",
     34    'def_section_trap'  => "Définition de la section trapézoïdale",
     35    'def_section_rect'  => "Définition de la section rectangulaire",
     36    'def_section_circ'  => "Définition de la section circulaire",
     37    'def_section_parab' => "Définition de la section parabolique",
     38    'diametre'          => "Diamètre (m)",
     39    'donnee_calc'       => "Donnée à calculer",
     40    'debit'             => "Débit (m<sup>3</sup>/s)",
     41    // E
     42    'erreur_obligatoire' => "Ce champ est obligatoire",
     43    'erreur_non_numerique' => "La valeur doit être numérique",
     44    'erreur_val_positive' => "Cette valeur doit être strictement positive",
     45    'erreur_val_positive_nulle' => "Cette valeur doit être positive ou nulle",
    4146    // F
    4247    'flag_erreur_calcul'=> "Erreur de calcul",
    43     'flag_débit_nul'    => "Débit nul",
     48    'flag_debit_nul'    => "Débit nul",
    4449    'flag_libre_den'    => "Libre dénoyé",
    4550    'flag_libre_noy'    => "Libre noyé",
     
    4954    'flag_surverse_den' => "Surverse dénoyée",
    5055    'flag_surverse_noy' => "Surverse noyée",
    51     'fond'            => "Fond",
    52     'fruit'           => "Fruit des berges (m/m)",
    53     'fixer_val'       => "Paramètre fixé",
     56    'fond'              => "Fond",
     57    'fruit'             => "Fruit des berges (m/m)",
     58    'fixer_val'         => "Paramètre fixé",
    5459    'fonte_beton_corrosive' =>"Fonte ou acier non revêtus - Béton grossier (eau corrosive)",
    5560    'fonte_beton_ncorrosive' =>"Fonte ou acier non revêtus - Béton grossier (eau peu corrosive)",
     
    5762    'fonte_revt_bitume' => "Fonte ou acier revêtement bitume - Béton centrifugé",
    5863    'fonte_revt_centrifuge' => "Fonte ou acier revêtement centrifugé",
    59     'froud'           => "Le Froude",
    60     'force_tract'     => "La force tractrice (Pa)",
     64    'froud'             => "Le Froude",
     65    'force_tract'       => "La force tractrice (Pa)",
    6166    // H
    62     'h_amont_imposee' => "Hauteur d'eau imposée à l'amont (m)",
    63     'h_aval_imposee'  => "Hauteur d'eau aval imposée (m)",
    64     'h_berge'         => "Hauteur de berge (m)",
    65     'h_conjuguee'      => "Hauteur conjuguée",
    66     'h_critique'      => "Hauteur critique",
    67     'h_normale'       => "Hauteur normale",
    68     'h_pelle'         => "Hauteur de pelle (m)",
    69     //I
    70     'impulsion'       => "Impulsion (N)",
     67    'h_amont_imposee'   => "Tirant d'eau imposée à l'amont (m)",
     68    'h_aval_imposee'    => "Tirant d'eau imposée à l'aval (m)",
     69    'h_berge'           => "Hauteur de berge (m)",
     70    'h_conjuguee'       => "Hauteur conjuguée",
     71    'h_critique'        => "Tirant d'eau critique",
     72    'h_normale'         => "Tirant d'eau normale",
     73    'h_normale_pente_neg_nul' => "La pente est négative ou nulle, la hauteur normale est infinie",
     74    'h_pelle'           => "Hauteur de pelle (m)",
     75    // I
     76    'impulsion'         => "Impulsion (N)",
    7177    // L
    72     'largeur_fond'    => "Largeur au fond (m)",
    73     'largeur_berge'   => "Largeur au niveau des berges",
     78    'largeur_fond'      => "Largeur au fond (m)",
     79    'largeur_berge'     => "Largeur au niveau des berges",
    7480    'ligne_eau_fluviale'  => "Ligne d'eau fluviale",
    7581    'ligne_eau_torrentielle'  => "Ligne d'eau torrentielle",
    76     'log_titre'       => "Journal des calculs",
    77     'longueur_bief'   => "Longueur du bief (m)",
    78     'larg_miroir'     => "La largeur au miroir (m)",
    79     'loi_debit'       => "Loi de débit",
     82    'log_titre'         => "Journal des calculs",
     83    'longueur_bief'     => "Longueur du bief (m)",
     84    'larg_miroir'       => "La largeur au miroir (m)",
     85    'loi_debit'         => "Loi de débit",
    8086    // N
    8187    'newton_non_convergence' => "Non convergence du calcul (Méthode de Newton)",
     88    'non_calcule'       => "pas calculé",
    8289    // O
    83     'ordonnee'        => "Ordonnée",
    84     'or_cemagref88'   => "Déversoir/Orifice Cemagref 88",
    85     'or_cemagref02'   => "Déversoir/Orifice Cemagref 02",
     90    'ordonnee'          => "Ordonnée",
     91    'or_cemagref88'     => "Déversoir/Orifice Cemagref 88",
     92    'or_cemagref02'     => "Déversoir/Orifice Cemagref 02",
    8693    // P
    87     'param_calcul'    => "Paramètres de calcul",
    88     'param_fixes'     => "Paramètres fixés",
    89     'pas_ajustement'  => "ajustement du pas d'espace à ",
    90     'pas_discret'     => "Pas de discrétisation (m)",
    91     'pas_nombre'      => "Nombre de pas d'espace",
    92     'pente_fond'      => "Pente du fond (m/m)",
    93     'precision_calc'  => "Précision de calcul et d'affichage des cotes (m)",
     94    'param_calcul'      => "Paramètres de calcul",
     95    'param_fixes'       => "Paramètres fixés",
     96    'pas_ajustement'    => "ajustement du pas d'espace à ",
     97    'pas_discret'       => "Pas de discrétisation (m)",
     98    'pas_nombre'        => "Nombre de pas d'espace",
     99    'pente_fond'        => "Pente du fond (m/m)",
     100    'precision_calc'    => "Précision de calcul et d'affichage des cotes (m)",
    94101    'pas_calcul_depuis_aval' => "Condition limite aval < Hauteur critique : pas de calcul possible depuis l'aval",
    95102    'pas_calcul_depuis_amont' => "Condition limite amont > Hauteur critique : pas de calcul possible depuis l'amont",
    96     'pas_var'         => "Avec un pas de variation de",
    97     'pvc'             => "PVC - Polyéthylène",
    98     'param_Q'         => "Q: Débit (m³/s)",
    99     'param_D'         => "D: Diamètre du tuyau (m)",
    100     'param_J'         => "J: Perte de charge (m)",
    101     'param_Lg'        => "Lg: Longueur du tuyau (m)",
    102     'param_L'         => "Largeur (m)",
    103     'param_W'         => "Ouverture (m)",
    104     'param_C'         => "Coefficient de débit",
    105     'param_CS'        => "Coefficient de débit de la surverse",
    106     'param_H'         => "Hauteur de la pelle (surverse)",
    107     'param_LF'        => "Largeur au fond (m)",
    108     'param_CR'        => "Coefficient de débit partie rectangulaire",
    109     'param_CR'        => "Coefficient de débit partie triangulaire",
    110     'param_F'     => "Fruit (m/m)",
    111     'param_ZM'        => "Cote de l'eau à l'amont (m)",
    112     'param_ZV'        => "Côte de l'eau à l'aval (m)",
    113     'precision'  => "Précision de calcul(m)",
    114     'perim_mouille'   => "Le périmètre mouillé (m)",
    115     'perte_charge'    => "La perte de charge (m/m)",
     103    'pas_var'           => "Avec un pas de variation de",
     104    'pvc'               => "PVC - Polyéthylène",
     105    'param_Q'           => "Q: Débit (m³/s)",
     106    'param_D'           => "D: Diamètre du tuyau (m)",
     107    'param_J'           => "J: Perte de charge (m)",
     108    'param_Lg'          => "Lg: Longueur du tuyau (m)",
     109    'param_L'           => "Largeur (m)",
     110    'param_W'           => "Ouverture (m)",
     111    'param_C'           => "Coefficient de débit",
     112    'param_CS'          => "Coefficient de débit de la surverse",
     113    'param_H'           => "Hauteur de la pelle (surverse)",
     114    'param_LF'          => "Largeur au fond (m)",
     115    'param_CR'          => "Coefficient de débit partie rectangulaire",
     116    'param_CT'          => "Coefficient de débit partie triangulaire",
     117    'param_F'           => "Fruit (m/m)",
     118    'param_ZM'          => "Cote de l'eau à l'amont (m)",
     119    'param_ZV'          => "Côte de l'eau à l'aval (m)",
     120    'precision'         => "Précision de calcul(m)",
     121    'perim_mouille'     => "Le périmètre mouillé (m)",
     122    'perte_charge'      => "La perte de charge (m/m)",
    116123    //R
    117     'rayon_hyd'       => "Le rayon hydraulique (m)",
    118     'rugosite_nc'     => "Rugosité (Strickler en m<sup>1/3</sup>s<sup>-1</sup>)",
     124    'rayon_hyd'         => "Le rayon hydraulique (m)",
     125    'rugosite_nc'       => "Rugosité (Strickler en m<sup>1/3</sup>s<sup>-1</sup>)",
    119126    //S
    120     'saisie_erreur'   => "Votre saisie contient des erreurs !",
    121     'section_trap'    => "Section Trapézoïdale",
    122     'section_rect'    => "Section Rectangulaire",
    123     'section_circ'    => "Section Circulaire",
    124     'section_parab'   => "Section Parabolique",
    125     'seuil_rect'      => "Seuil Rectangulaire",
    126     'seuil_trap'      => "Seuil Trapézoïdal",
    127     'surf_mouille'    => "La surface mouillée (m<sup>2</sup>)",
    128     's_cemagref88'    => "Vanne de fond/Seuil Cemagref 88",
    129     's_denoye'        => "Seuil dénoyé",
    130     's_noye'          => "Seuil noyé",
    131     's_cemagref02'    => "Vanne de fond/Seuil Cemagref 02",
     127    'saisie_erreur'     => "Votre saisie contient des erreurs !",
     128    'section_trap'      => "Trapézoïdale",
     129    'section_rect'      => "Rectangulaire",
     130    'section_circ'      => "Circulaire",
     131    'section_parab'     => "Parabolique",
     132    'seuil_rect'        => "Seuil Rectangulaire",
     133    'seuil_trap'        => "Seuil Trapézoïdal",
     134    'surf_mouille'      => "La surface mouillée (m<sup>2</sup>)",
     135    's_cemagref88'      => "Vanne de fond/Seuil Cemagref 88",
     136    's_denoye'          => "Seuil dénoyé",
     137    's_noye'            => "Seuil noyé",
     138    's_cemagref02'      => "Vanne de fond/Seuil Cemagref 02",
    132139    //T
    133     'tirant_eau'      => "Tirant d'eau (m)",
    134     'tuyau_lisse1'    => "Tuyau hydrauliquement lisse - 0.05 ≤ D ≤ 0.2",
    135     'tuyau_lisse2'    => "Tuyau hydrauliquement lisse - 0.25 ≤ D ≤ 1",
    136     'tirant_eau_crit' => "Le tirant d'eau critique (m)",
    137     'tirant_eau_norm' => "Le tirant d'eau normal (m)",
    138     'tirant_eau_fluv' => "Le tirant d'eau fluvial (m)",
    139     'tirant_eau_torr' => "Le tirant d'eau torrentiel (m)",
    140     'tirant_eau_conj' => "Le tirant d'eau conjugué (m)",
     140    'tirant_eau'        => "Tirant d'eau (m)",
     141    'tirant_eau_conj'   => "Le tirant d'eau conjugué (m)",
     142    'tirant_eau_crit'   => "Le tirant d'eau critique (m)",
     143    'tirant_eau_fluv'   => "Le tirant d'eau fluvial (m)",
     144    'tirant_eau_norm'   => "Le tirant d'eau normal (m)",
     145    'tirant_eau_torr'   => "Le tirant d'eau torrentiel (m)",
     146    'tuyau_lisse1'      => "Tuyau hydrauliquement lisse - 0.05 ≤ D ≤ 0.2",
     147    'tuyau_lisse2'      => "Tuyau hydrauliquement lisse - 0.25 ≤ D ≤ 1",
    141148    'type_ecoulement'   => "Type de l'écoulement",
    142     'type_materiau'   => "Type du matériau",
    143     'type_section'    => "Type de section",
     149    'type_materiau'     => "Type du matériau",
     150    'type_section'      => "Type de section",
    144151    //V
    145     'valeur_positive' => "Cette valeur doit être strictement positive",
    146     'valeur_positive_nulle' => "Cette valeur doit être positive ou nulle",
    147     'valeurs'         => "Valeurs",
    148     'val_min'         => "De la valeur minimum",
    149     'val_max'         => "A la valeur maximum",
    150     'val_min'         => "De la Valeur minimum",
    151     'vanne_circ'      => "Vanne Circulaire",
    152     'vanne_rect'      => "Vanne Rectangulaire",
    153     'vanne_trap'      => "Vanne Trapézoïdale",
    154     'varier_val'      => "Paramètre à varier",
    155     'vit_moy'         => "La vitesse moyenne (m/s)",
    156     'var_lin'         => "Variation linéaire de l'énergie spécifique (m/m)",
    157     'v_denoye'        => "Vanne dénoyé",
    158     'v_noye'          => "Vanne noyé",
     152    'valeurs'           => "Valeurs",
     153    'val_min'           => "De la valeur minimum",
     154    'val_max'           => "A la valeur maximum",
     155    'vanne_circ'        => "Vanne Circulaire",
     156    'vanne_rect'        => "Vanne Rectangulaire",
     157    'vanne_trap'        => "Vanne Trapézoïdale",
     158    'varier_val'        => "Paramètre à varier",
     159    'vit_moy'           => "La vitesse moyenne (m/s)",
     160    'var_lin'           => "Variation linéaire de l'énergie spécifique (m/m)",
     161    'v_denoye'          => "Vanne dénoyé",
     162    'v_noye'            => "Vanne noyé",
    159163
    160164);
  • _plugins_/hydraulic/trunk/plugin.xml

    r89778 r93248  
    55    <auteur>David Dorchies, Médéric Dulondel</auteur>
    66    <licence>GNU/GLP</licence>
    7     <version>0.7.0</version>
     7    <version>0.7.1</version>
    88    <necessite id="lib:dist" src="https://bitbucket.org/cleonello/jqplot/downloads/jquery.jqplot.1.0.8r1250.zip" />
    99    <slogan>
Note: See TracChangeset for help on using the changeset viewer.