Changeset 59892 in spip-zone


Ignore:
Timestamp:
Mar 28, 2012, 7:20:24 PM (8 years ago)
Author:
dorch@…
Message:

Merge actual branche v0.3 into trunk

Location:
_plugins_/hydraulic/trunk
Files:
2 deleted
9 edited
11 copied

Legend:

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

    r56971 r59892  
    11[<div class='hyd_formulaire_erreur '><span>(#ENV*{message_erreur})</span></div>]
    2 <form method="post" action="#ENV{action}">
     2
     3<script language="javascript" type="text/javascript" src="#CHEMIN{js/hyd_fonctions.js}"></script>
     4<script>
     5//Permet d'afficher ou cacher les champs correspondant à une section.
     6function afficher_cacher() {
     7
     8   var section = getSelectValue('choix_section');
     9    var f = document.getElementById("form_courbe_remous");
     10    if(f) {
     11       var champs = f.getElementsByTagName("tr");
     12       for(var i=0, n=champs.length; i<n; i++) {
     13
     14
     15          if((champs[i].getAttribute("id") != null) &&((champs[i].getAttribute("id")).substr(0,2) == section)){
     16            document.getElementById((champs[i].getAttribute("id"))).style.display='table-row';
     17
     18        }
     19        else if((champs[i].getAttribute("id") != null) &&((champs[i].getAttribute("id")).substr(0,1) == 'F')) {
     20            document.getElementById((champs[i].getAttribute("id"))).style.display='none';
     21
     22       }
     23
     24      }
     25    }
     26
     27}
     28</script>
     29
     30<form method="post" action="#ENV{action}" id="form_courbe_remous">
    331   #ACTION_FORMULAIRE{#ENV{action}}
    432   <table class="hyd_formulaire">
    533      <tbody>
    6          <tr><td colspan="2"><div class="hyd_formulaire_chapitre"><:hydraulic:def_section_trap:></div></td></tr>
    7          <tr>
    8             <td align="right">
    9                <:hydraulic:largeur_fond:> :
    10             </td>
    11             <td>
    12                <input type="text" value="#ENV{rLarg}" maxlength="30" name="rLarg">
    13                [<div class='hyd_erreur'>(#ENV**{erreurs}|table_valeur{rLarg})</div>]
    14             </td>
     34         <tr id="type_section_field">
     35            <td colspan="2"><div class="hyd_formulaire_chapitre"><:hydraulic:type_section:></div></td>
    1536         </tr>
    16          <tr>
    17             <td align="right">
    18                <:hydraulic:fruit:> :
    19             </td>
    20             <td>
    21                <input type="text" value="#ENV{rFruit}" maxlength="30" name="rFruit">
    22                [<div class='hyd_erreur'>(#ENV**{erreurs}|table_valeur{rFruit})</div>]
    23             </td>
    24          </tr>
    25          <tr><td colspan="2"><div class="hyd_formulaire_chapitre"><:hydraulic:caract_bief:></div></td></tr>
    26          <tr>
    27             <td align="right"><:hydraulic:coef_strickler:> :</td>
    28             <td>
    29                <input type="text" value="#ENV{rKs}" maxlength="30" name="rKs">
    30                [<div class='hyd_erreur'>(#ENV**{erreurs}|table_valeur{rKs})</div>]
    31             </td>
    32          </tr>
    33          <tr>
    34             <td align="right"><:hydraulic:longueur_bief:> :</td>
    35             <td><input type="text" value="#ENV{rLong}" maxlength="30" name="rLong"></td>
    36                [<div class='hyd_erreur'>(#ENV**{erreurs}|table_valeur{rLong})</div>]
    37          </tr>
    38          <tr>
    39             <td align="right"><:hydraulic:pente_fond:> :</td>
    40             <td><input type="text" value="#ENV{rIf}" maxlength="30" name="rIf"></td>
    41                [<div class='hyd_erreur'>(#ENV**{erreurs}|table_valeur{rIf})</div>]
    42          </tr>
    43          <tr><td colspan="2"><div class="hyd_formulaire_chapitre"><:hydraulic:condition_limite:></div></td></tr>
    44          <tr>
    45             <td align="right"><:hydraulic:debit_amont:> :</td>
    46             <td><input type="text" value="#ENV{rQ}" maxlength="30" name="rQ"></td>
    47                [<div class='hyd_erreur'>(#ENV**{erreurs}|table_valeur{rQ})</div>]
    48          </tr>
    49          <tr>
    50             <td align="right"><:hydraulic:h_aval_imposee:> :</td>
    51             <td>
    52                <input type="text" value="#ENV{rYaval}" maxlength="30" name="rYaval">
    53                [<div class='hyd_erreur'>(#ENV**{erreurs}|table_valeur{rYaval})</div>]
    54             </td>
    55          </tr>
    56          <tr>
    57             <td align="right"><:hydraulic:h_amont_imposee:> :</td>
    58             <td>
    59                <input type="text" value="#ENV{rYamont}" maxlength="30" name="rYamont">
    60                [<div class='hyd_erreur'>(#ENV**{erreurs}|table_valeur{rYamont})</div>]
    61             </td>
    62          </tr>
    63          <tr><td colspan="2"><div class="hyd_formulaire_chapitre"><:hydraulic:param_calcul:></div></td></tr>
    64          <tr>
    65             <td align="right"><:hydraulic:pas_discret:> :</td>
    66             <td><input type="text" value="#ENV{rDx}" maxlength="30" name="rDx"></td>
    67                [<div class='hyd_erreur'>(#ENV**{erreurs}|table_valeur{rDx})</div>]
    68          </tr>
    69          <tr>
    70             <td align="right"><:hydraulic:precision_calc:> :</td>
    71             <td><input type="text" value="#ENV{rPrec}" maxlength="30" name="rPrec"></td>
    72                [<div class='hyd_erreur'>(#ENV**{erreurs}|table_valeur{rPrec})</div>]
    73          </tr>
     37
     38                        <tr id="type_section_choix">
     39                                <td align="right">
     40                                        <:hydraulic:choix_section:> :
     41                                </td>                                   
     42
     43                                <td>
     44                                        <select name="lTypeSection" id="choix_section" 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{lTypeSection}|=={#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>
     57
     58            <BOUCLE_fieldChamps(POUR){tableau #ENV{mes_saisies}}>
     59
     60                                 #SET{id_fieldset, #CLE}
     61                               
     62                                 <tr id="#GET{id_fieldset}_field" style="display:[(#CLE|match{^([(#ENV{lTypeSection})]|Caract_bief|Cond_lim|Param_calc)$}|?{'table-row','none'})];">   
     63                                         <td colspan="2"><div class="hyd_formulaire_chapitre">[(#VALEUR|table_valeur{0}|traduction_hydraulic)]</div></td>
     64                                </tr>
     65                               
     66                                <BOUCLE_champsLib(POUR){tableau (#VALEUR|table_valeur{1})}>
     67                                                                               
     68                                        <tr id="#GET{id_fieldset}_#CLE" style="display:[(#GET{id_fieldset}|match{^([(#ENV{lTypeSection})]|Caract_bief|Cond_lim|Param_calc)$}|?{'table-row','none'})];">
     69                                                <td align="right" width="65%">
     70                                                        [(#VALEUR|table_valeur{0}|traduction_hydraulic)] :     
     71                                                </td>
     72                                               
     73                                                <td width="35%">
     74                                                   <input type="text" value="[(#ENV{#GET{id_fieldset}_#CLE})]" maxlength="30" name="#GET{id_fieldset}_#CLE">
     75                                                   [<div class='hyd_erreur'>(#ENV**{erreurs}|table_valeur{#GET{id_fieldset}_#CLE})</div>]
     76                                                </td>
     77                                               
     78                                        </tr>
     79                                       
     80                                </BOUCLE_champsLib>
     81
     82                        </BOUCLE_fieldChamps>
    7483
    7584         <tr>
    7685            <td colspan="2" class="hyd_bouton_submit">
    77                <input type="submit" value=" <:hydraulic:calculer_remous:>">
    78                </td>
     86               <input type="submit" value="<:hydraulic:calculer_remous:>">
     87            </td>
    7988         </tr>
     89
    8090      </tbody>
    8191   </table>
  • _plugins_/hydraulic/trunk/formulaires/courbe_remous.php

    r56971 r59892  
    11<?php
    22/*
    3  * formulaire/courbe_remous.php
     3 * formulaires/courbe_remous.php
    44 *
    55 *
     
    3939 */
    4040
     41include_spip('hyd_inc/section');
     42
     43function mes_saisies_section() {
     44
     45    $fieldset_champs = caract_communes();
     46
     47    $fieldset_champs['Caract_bief'] = array(
     48                                                                                   'caract_bief',
     49                                                                                   array(
     50                                                                                                 'rKs'    =>array('coef_strickler',50),
     51                                                                                                 'rLong'  =>array('longueur_bief', 50),
     52                                                                                                 'rIf'    =>array('pente_fond', 0.005),
     53                                                                                                 'rYBerge'=>array('h_berge',1)
     54                                                                                                )
     55                                                                           );
     56
     57        $fieldset_champs['Cond_lim']    = array(
     58                                                                                   'condition_limite',
     59                                                                                   array(
     60                                                                                                 'rQ'     =>array('debit_amont', 2),
     61                                                                                                 'rYaval' =>array('h_aval_imposee', 0.6),
     62                                                                                                 'rYamont'=>array('h_amont_imposee', 0.15)
     63                                                                                                )
     64                                                                           );
     65
     66        $fieldset_champs['Param_calc']  = array(
     67                                                                                   'param_calcul',
     68                                                                                   array(
     69                                                                                                 'rDx'    =>array('pas_discret', 5),
     70                                                                                                 'rPrec'  =>array('precision_calc', 0.001)
     71                                                                                                )
     72                                                                           );   
     73               
     74  return $fieldset_champs;
     75
     76}
     77
     78function champs_obligatoires() {
     79
     80    $tSaisie = mes_saisies_section();
     81    $tChOblig = array();
     82    $sTypeSection = _request('lTypeSection');
     83
     84    foreach($tSaisie as $IdFS=>$FieldSet) {
     85        if((substr($IdFS,0,1) != 'F') || ($IdFS == $sTypeSection)){
     86            foreach($FieldSet[1] as $Cle=>$Champ) {
     87                if((!isset($Champ[2])) || (isset($Champ[2]) && $Champ[2])) {
     88                    $tChOblig[] = $IdFS.'_'.$Cle;
     89                }
     90            }
     91        }
     92    }
     93    return $tChOblig;
     94}
     95
    4196function formulaires_courbe_remous_charger_dist() {
     97    // On charge les saisies et les champs qui nécessitent un accès par les fonctions
     98    $tSaisie_section = mes_saisies_section();
    4299    $valeurs = array(
    43         'rLarg'=>2.5,
    44         'rFruit'=>0.56,
    45         'rYaval'=>0.6,
    46         'rYamont'=>0.15,
    47         'rKs'=>50,
    48         'rQ'=>2,
    49         'rLong'=>50,
    50         'rIf'=>0.005,
    51         'rDx'=>5,
    52         'rPrec'=>0.001);
     100        'lTypeSection' => 'FT',
     101        'mes_saisies' => $tSaisie_section
     102    );
     103
     104    foreach($tSaisie_section as $CleFD=>$FieldSet) {
     105        foreach($FieldSet[1] as $Cle=>$Champ) {
     106                $valeurs[$CleFD.'_'.$Cle] = $Champ[1];
     107        }
     108    }
    53109
    54110    return $valeurs;
     
    56112
    57113function formulaires_courbe_remous_verifier_dist(){
     114
     115
    58116    $erreurs = array();
    59117    $datas = array();
     118
     119    $tChOblig= champs_obligatoires();
    60120    // verifier que les champs obligatoires sont bien là :
    61     foreach(array('rLarg','rYaval','rYamont','rKs','rQ','rLong','rIf','rDx','rPrec') as $obligatoire) {
     121    foreach($tChOblig as $obligatoire) {
    62122        if (!_request($obligatoire)) {
    63123            $erreurs[$obligatoire] = _T('hydraulic:champ_obligatoire');}
     
    74134        $erreurs['message_erreur'] = _T('hydraulic:saisie_erreur');
    75135    }
     136
    76137    return $erreurs;
    77138}
     
    79140function formulaires_courbe_remous_traiter_dist(){
    80141    global $spip_lang;
    81 /*
    82 $fdbg = fopen('debug.log','w');
    83 */
    84142    include_spip('hyd_inc/section.class');
    85143    include_spip('hyd_inc/cache');
    86144    include_spip('hyd_inc/log.class');
    87     include_spip('hyd_inc/calcul');
     145    include_spip('hyd_inc/courbe_remous');
    88146    include_spip('hyd_inc/graph.class');
    89147
    90148    $datas = array();
    91149    $echo = '';
    92     // On récupère les données
    93     foreach(array('rLarg','rFruit','rYaval','rYamont','rKs','rQ','rLong','rIf','rDx','rPrec') as $champ) {
    94         if (_request($champ)) $datas[$champ] = _request($champ);
     150    $tSaisie = mes_saisies_section();
     151    $tChUtil = array();
     152    $lTypeSection = _request('lTypeSection');
     153
     154    foreach($tSaisie as $IdFS=>$FieldSet) {
     155        if((substr($IdFS,0,1) != 'F') || ($IdFS == $lTypeSection)){
     156            foreach($FieldSet[1] as $Cle=>$Champ) {
     157                    $tChUtil[] = $IdFS.'_'.$Cle;
     158            }
     159        }
     160    }
     161
     162    //On récupère les données
     163    foreach($tChUtil as $champ) {
     164        if (_request($champ)){
     165            $datas[$champ] = _request($champ);
     166        }
     167
    95168        $datas[$champ] = str_replace(',','.',$datas[$champ]); // Bug #574
    96169    }
     
    110183    }
    111184
    112     // Initialisation du format d'affichage des réels
    113     $iPrec=(int)-log10($rPrec);
    114 
    115185    // Contrôle du nombre de pas d'espace maximum
    116186    $iPasMax = 1000;
    117     if($rLong / $rDx > $iPasMax) {
    118         $rDx = $rLong / $iPasMax;
    119         $oLog->Add(_T('hydraulic:pas_nombre').' > '.$iPasMax.' => '._T('hydraulic:pas_ajustement').$rDx.' m');
    120     }
     187    if($Caract_bief_rLong / $Param_calc_rDx > $iPasMax) {
     188        $Param_calc_rDx = $Caract_bief_rLong / $iPasMax;
     189        $oLog->Add(_T('hydraulic:pas_nombre').' > '.$iPasMax.' => '._T('hydraulic:pas_ajustement').$Param_calc_rDx.' m');
     190    }
     191    //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');
    121192
    122193    // Enregistrement des paramètres dans les classes qui vont bien
    123     $oParam= new cParam($rYaval,$rKs,$rQ,$rLong,$rIf,$rDx,$rPrec);
    124     $oSection=new cSnTrapeze($oParam,$rLarg,$rFruit);
    125 
     194    $oParam= new cParam($Cond_lim_rYaval,$Caract_bief_rKs,$Cond_lim_rQ,$Caract_bief_rLong,$Caract_bief_rIf,$Param_calc_rDx,$Param_calc_rPrec,$Caract_bief_rYBerge);
     195
     196    switch($lTypeSection) {
     197        case 'FT':
     198            include_spip('hyd_inc/sectionTrapez.class');
     199            $oSection=new cSnTrapez($oLog,$oParam,$FT_rLarg,$FT_rFruit);
     200            break;
     201
     202        case 'FR':
     203            include_spip('hyd_inc/sectionRectang.class');
     204            $oSection=new cSnRectang($oLog,$oParam,$FR_rLarg);
     205            break;
     206
     207        case 'FC':
     208            include_spip('hyd_inc/sectionCirc.class');
     209            $oSection=new cSnCirc($oLog,$oParam,$FC_rDiam);
     210            break;
     211
     212        case 'FP':
     213            echo 'puissance';
     214
     215        default:
     216            include_spip('hyd_inc/sectionTrapez.class.php');
     217            $oSection=new cSnTrapeze($oLog,$oParam,$FT_rLarg,$FT_rFruit);
     218    }
    126219
    127220    /***************************************************************************
    128221    *                        Calcul de la ligne d'eau
    129222    ****************************************************************************/
    130     if(is_file(HYD_CACHE_DIRECTORY.$CacheFileName)) {
     223    $bNoCache = false; // true pour débugage
     224    if(!$bNoCache && is_file(HYD_CACHE_DIRECTORY.$CacheFileName)) {
    131225        // On récupère toutes les données dans un cache déjà créé
    132         list($tr,$sLog) = ReadCacheFile($CacheFileName);
     226        list($tr,$sLog,$oSection->rHautCritique,$oSection->rHautNormale) = ReadCacheFile($CacheFileName);
    133227    }
    134228    else {
    135229        // On calcule les données pour créer un cache et afficher le résultat
    136         $oLog->Add(_T('hydraulic:h_critique').' = '.format_nombre($oSection->rHautCritique,$iPrec).' m');
    137         $oLog->Add(_T('hydraulic:h_normale').' = '.format_nombre($oSection->rHautNormale,$iPrec).' m');
     230        $oLog->Add(_T('hydraulic:largeur_berge').' = '.format_nombre($oSection->rLargeurBerge,$oParam->iPrec).' m');
     231        $oLog->Add(_T('hydraulic:h_critique').' = '.format_nombre($oSection->CalcGeo('Yc'),$oParam->iPrec).' m');
     232        $oLog->Add(_T('hydraulic:h_normale').' = '.format_nombre($oSection->CalcGeo('Yn'),$oParam->iPrec).' m');
    138233
    139234        // Calcul depuis l'aval
    140         if($oSection->rHautCritique <= $rYaval) {
     235        if($oSection->rHautCritique <= $Cond_lim_rYaval) {
    141236            $oLog->Add(_T('hydraulic:calcul_fluvial'));
    142             list($tr['X1'],$tr['Y1']) = calcul_courbe_remous($oParam,$oSection,$oLog,$iPrec);
     237            list($tr['X1'],$tr['Y1']) = calcul_courbe_remous($oParam,$oSection,$oLog,$oParam->iPrec);
    143238        }
    144239        else {
     
    147242
    148243        // Calcul depuis l'amont
    149         if($oSection->rHautCritique >= $rYamont) {
     244        if($oSection->rHautCritique >= $Cond_lim_rYamont) {
    150245            $oLog->Add(_T('hydraulic:calcul_torrentiel'));
    151             $oParam->rYCL = $rYamont; // Condition limite amont
     246            $oParam->rYCL = $Cond_lim_rYamont; // Condition limite amont
    152247            $oParam->rDx = -$oParam->rDx; // un pas négatif force le calcul à partir de l'amont
    153             list($tr['X2'],$tr['Y2']) = calcul_courbe_remous($oParam,$oSection,$oLog,$iPrec);
     248            list($tr['X2'],$tr['Y2']) = calcul_courbe_remous($oParam,$oSection,$oLog,$oParam->iPrec);
    154249        }
    155250        else {
     
    160255        $sLog = $oLog->Result();
    161256        //Enregistrement des données dans fichier cache
    162         WriteCacheFile($CacheFileName,array($tr,$sLog));
     257        WriteCacheFile($CacheFileName,array($tr,$sLog,$oSection->rHautCritique,$oSection->rHautNormale));
    163258    }
    164259    //Construction d'un tableau des indices x combinant les abscisses des 2 lignes d'eau
     
    175270    ****************************************************************************/
    176271    $oGraph = new cGraph();
    177     // Ligne d'eau fluviale
     272    // Cote des berges
     273    $oGraph->AddSerie(
     274        'berge',
     275        $trX,
     276        $oParam->rYB,  // La cote des berges sera calculée à partir de la pente fournie dans GetGraph
     277        '#C58f50',
     278        'lineWidth:1');
     279    // Cote du fond
     280    $oGraph->AddSerie(
     281        'fond',
     282        $trX,
     283        0,  // La cote du fond sera calculée à partir de la pente fournie dans GetGraph
     284        '#753f00',
     285        'lineWidth:1, fill:true');
     286   // Ligne d'eau fluviale
    178287    if(isset($tr['Y1'])) {
    179288        $oGraph->AddSerie(
     
    181290            $tr['X1'],
    182291            $tr['Y1'],
    183             '#00a3cd',
     292            '#0093bd',
    184293            'lineWidth:3, showMarker:true, markerOptions:{style:\'filledCircle\', size:8}');
    185294    }
     
    193302            'lineWidth:3, showMarker:true, markerOptions:{style:\'filledCircle\', size:8}');
    194303    }
    195     // Cote du fond
    196     $oGraph->AddSerie(
    197         'fond',
    198         $trX,
    199         0,  // La cote du fond sera calculée à partir de la pente fournie dans GetGraph
    200         '#753f00',
    201         'lineWidth:1, fill:true');
    202304    // Hauteur critique
    203305    $oGraph->AddSerie(
     
    206308        $oSection->rHautCritique,  // La cote du fond sera calculée à partir de la pente fournie dans GetGraph
    207309        '#ff0000',
    208         'lineWidth:1');
     310        'lineWidth:2');
    209311    // Hauteur normale
    210312    $oGraph->AddSerie(
     
    213315        $oSection->rHautNormale,  // La cote du fond sera calculée à partir de la pente fournie dans GetGraph
    214316        '#a4c537',
    215         'lineWidth:1');
     317        'lineWidth:2');
    216318
    217319    // Décalage des données par rapport au fond
    218     $oGraph->Decal(0, $rIf, $rLong);
     320    $oGraph->Decal(0, $Caract_bief_rIf, $Caract_bief_rLong);
    219321
    220322    // Récupération du graphique
     
    245347    foreach($trX as $rX) {
    246348        $i+=1;
    247         $echo.='<tr class="';
     349        $echo.='<tr class="align_right ';
    248350        $echo.=($i%2==0)?'row_even':'row_odd';
    249         $echo.='"><td>'.format_nombre($rX,$iPrec).'</td>';
     351        $echo.='"><td>'.format_nombre($rX,$oParam->iPrec).'</td>';
    250352        if(isset($tr['X1']) && !(($cle = array_search($rX,$tr['X1'])) === false)) {
    251             $echo .= '<td>'.format_nombre($tr['Y1'][$cle],$iPrec).'</td>';
    252             $echo .= '<td>'.format_nombre($oSection->ReCalcFr($oParam, $tr['Y1'][$cle]),$iPrec).'</td>';
     353            $echo .= '<td>'.format_nombre($tr['Y1'][$cle],$oParam->iPrec).'</td>';
     354            $echo .= '<td>'.format_nombre($oSection->Calc('Fr', $tr['Y1'][$cle]),$oParam->iPrec).'</td>';
    253355        }
    254356        else {
     
    256358        }
    257359        if(isset($tr['X2']) && !(($cle = array_search($rX,$tr['X2'])) === false)) {
    258             $echo .= '<td>'.format_nombre($tr['Y2'][$cle],$iPrec).'</td>';
    259             $echo .= '<td>'.format_nombre($oSection->ReCalcFr($oParam, $tr['Y2'][$cle]),$iPrec).'</td>';
     360            $echo .= '<td>'.format_nombre($tr['Y2'][$cle],$oParam->iPrec).'</td>';
     361            $echo .= '<td>'.format_nombre($oSection->Calc('Fr', $tr['Y2'][$cle]),$oParam->iPrec).'</td>';
    260362        }
    261363        else {
  • _plugins_/hydraulic/trunk/hyd_inc

    • Property svn:ignore set to
      *.bat
  • _plugins_/hydraulic/trunk/hyd_inc/newton.class.php

    r56649 r59892  
    4242*/
    4343abstract class acNewton {
    44    protected $rTol;
    45    protected $rDx;
    46    private $iCpt=0;
    47    private $iCptMax=50;
     44    protected $rTol;
     45    protected $rDx;
     46    private $iCpt=0;
     47    private $iCptMax=100;
     48    private $rRelax=1; /// Coefficient de relaxation
     49    private $rFnPrec=0; /// Mémorisation du Fn précédent pour détecter le changement de signe
     50    private $iOscil=0; /// Nombre de changement de signe de Delta
     51    private $oLog;
    4852
    49    abstract public function CalcFn($rX);
     53    /**
     54     * Calcul de la fonction f(x) dont on cherche le zéro.
     55     * @param $rX x
     56     * @return Calcul de la fonction
     57     */
     58    abstract protected function CalcFn($rX);
    5059
    51    private function CalcDer($x) {
    52       return ($this->CalcFn($x+$this->rDx)-$this->CalcFn($x-$this->rDx))/(2*$this->rDx);
    53    }
     60    /**
     61     * Calcul de la dérivée f'(x) (peut être redéfini pour calcul analytique)
     62     * @param $rX x
     63     * @return Calcul de la fonction
     64     */
     65    protected function CalcDer($x) {
     66        spip_log('Newton:CalcDer $rX='.$x,'hydraulic');
     67        return ($this->CalcFn($x+$this->rDx)-$this->CalcFn($x-$this->rDx))/(2*$this->rDx);
     68    }
    5469
    55    private function FuzzyEqual($rFn) {
    56       return (abs($rFn) < $this->rTol);
    57    }
     70    /**
     71     * Test d'égalité à une tolérance près
     72     * @param $rFn x
     73     * @return True si égal, False sinon
     74     */
     75    private function FuzzyEqual($rFn) {
     76        return (abs($rFn) < $this->rTol);
     77    }
    5878
    59    public function Newton($rX) {
    60       $this->iCpt++;
    61       $rFn=$this->CalcFn($rX);
    62       //echo $this->iCpt.' - f('.$rX.') = '.$rFn;
    63       if($this->FuzzyEqual($rFn) || $this->iCpt >= $this->iCptMax) {
    64          return $rX;
    65       }
    66       else {
    67          $rDer=$this->CalcDer($rX);
    68          //echo ' - f\\\' = '.$rDer.'<br/>';
    69          if($rDer!=0) {
    70             return $this->Newton($rX-$rFn/$rDer);
    71          }
    72       }
    73    }
     79    /**
     80     * Fonction récursive de calcul de la suite du Newton
     81     * @param $rX x
     82     * @return Solution du zéro de la fonction
     83     */
     84    public function Newton($rX) {
     85        $this->iCpt++;
     86        $rFn=$this->CalcFn($rX);
     87        //echo('</br>Newton '.$this->iCpt.' Relax='.$this->rRelax.'- f('.$rX.') = '.$rFn);
     88        if($this->FuzzyEqual($rFn) || $this->iCpt >= $this->iCptMax) {
     89            return $rX;
     90        }
     91        else {
     92            $rDer=$this->CalcDer($rX);
     93            //echo(' - f\' = '.$rDer);
     94            if($rDer!=0) {
     95/*
     96                if($this->rRelax > 1) {
     97                    // On réduit progressivement le coef de relaxation
     98                    $this->rRelax *= 1;
     99                }
     100*/
     101                if($rFn < 0 xor $this->rFnPrec < 0) {
     102                    $this->nOscil++;
     103                    if($this->rRelax > 1) {
     104                        // Sur une forte relaxation, au changement de signe on réinitialise
     105                        $this->rRelax = 1;
     106                    }
     107                    elseif($this->nOscil>2) {
     108                        // On est dans le cas d'une oscillation autour de la solution
     109                        // On réduit le coefficient de relaxation
     110                        //~ echo '</br> ******  Delta='.$Delta.' DeltaPrec='.$this->rDelta;
     111                        $this->rRelax *= 0.5;
     112                    }
     113                }
     114                $this->rFnPrec = $rFn;
     115                $Delta = $rFn / $rDer;
     116                while(abs($Delta*$this->rRelax) < $this->rTol && $rFn > 10*$this->rTol && $this->rRelax < 2^8) {
     117                    // On augmente le coefficicient de relaxation s'il est trop petit
     118                    $this->rRelax *= 2;
     119                }
     120                $rRelax = $this->rRelax;
     121                while($rX - $Delta*$rRelax <= 0 && $rRelax > 1E-4) {
     122                    // On diminue le coeficient de relaxation si on passe en négatif
     123                    $rRelax *= 0.5; // Mais on ne le mémorise pas pour les itérations suivantes
     124                }
     125                $rX = $rX - $Delta*$rRelax;
     126                $this->rDelta = $Delta;
     127                if($rX<0) {$rX = $this->rTol;} // Aucune valeur recherchée ne peut être négative ou nulle
     128                return $this->Newton($rX);
     129            }
     130            else {
     131                // Echec de la résolution
     132                return false;
     133            }
     134        }
     135    }
     136
     137    /**
     138     * Pour savoir si le Newton a convergé
     139     * @return true si oui, false sinon
     140     */    public function HasConverged() {
     141                if($this->iCpt >= $this->iCptMax) {
     142                        return false;
     143                }
     144                else {
     145                        return true;
     146                }
     147        }
    74148}
    75149
  • _plugins_/hydraulic/trunk/hyd_inc/section.class.php

    r56649 r59892  
    11<?php
    22/**
    3  *      \file class.section.php
    4  *
    5  *      Copyright 2009 dorch <dorch@dorch-xps>
     3 *      @file class.section.php
     4 *      Gestion des calculs au niveau des Sections
     5 */
     6
     7/*      Copyright 2009-2012 Dorch <dorch@dorch.fr>
    68 *
    79 *      This program is free software; you can redistribute it and/or modify
     
    2123 */
    2224
     25// Chargement de la classe pour la méthode de Newton
    2326include_spip('hyd_inc/newton.class');
     27
     28/**
     29 * Gestion des Paramètres du canal (hors section)
     30 */
    2431class cParam {
    25    public $rYCL; // Condition limite en cote à l'amont ou à l'aval
    26    public $rKs; // Strickler
    27    public $rQ; // Débit
    28    public $rLong; // Longueur du bief
    29    public $rIf; // Pente du fond
    30    public $rDx; // Pas d'espace (positif en partant de l'aval, négatif en partant de l'amont)
    31    public $rPrec; // Précision de calcul et d'affichage
    32    public $rG=9.81; // Constante de gravité
    33 
    34    function __construct($rYCL,$rKs, $rQ, $rLong, $rIf, $rDx, $rPrec) {
    35       $this->rYCL=(real) $rYCL;
    36       $this->rKs=(real) $rKs;
    37       $this->rQ=(real) $rQ;
    38       $this->rLong=(real) $rLong;
    39       $this->rIf=(real) $rIf;
    40       $this->rDx=(real) $rDx;
    41       $this->rPrec=(real) $rPrec;
    42    }
     32    public $rYCL;   /// Condition limite en cote à l'amont ou à l'aval
     33    public $rKs;    /// Strickler
     34    public $rQ;     /// Débit
     35    public $rLong;  /// Longueur du bief
     36    public $rIf;    /// Pente du fond
     37    public $rDx;    /// Pas d'espace (positif en partant de l'aval, négatif en partant de l'amont)
     38    public $rPrec;  /// Précision de calcul et d'affichage
     39    public $rG=9.81;/// Constante de gravité
     40    public $iPrec;  /// Précision en nombre de décimales
     41
     42    function __construct($rYCL,$rKs, $rQ, $rLong, $rIf, $rDx, $rPrec, $rYB) {
     43        $this->rYCL=(real) $rYCL;
     44        $this->rKs=(real) $rKs;
     45        $this->rQ=(real) $rQ;
     46        $this->rLong=(real) $rLong;
     47        $this->rIf=(real) $rIf;
     48        $this->rDx=(real) $rDx;
     49        $this->rPrec=(real) $rPrec;
     50        $this->rYB=(real) $rYB;
     51        $this->iPrec=(int)-log10($rPrec);
     52    }
    4353}
     54
     55/**
     56 * Gestion commune pour les différents types de section.
     57 * Comprend les formules pour la section rectangulaire pour gérer les débordements
     58 */
    4459abstract class acSection {
    45    public $rS;
    46    public $rR;
    47    public $rB;
    48    public $rJ;
    49    public $rFr;
    50    public $rY;
    51    public $rHautCritique;
    52    public $rHautNormale;
    53 
    54    public function __construct($oP) {
    55       // Calcul des hauteurs normale et critique à la construction de la classe
     60    //~ public $rS;             /// Surface hydraulique
     61    //~ public $rP;             /// Périmètre hydraulique
     62    //~ public $rR;             /// Rayon hydraulique
     63    //~ public $rB;             /// Largeur au miroir
     64    //~ public $rJ;             /// Perte de charge
     65    //~ public $rFr;                /// Froude
     66    protected $rY=0;          /// Tirant d'eau
     67    public $rHautCritique;  /// Tirant d'eau critique
     68    public $rHautNormale;   /// Tirant d'eau normal
     69    protected $oP;   /// Paramètres du système canal (classe oParam)
     70    protected $oLog; /// Pour l'affichage du journal de calcul
     71    public $rLargeurBerge; /// largeur au débordement
     72    protected $bSnFermee = false; /// true si la section est fermée (fente de Preissmann)
     73    /**
     74     * Tableau contenant les données dépendantes du tirant d'eau $this->rY.
     75     *
     76     * Les clés du tableau peuvent être :
     77     * - S : la surface hydraulique
     78     * - P : le périmètre hydraulique
     79     * - R : le rayon hydraulique
     80     * - B : la largeur au miroir
     81     * - J : la perte de charge
     82     * - Fr : le nombre de Froude
     83     * - dS : la dérivée de S par rapport Y
     84     * - dP : la dérivée de P par rapport Y
     85     * - dR : la dérivée de R par rapport Y
     86     * - dB : la dérivée de B par rapport Y
     87     */
     88    private $arCalc = array();
     89    protected $arCalcGeo = array(); /// Données ne dépendant pas de la cote de l'eau
     90
     91    /**
     92     * Construction de la classe.
     93     * Calcul des hauteurs normale et critique
     94     */
     95    public function __construct(&$oLog,&$oP) {
     96      $this->oP = &$oP;
     97      $this->CalcGeo('B');
    5698      //spip_log($this,'hydraulic');
    57       $oHautCritique = new cHautCritique($this, $oP);
    58       $this->rHautCritique = $oHautCritique->Newton($oP->rPrec);
    59       $oHautNormale= new cHautNormale($this, $oP);
    60       $this->rHautNormale = $oHautNormale->Newton($this->rHautCritique);
    61    }
    62 
    63    abstract public function CalcS();
    64 
    65    abstract public function CalcP();
    66 
    67    public function CalcR() {
    68       $this->rR=$this->rS/$this->rP;
    69       return $this->rR;
    70    }
    71 
    72    abstract public function CalcB();
    73 
    74    public function CalcJ(cParam $oP) {
    75       $this->rJ= pow($oP->rQ/$this->rS/$oP->rKs,2)/pow($this->rR,4/3);
    76       return $this->rJ;
    77    }
    78 
    79    public function CalcFr(cParam $oP) {
    80       $this->rFr=$oP->rQ/$this->rS*sqrt($this->rB/$this->rS/$oP->rG);
    81       return $this->rFr;
    82    }
    83 
    84    public function ReCalcFr(cParam $oP,$rY) {
    85       $this->rY = $rY;
    86       $this->rS = $this->CalcS();
    87       $this->rFr=$oP->rQ/$this->rS*sqrt($this->CalcB()/$this->rS/$oP->rG);
    88       return $this->rFr;
    89    }
    90 
    91    public function CalcY(cParam $oP) {
    92       $dY=$oP->rDx*($oP->rIf-$this->rJ)/(1-pow($this->rFr,2));
    93       $this->rY=$this->rY-$dY;
    94       return $this->rY;
    95    }
    96 
    97    public function CalcPasX(cParam $oP, $rY) {
    98       $this->rY = $rY;
    99       $this->CalcB();
    100       $this->CalcP();
    101       $this->CalcS();
    102       $this->CalcR();
    103       $this->CalcJ($oP);
    104       $this->CalcFr($oP);
    105       return $this->CalcY($oP);
    106    }
     99    }
     100
     101    /**
     102     * Efface toutes les données calculées pour forcer le recalcul
     103     */
     104    public function Reset($bGeo=true) {
     105        $this->arCalc = array();
     106        if($bGeo) {
     107         $this->arCalcGeo = array();
     108      }
     109    }
     110
     111    /**
     112     * Calcul des données à la section
     113     * @param $sDonnee Clé de la donnée à calculer (voir $this->$arCalc)
     114     * @param $bRecalc Pour forcer le recalcul de la donnée
     115     * @return la donnée calculée
     116     */
     117    public function Calc($sDonnee, $rY = false) {
     118        if($rY!==false && $rY!=$this->rY) {
     119            //spip_log('Calc('.$sDonnee.') rY='.$rY,'hydraulic');
     120            $this->rY = $rY;
     121            // On efface toutes les données dépendantes de Y pour forcer le calcul
     122            $this->Reset(false);
     123        }
     124
     125        if(!isset($this->arCalc[$sDonnee])) {
     126            // La donnée a besoin d'être calculée
     127            switch($sDonnee) {
     128                case 'S' : // Surface mouillée
     129                    $this->arCalc[$sDonnee] = $this->CalcS();
     130                    break;
     131                case 'P' : // Périmètre mouillé
     132                    $this->arCalc[$sDonnee] = $this->CalcP();
     133                    break;
     134                case 'R' : // Rayon hydraulique
     135                    $this->arCalc[$sDonnee] = $this->CalcR();
     136                    break;
     137                case 'B' : // Largeur au miroir
     138                    $this->arCalc[$sDonnee] = $this->CalcB();
     139                    break;
     140                case 'J' : // Perte de charge linéaire
     141                    $this->arCalc[$sDonnee] = $this->CalcJ();
     142                    break;
     143                case 'Fr' : // Froude
     144                    $this->arCalc[$sDonnee] = $this->CalcFr();
     145                    break;
     146                case 'dS' : // dS/dY
     147                    $this->arCalc[$sDonnee] = $this->CalcSder();
     148                    break;
     149                case 'dP' : // dP/dY
     150                    $this->arCalc[$sDonnee] = $this->CalcPder();
     151                    break;
     152                case 'dR' : // dR/dY
     153                    $this->arCalc[$sDonnee] = $this->CalcRder();
     154                    break;
     155                case 'dB' : // dB/dY
     156                    $this->arCalc[$sDonnee] = $this->CalcBder();
     157                    break;
     158                case 'V' : // Vitesse moyenne
     159                    $this->arCalc[$sDonnee] = $this->CalcV();
     160                    break;
     161                case 'Hs' : // Charge spécifique
     162                    $this->arCalc[$sDonnee] = $this->CalcHs();
     163                    break;
     164                case 'Yf' : // Tirant d'eau fluvial
     165                    $this->arCalc[$sDonnee] = $this->CalcYf();
     166                    break;
     167                case 'Yt' : // Tirant d'eau torrentiel
     168                    $this->arCalc[$sDonnee] = $this->CalcYt();
     169                    break;
     170                case 'Yco' : // Tirant d'eau conjugué
     171                    $this->arCalc[$sDonnee] = $this->CalcYco();
     172                    break;
     173                case 'Tau0' : // Force tractrice ou contrainte de cisaillement
     174                    $this->arCalc[$sDonnee] = $this->CalcTau0();
     175                    break;
     176                case 'Yg' : // Distance du centre de gravité de la section à la surface libre
     177                    $this->arCalc[$sDonnee] = $this->CalcYg();
     178                    break;
     179                case 'Imp' : // Impulsion hydraulique
     180                    $this->arCalc[$sDonnee] = $this->CalcImp();
     181                    break;
     182                case 'Alpha' : // Angle Alpha de la surface libre par rapport au fond pour les sections circulaires
     183                    $this->arCalc[$sDonnee] = $this->CalcAlpha();
     184                    break;
     185                case 'dAlpha' : // Dérivée de l'angle Alpha de la surface libre par rapport au fond pour les sections circulaires
     186                    $this->arCalc[$sDonnee] = $this->CalcAlphaDer();
     187                    break;
     188            }
     189        }
     190        //spip_log('Calc('.$sDonnee.')='.$this->arCalc[$sDonnee],'hydraulic');
     191        return $this->arCalc[$sDonnee];
     192    }
     193
     194    /**
     195     * Calcul des données uniquement dépendantes de la géométrie de la section
     196     * @param $sDonnee Clé de la donnée à calculer (voir $this->$arCalcGeo)
     197     * @param $rY Hauteur d'eau
     198     * @return la donnée calculée
     199     */
     200    public function CalcGeo($sDonnee) {
     201      if($sDonnee != 'B' && !isset($this->arCalcGeo['B'])) {
     202         // Si la largeur aux berges n'a pas encore été calculée, on commence par ça
     203         $this->CalcGeo('B');
     204      }
     205        if(!isset($this->arCalcGeo[$sDonnee])) {
     206            // La donnée a besoin d'être calculée
     207         //spip_log('CalcGeo('.$sDonnee.') rY='.$this->oP->rYB,'hydraulic');
     208         $this->Reset(false);
     209         $this->rY = $this->oP->rYB;
     210            switch($sDonnee) {
     211            case 'B' : // Largeur aux berges
     212               $this->arCalcGeo[$sDonnee] = $this->CalcB();
     213               if($this->arCalcGeo[$sDonnee] < $this->oP->rYB / 100) {
     214                  // Section fermée
     215                  $this->bSnFermee = true;
     216                  // On propose une fente de Preissmann égale à 1/100 de la hauteur des berges
     217                  $this->arCalcGeo[$sDonnee] = $this->oP->rYB / 100;
     218               }
     219               $this->rLargeurBerge = $this->arCalcGeo[$sDonnee];
     220                    break;
     221                case 'S' : // Surface mouillée
     222                    $this->arCalcGeo[$sDonnee] = $this->CalcS();
     223                    break;
     224                case 'P' : // Périmètre mouillé
     225                    $this->arCalcGeo[$sDonnee] = $this->CalcP();
     226                    break;
     227                case 'Yc' : // Tirant d'eau critique
     228                    $this->arCalcGeo[$sDonnee] = $this->CalcYc();
     229                    break;
     230                case 'Yn' : // Tirant d'eau normal
     231                    $this->arCalcGeo[$sDonnee] = $this->CalcYn();
     232                    break;
     233            }
     234        }
     235        //spip_log('CalcGeo('.$sDonnee.')='.$this->arCalcGeo[$sDonnee],'hydraulic');
     236        return $this->arCalcGeo[$sDonnee];
     237    }
     238
     239    /**
     240     * Calcul de la surface hydraulique.
     241     * @return La surface hydraulique
     242     */
     243    protected function CalcS($rY) {
     244        return $rY*$this->rLargeurBerge;
     245    }
     246
     247    /**
     248     * Calcul de dérivée de la surface hydraulique par rapport au tirant d'eau.
     249     * @return dS
     250     */
     251    protected function CalcSder() {
     252        return $this->rLargeurBerge;
     253    }
     254
     255   /**
     256    * Calcul du périmètre hydraulique.
     257    * @return Le périmètre hydraulique
     258    */
     259    protected function CalcP($rY) {
     260        return 2*$rY;
     261    }
     262    /**
     263     * Calcul de dérivée du périmètre hydraulique par rapport au tirant d'eau.
     264     * @return dP
     265     */
     266    protected function CalcPder() {
     267        return 2;
     268    }
     269
     270   /**
     271    * Calcul du rayon hydraulique.
     272    * @return Le rayon hydraulique
     273    */
     274    protected function CalcR() {
     275        if($this->Calc('P')!=0) {
     276            return $this->Calc('S')/$this->Calc('P');
     277        }
     278        else {
     279            return INF;
     280        }
     281    }
     282
     283    /**
     284     * Calcul de dérivée du rayon hydraulique par rapport au tirant d'eau.
     285     * @return dR
     286     */
     287    protected function CalcRder() {
     288        if($this->Calc('P')!=0) {
     289            return ($this->Calc('dS')*$this->Calc('P')-$this->Calc('S')*$this->Calc('dP'))/pow($this->Calc('P'),2);
     290        }
     291        else {
     292            return 0;
     293        }
     294    }
     295
     296   /**
     297    * Calcul de la largeur au miroir.
     298    * @return La largeur au miroir
     299    */
     300    protected function CalcB() {
     301        return $this->rLargeurBerge;
     302    }
     303    /**
     304     * Calcul de dérivée de la largeur au miroir par rapport au tirant d'eau.
     305     * @return dB
     306     */
     307    protected function CalcBder() {
     308        return 0;
     309    }
     310
     311   /**
     312    * Calcul de la perte de charge par la formule de Manning-Strickler.
     313    * @return La perte de charge
     314    */
     315    private function CalcJ() {
     316        return pow($this->oP->rQ/$this->Calc('S')/$this->oP->rKs,2)/pow($this->Calc('R'),4/3);
     317    }
     318
     319   /**
     320    * Calcul du nombre de Froude.
     321    * @return Le nombre de Froude
     322    */
     323    private function CalcFr() {
     324        return $this->oP->rQ/$this->Calc('S')*sqrt($this->Calc('B')/$this->Calc('S')/$this->oP->rG);
     325    }
     326
     327   /**
     328    * Calcul du point suivant de la courbe de remous par la méthode Euler explicite.
     329    * @return Tirant d'eau
     330    */
     331    public function CalcY_M1($Y) {
     332        // L'appel à Calc('J') avec Y en paramètre réinitialise toutes les données dépendantes de la ligne d'eau
     333        return $Y-($this->oP->rDx*($this->oP->rIf-$this->Calc('J',$Y))/(1-pow($this->Calc('Fr',$Y),2)));
     334    }
     335
     336   /**
     337    * Calcul de la vitesse moyenne.
     338    * @return Vitesse moyenne
     339    */
     340    private function CalcV() {
     341        return $this->oP->rQ/$this->Calc('S');
     342    }
     343
     344   /**
     345    * Calcul de la charge spécifique.
     346    * @return Charge spécifique
     347    */
     348    private function CalcHs() {
     349        return $this->rY+pow($this->Calc('V'),2)/(2*$this->oP->rG);
     350    }
     351
     352   /**
     353    * Calcul du tirant d'eau critique.
     354    * @return tirant d'eau critique
     355    */
     356    private function CalcYc() {
     357        $oHautCritique = new cHautCritique($this, $this->oP);
     358        if(!$this->rHautCritique = $oHautCritique->Newton($this->oP->rPrec) or !$oHautCritique->HasConverged()) {
     359         $this->oLog(_T('hydraulic:h_critique').' : '._T('hydraulic:newton_non_convergence'));
     360      }
     361      return $this->rHautCritique;
     362    }
     363
     364   /**
     365    * Calcul du tirant d'eau normal.
     366    * @return tirant d'eau normal
     367    */
     368    private function CalcYn() {
     369        $oHautNormale= new cHautNormale($this, $this->oP);
     370        if(!$this->rHautNormale = $oHautNormale->Newton($this->CalcGeo('Yc')) or !$oHautNormale->HasConverged()) {
     371         $this->oLog(_T('hydraulic:h_normale').' : '._T('hydraulic:newton_non_convergence'));
     372      }
     373        return $this->rHautNormale;
     374    }
     375
     376   /**
     377    * Calcul du tirant d'eau fluvial.
     378    * @return tirant d'eau fluvial
     379    */
     380    private function CalcYf() {
     381        if($this->rY > $this->Calc('Yc')) {
     382            return $this->rY;
     383        }
     384        else {
     385            $oHautCorrespondante= new cHautCorrespondante($this, $oP);
     386            return $oHautCorrespondante->Newton($this->Calc('Yc'));
     387        }
     388    }
     389
     390   /**
     391    * Calcul du tirant d'eau torrentiel.
     392    * @return tirant d'eau torrentiel
     393    */
     394    private function CalcYt() {
     395        if($this->rY < $this->Calc('Yc')) {
     396            return $this->rY;
     397        }
     398        else {
     399            $oHautCorrespondante= new cHautCorrespondante($this, $oP);
     400            return $oHautCorrespondante->Newton($this->Calc('Yc'));
     401        }
     402    }
     403
     404   /**
     405    * Calcul du tirant d'eau conjugué.
     406    * @return tirant d'eau conjugué
     407    */
     408    private function CalcYco() {
     409        return (sqrt(1 + 8 * pow($this->Calc('Fr'),2)) - 1) / 2;
     410    }
     411
     412   /**
     413    * Calcul de la contrainte de cisaillement.
     414    * @return contrainte de cisaillement
     415    */
     416    private function CalcTau0() {
     417        return 1000 * $oP->rG * $this->Calc('R') * $oP->rIf;
     418    }
     419
     420    /**
     421     * Calcul de la distance du centre de gravité de la section à la surface libre.
     422     * @return Distance du centre de gravité de la section à la surface libre
     423     */
     424    protected function CalcYg($rY) {
     425        return $rY / 2;
     426    }
     427    /**
     428     * Calcul de l'impulsion hydraulique.
     429     * @return Impulsion hydraulique
     430     */
     431    protected function CalcImp() {
     432        return 1000 * ($oP->rQ * $this->Calc('V') + $oP->rG * $this->Calc('S') * $this->Calc('Yg'));
     433    }
     434
     435    /**
     436     * Calcul de l'angle Alpha entre la surface libre et le fond pour les sections circulaires.
     437     * @return Angle Alpha pour une section circulaire, 0 sinon.
     438     */
     439    protected function CalcAlpha(){
     440        return 0;
     441    }
     442
     443    /**
     444     * Calcul de la dérivée de l'angle Alpha entre la surface libre et le fond pour les sections circulaires.
     445     * @return Dérivée de l'angle Alpha pour une section circulaire, 0 sinon.
     446     */
     447    protected function CalcAlphaDer(){
     448        return 0;
     449    }
    107450
    108451}
    109 class cSnTrapeze extends acSection {
    110    public $rLargeurFond;
    111    public $rFruit;
    112 
    113 
    114    function __construct($oP,$rLargeurFond, $rFruit) {
    115       $this->rLargeurFond=(real) $rLargeurFond;
    116       $this->rFruit=(real) $rFruit;
    117       parent::__construct($oP);
    118    }
    119 
    120    public function CalcB() {
    121       $this->rB=$this->rLargeurFond+2*$this->rFruit*$this->rY;
    122       return $this->rB;
    123    }
    124 
    125    public function CalcP() {
    126       $this->rP=$this->rLargeurFond+2*sqrt(1+pow($this->rFruit,2))*$this->rY;
    127       return $this->rP;
    128    }
    129 
    130    public function CalcS() {
    131       $this->rS=$this->rY*($this->rLargeurFond+$this->rFruit*$this->rY);
    132       return $this->rS;
    133    }
     452
     453
     454/**
     455 * Calcul de la hauteur critique
     456 */
     457class cHautCritique extends acNewton {
     458    private $oSn;
     459    private $oP;
     460
     461    /**
     462     * Constructeur de la classe
     463     * @param $oSn Section sur laquelle on fait le calcul
     464     * @param $oP Paramètres supplémentaires (Débit, précision...)
     465     */
     466    function __construct($oSn,cParam $oP) {
     467        $this->oSn = $oSn;
     468        $this->oP = $oP;
     469        $this->rTol=$oP->rPrec;
     470        $this->rDx=$oP->rPrec/10;
     471    }
     472
     473    /**
     474     * Calcul de la fonction dont on cherche le zéro
     475     * @param $rX Variable dont dépend la fonction
     476     */
     477    protected function CalcFn($rX) {
     478        // Calcul de la fonction
     479        $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);
     480        spip_log('cHautCritique:CalcFn('.$rX.')='.$rFn,'hydraulic');
     481        return $rFn;
     482    }
     483
     484    /**
     485     * Calcul analytique de la dérivée de la fonction dont on cherche le zéro
     486     * @param $rX Variable dont dépend la fonction
     487     */
     488    protected function CalcDer($rX) {
     489        // L'initialisation à partir de $rX a été faite lors de l'appel à CalcFn
     490        $rDer = ($this->oSn->Calc('dB')*$this->oSn->Calc('S')-3*$this->oSn->Calc('B')*$this->oSn->Calc('dS'));
     491        $rDer = pow($this->oP->rQ,2)/$this->oP->rG * $rDer / pow($this->oSn->Calc('S'),4);
     492        spip_log('cHautCritique:CalcDer('.$rX.')='.$rDer,'hydraulic');
     493        return $rDer;
     494    }
    134495}
    135 class cHautCritique extends acNewton {
    136    private $oSn;
    137    private $oP;
    138 
    139    function __construct($oSn,cParam $oP) {
    140       $this->oSn = $oSn;
    141       $this->oP = $oP;
    142       $this->rTol=$oP->rPrec;
    143       $this->rDx=$oP->rPrec/10;
    144    }
    145    public function CalcFn($rX) {
    146       $this->oSn->rY = $rX;
    147       $this->oSn->CalcS();
    148       $this->oSn->CalcB();
    149       return (pow($this->oP->rQ,2)/pow($this->oSn->rS,2)*($this->oSn->rB/$this->oSn->rS/$this->oP->rG)-1);
    150    }
    151 
     496
     497/**
     498 * Calcul de la hauteur normale
     499 */
     500class cHautNormale extends acNewton {
     501    private $oSn;
     502    private $rQ;
     503    private $rKs;
     504    private $rIf;
     505
     506    /**
     507     * Constructeur de la classe
     508     * @param $oSn Section sur laquelle on fait le calcul
     509     * @param $oP Paramètres supplémentaires (Débit, précision...)
     510     */
     511    function __construct($oSn, cParam $oP) {
     512        $this->oSn=$oSn;
     513        $this->rQ=$oP->rQ;
     514        $this->rKs=$oP->rKs;
     515        $this->rIf=$oP->rIf;
     516        $this->rG=$oP->rG;
     517        $this->rTol=$oP->rPrec;
     518        $this->rDx=$oP->rPrec/10;
     519    }
     520
     521    /**
     522     * Calcul de la fonction dont on cherche le zéro
     523     * @param $rX Variable dont dépend la fonction
     524     */
     525    protected function CalcFn($rX) {
     526        // Calcul de la fonction
     527        $rFn = ($this->rQ-$this->rKs*pow($this->oSn->Calc('R',$rX),2/3)*$this->oSn->Calc('S',$rX)*sqrt($this->rIf));
     528        spip_log('cHautNormale:CalcFn('.$rX.')='.$rFn,'hydraulic');
     529        return $rFn;
     530    }
     531
     532    /**
     533     * Calcul analytique de la dérivée de la fonction dont on cherche le zéro
     534     * @param $rX Variable dont dépend la fonction
     535     */
     536    protected function CalcDer($rX) {
     537        // L'initialisation a été faite lors de l'appel à CalcFn
     538        $rDer = 2/3*$this->oSn->Calc('dR')*pow($this->oSn->Calc('R'),-1/3)*$this->oSn->Calc('S');
     539        $rDer += pow($this->oSn->Calc('R'),2/3)*$this->oSn->Calc('dS');
     540        $rDer *= -$this->rKs * sqrt($this->rIf);
     541        spip_log('cHautNormale:CalcDer('.$rX.')='.$rDer,'hydraulic');
     542        return $rDer;
     543    }
    152544}
    153 class cHautNormale extends acNewton {
    154    private $oSn;
    155    private $rQ;
    156    private $rKs;
    157    private $rIf;
    158 
    159    function __construct($oSn, $oP) {
    160       $this->oSn=$oSn;
    161       $this->rQ=$oP->rQ;
    162       $this->rKs=$oP->rKs;
    163       $this->rIf=$oP->rIf;
    164       $this->rG=$oP->rG;
    165       $this->rTol=$oP->rPrec;
    166       $this->rDx=$oP->rPrec/10;
    167    }
    168 
    169    public function CalcFn($rX) {
    170       $this->oSn->rY = $rX;
    171       $this->oSn->CalcS();
    172       $this->oSn->CalcP();
    173       return ($this->rQ-$this->rKs*pow($this->oSn->CalcR(),2/3)*$this->oSn->rS*sqrt($this->rIf));
    174    }
     545
     546
     547/**
     548 * Calcul de la hauteur correspondante (charge égale)
     549 */
     550class cHautCorrespondante extends acNewton {
     551    private $rY; // Tirant d'eau connu
     552    private $rV2; // Vitesse moyenne au carré associée au tirant d'eau connu
     553    private $oSnCal; // Section contenant les données de la section avec la hauteur à calculer
     554    private $rG; // Constante de gravité
     555
     556    /**
     557     * Constructeur de la classe
     558     * @param $oSn Section sur laquelle on fait le calcul
     559     * @param $oP Paramètres supplémentaires (Débit, précision...)
     560     */
     561    function __construct(acSection $oSn, cParam $oP) {
     562        $this->rY = $oSn->rY;
     563        $this->rV2 = pow($oSn->Calc('V'),2);
     564        $this->oSnCal = clone $oSn;
     565        $this->rQ = $oP->rQ;
     566        $this->rG = $oP->rG;
     567    }
     568
     569    /**
     570     * Calcul de la fonction dont on cherche le zéro
     571     * @param $rX Variable dont dépend la fonction
     572     */
     573    protected function CalcFn($rX) {
     574        // Calcul de la fonction
     575        $rFn = $this->rY - $rX + ($this->rV2+pow($this->oSnCal->Calc('V',$rX),2))/(2*$this->rG);
     576        spip_log('cHautCorrespondante:CalcFn('.$rX.')='.$rFn,'hydraulic');
     577        return $rFn;
     578    }
     579
     580    /**
     581     * Calcul analytique de la dérivée de la fonction dont on cherche le zéro
     582     * @param $rX Variable dont dépend la fonction
     583     */
     584    protected function CalcDer($rX) {
     585        // L'initialisation a été faite lors de l'appel à CalcFn
     586        $rDer = - $this->rQ/ $this->rG * $this->oSnCal->Calc('dS') / pow($this->oSnCal->Calc('S'),3);
     587        spip_log('cHautCorrespondante:CalcDer('.$rX.')='.$rDer,'hydraulic');
     588        return $rDer;
     589    }
    175590}
    176591
  • _plugins_/hydraulic/trunk/hydraulic.css.html

    r57841 r59892  
    8989    background-color: #eeeeee;
    9090}
     91
     92#jqplot_ligne_lechapt_calmon, #jqplot_courbe_remous{
     93        margin: 0 auto;
     94}
     95
     96tr.align_right td {
     97        text-align: right;
     98}
  • _plugins_/hydraulic/trunk/lang/hydraulic_en.php

    r56971 r59892  
    1 <?php
     1<?php
    22// This is a SPIP language file  --  Ceci est un fichier langue de SPIP
    33$GLOBALS[$GLOBALS['idx_lang']] = array(
     
    55    'abscisse'        => "Abscissa",
    66    'arret_calcul'    => "Calculation stopped: Critical elevation reached at abscissa",
     7    'acier_lamine'    => "Rolled steel - Smooth concrete",
     8    // B
     9    'berge'           => "Embankment",
    710    // C
    811    'calcul_caract'   => "The calculation has the following characteristics:",
     
    1518    'calcul_torrentiel'=> "Uptream boundary condition <= Critical elevation : calculation of supercritical part from upstream",
    1619    'champ_obligatoire'=> 'This field is required',
     20    'choix_materiau'  => "Choice of material",
     21    'caract_lechapt_calmon' => "Characteristics",
     22    'calculer_lechapt_calmon' => "Calculation with Lechapt and Calmon formula",
     23    'calcul_val'      => "Value to calculate",
     24    'choix_section'   => "Choice of section",
    1725    // D
    1826    'debit_amont'     => "Upstream flow (m3/s)",
    1927    'def_section_trap'=> "Definition of trapezoidal section",
    20     // F
     28    'def_section_rect'=> "Definition of rectangular section",
     29    'def_section_circ'=> "Definition of circular section",
     30    'def_section_puis'=> "Definition of power section",
     31        'diametre'                => "Diameter (m)",
     32     // F
    2133    'fond'            => "Bottom",
    2234    'fruit'           => "Slope (m/m)",
     35    'fixer_val'       => "Fixed parameter",
     36    'fonte_beton_corrosive' =>"Unlined cast iron - Coarse concrete (corrosive water)",
     37        'fonte_beton_ncorrosive' => "Cast steel or uncoated - Concrete coarse (somewhat corrosive water)",
     38    'fonte_revt_ciment' => "Cast steel or cement coating",
     39    'fonte_revt_bitume' => "Cast iron or steel coating bitumen - Concrete centrifuged",
     40    'fonte_revt_centrifuge' => "Cast iron or steel coating centrifuged",
    2341    // H
    2442    'h_amont_imposee' => "Water level imposed at the upstream (m)",
    2543    'h_aval_imposee'  => "Downstream water level imposed (m)",
     44    'h_berge'         => "Embankment elevation (m)",
    2645    'h_critique'      => "Critical elevation",
    2746    'h_normale'       => "Normal elevation",
    2847    // L
    2948    'largeur_fond'    => "Width at bottom (m)",
     49    'largeur_berge'   => "Width at embankment level",
    3050    'ligne_eau_fluviale'  => "Subcritical water profile",
    3151    'ligne_eau_torrentielle'  => "Supercritical water profile",
    3252    'log_titre'       => "Calculation's log",
    3353    'longueur_bief'   => "Length of reach (m)",
     54    //N
     55    'newton_non_convergence' => "Non-convergence of the calculation (Newton's method)",
    3456    // P
    3557    'param_calcul'    => "Calculation parameters",
     
    4163    'pas_calcul_depuis_aval' => 'Downstream boundary condition < Critical elevation : no possible calculation from downstream',
    4264    'pas_calcul_depuis_amont' => 'Upstream boundary condition < Critical elevation : no possible calculation from upstream',
     65   'pas_var' => "With a variation step of",
     66    'pvc' => "PVC - Polyethylene",
     67    'param_Q' => "Q: Flow (m&#179; / s)",
     68    'param_D' => "D: Pipe diameter (m)",
     69    'param_J' => "J: Head drop (m)",
     70    'param_Lg' => "Lg: Pipe length (m)",
     71    'param_calc_lechapt_calmon' => "Calculation parameters",
     72    'precision_lechapt_calmon' => "Display accuracy (m)",
    4373    //S
    4474    'saisie_erreur'   => 'Your entry contains errors!',
     75    'section_trap'    => "Trapezoidal Section",
     76    'section_rect'    => "Rectangular Section",
     77    'section_circ'    => "Circular Section",
     78    'section_puiss'   => "Power Section",
    4579    //T
    4680    'tirant_eau'         => 'Draft (m)',
     81    'type_materiau' => "Type of material",
     82    'tuyau_lisse1' => "Hydraulically smooth pipe - 0.05 &#8804; D &#8804; 0.2 ",
     83    'tuyau_lisse2' => "Hydraulically smooth pipe - 0.25 &#8804; D &#8804; 1 ",
     84    'type_section' => "Type of section",
    4785    //V
    48     'valeur_positive' => 'This value must be strictly positive'
     86    'valeur_positive' => "This value must be strictly positive",
     87    'val_min' => "From minimum value",
     88    'val_max' => "To maximum value",
     89    'varier_val' => "Parameter to vary "
    4990);
    5091
  • _plugins_/hydraulic/trunk/lang/hydraulic_fr.php

    r56971 r59892  
    55    'abscisse'        => "Abscisse",
    66    'arret_calcul'    => "Arrêt du calcul : Hauteur critique atteinte à l'abscisse",
     7    'acier_lamine'    => "Acier laminé - Béton lisse",
     8    // B
     9    'berge'           => "Berge",
    710    // C
    811    'calcul_caract'   => "Le calcul a les caractéristiques suivantes :",
     
    1417    'calcul_fluvial'  => "Condition limite aval >= Hauteur critique : calcul de la partie fluviale à partir de l'aval",
    1518    'calcul_torrentiel'=> "Condition limite amont <= Hauteur critique : calcul de la partie torrentielle à partir de l'amont",
    16     'champ_obligatoire'=> 'Ce champ est obligatoire',
     19    'champ_obligatoire'=> "Ce champ est obligatoire",
     20    'choix_materiau'  => "Choix du matériau",
     21    'caract_lechapt_calmon' => "Caractéristiques",
     22    '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)",
     27    'choix_donnee_calc' => "Choix de la donnée à calculer",
     28    'charge_critique' => "La charge critique (m)",
     29    'larg_miroir'     => "La largeur au miroir (m)",
    1730    // D
    1831    'debit_amont'     => "Débit amont (m3/s)",
    1932    'def_section_trap'=> "Définition de la section trapézoïdale",
     33    'def_section_rect'=> "Définition de la section rectangulaire",
     34    'def_section_circ'=> "Définition de la section circulaire",
     35    'def_section_puis'=> "Définition de la section puissance",
     36        'diametre'       => "Diamètre (m)",
     37        'donnee_calc'     => "Donnée à calculer",
    2038    // F
    2139    'fond'            => "Fond",
    2240    'fruit'           => "Fruit (m/m)",
     41    'fixer_val'       => "Paramètre fixé",
     42    'fonte_beton_corrosive' =>"Fonte ou acier non revêtus - Béton grossier (eau corrosive)",
     43    'fonte_beton_ncorrosive' =>"Fonte ou acier non revêtus - Béton grossier (eau peu corrosive)",
     44    'fonte_revt_ciment' => "Fonte ou acier revêtement ciment",
     45    'fonte_revt_bitume' => "Fonte ou acier revêtement bitume - Béton centrifugé",
     46    'fonte_revt_centrifuge' => "Fonte ou acier revêtement centrifugé",
     47    'froud'           => "Le Froude",
     48    'force_tract'     => "La force tractrice (Pa)",
    2349    // H
    2450    'h_amont_imposee' => "Hauteur d'eau imposée à l'amont (m)",
    2551    'h_aval_imposee'  => "Hauteur d'eau aval imposée (m)",
     52    'h_berge'         => "Hauteur de berge (m)",
    2653    'h_critique'      => "Hauteur critique",
    2754    'h_normale'       => "Hauteur normale",
     55    //I
     56    'impulsion'       => "Impulsion",
    2857    // L
    2958    'largeur_fond'    => "Largeur au fond (m)",
     59    'largeur_berge'   => "Largeur au niveau des berges",
    3060    'ligne_eau_fluviale'  => "Ligne d'eau fluviale",
    3161    'ligne_eau_torrentielle'  => "Ligne d'eau torrentielle",
    3262    'log_titre'       => "Journal des calculs",
    3363    'longueur_bief'   => "Longueur du bief (m)",
     64    //N
     65    'newton_non_convergence' => "Non convergence du calcul (Méthode de Newton)",
    3466    // P
    3567    'param_calcul'    => "Paramètres de calcul",
     
    3971    'pente_fond'      => "Pente du fond (m/m)",
    4072    'precision_calc'  => "Précision de calcul et d'affichage des cotes (m)",
    41     'pas_calcul_depuis_aval' => 'Condition limite aval < Hauteur critique : pas de calcul possible depuis l\'aval',
    42     'pas_calcul_depuis_amont' => 'Condition limite amont > Hauteur critique : pas de calcul possible depuis l\'amont',
     73    'pas_calcul_depuis_aval' => "Condition limite aval < Hauteur critique : pas de calcul possible depuis l'aval",
     74    'pas_calcul_depuis_amont' => "Condition limite amont > Hauteur critique : pas de calcul possible depuis l'amont",
     75    'pas_var'         => "Avec un pas de variation de",
     76    'pvc'             => "PVC - Polyéthylène",
     77    'param_Q'         => "Q: Débit (m³/s)",
     78    'param_D'         => "D: Diamètre du tuyau (m)",
     79    'param_J'         => "J: Perte de charge (m)",
     80    'param_Lg'        => "Lg: Longueur du tuyau (m)",
     81    'precision_lechapt_calmon'  => "Précision de calcul(m)",
     82    'perim_mouille'   => "Le périmètre mouillé (m)",
     83    'perte_charge'    => "La perte de charge (m/m)",
     84    //R
     85    'rayon_hyd'       => "Le rayon hydraulique (m)",
    4386    //S
    44     'saisie_erreur'   => 'Votre saisie contient des erreurs !',
     87    'saisie_erreur'   => "Votre saisie contient des erreurs !",
     88    'section_trap'    => "Section Trapézoïdale",
     89    'section_rect'    => "Section Rectangulaire",
     90    'section_circ'    => "Section Circulaire",
     91    'section_puiss'   => "Section Puissance",
     92    'surf_mouille'    => "La surface mouillée (m²)",
    4593    //T
    46     'tirant_eau'      => 'Tirant d\'eau (m)',
     94    'tirant_eau'      => "Tirant d'eau (m)",
     95    'type_materiau'   => "Type du matériau",
     96    'tuyau_lisse1'    => "Tuyau hydrauliquement lisse - 0.05 ≤ D ≤ 0.2",
     97    'tuyau_lisse2'    => "Tuyau hydrauliquement lisse - 0.25 ≤ D ≤ 1",
     98    'type_section'    => "Type de section",
     99    'tirant_eau_crit' => "Le tirant d'eau critique (m)",
     100    'tirant_eau_norm' => "Le tirant d'eau normal (m)",
     101    'tirant_eau_fluv' => "Le tirant d'eau fluvial (m)",
     102    'tirant_eau_torr' => "Le tirant d'eau torrentiel (m)",
     103    'tirant_eau_conj' => "Le tirant d'eau conjugué (m)",
    47104    //V
    48     'valeur_positive' => 'Cette valeur doit être strictement positive'
     105    'valeur_positive' => "Cette valeur doit être strictement positive",
     106    'valeur_positive_nulle' => "Cette valeur doit être positive ou nulle",
     107    'val_min'         => "De la valeur minimum",
     108    'val_max'         => "A la valeur maximum",
     109    'varier_val'      => "Paramètre à varier",
     110    'val_min'         => "De la Valeur minimum",
     111    'val_max'         => "A la Valeur maximum",
     112    'varier_val'      => "Paramètre à varier",
     113    'vit_moy'         => "La vitesse moyenne (m/s)",
     114    'var_lin'         => "Variation linéaire de l'énergie spécifique (m/m)",
     115
    49116);
    50117
  • _plugins_/hydraulic/trunk/plugin.xml

    r57841 r59892  
    11<plugin>
    2         <nom><multi>
    3         [fr]Calculette d'hydraulique
    4         [en]Calculator for hydraulic</multi></nom>
    5         <auteur>David Dorchies</auteur>
    6         <licence>GNU/GLP</licence>
    7         <version>0.3.0-alpha</version>
    8         <necessite id="lib:dist" src="https://bitbucket.org/cleonello/jqplot/downloads/jquery.jqplot.1.0.0b2_r1012.zip" />
    9         <slogan>
    10                 <multi>[fr]Des calculs d'hydraulique sous SPIP !
    11                 [en]Hydraulic calculations on SPIP !</multi>
    12         </slogan>
    13         <description>
    14         <multi>
     2    <nom><multi>
     3    [fr]Calculette d'hydraulique
     4    [en]Calculator for hydraulic</multi></nom>
     5    <auteur>David Dorchies, Médéric Dulondel</auteur>
     6    <licence>GNU/GLP</licence>
     7    <version>0.4.1</version>
     8    <necessite id="lib:dist" src="https://bitbucket.org/cleonello/jqplot/downloads/jquery.jqplot.1.0.0b2_r1012.zip" />
     9    <slogan>
     10        <multi>[fr]Des calculs d'hydraulique sous SPIP !
     11        [en]Hydraulic calculations on SPIP !</multi>
     12    </slogan>
     13    <description>
     14    <multi>
    1515[fr]Calculatrice permettant d'effectuer des calculs en hydraulique adapt&#233;s aux canaux et cours d'eau. Le plugin se pr&#233;sente
    16 sous la forme de mod&#232;les &#224; ins&#233;rer dans des articles, rubriques ou squelettes.
     16sous la forme de formulaires &#224; ins&#233;rer dans des articles, rubriques ou squelettes.
    1717
    18 Les modules de calcul disponibles sont :
    19 -*&lt;hyd|courberemous&gt; : Calcul d'une courbe de remous dans un canal trap&#233;zoïdal &#224; surface libre
     18Les formulaires de calcul disponibles sont :
     19-*&lt;formulaire|courbe_remous&gt; : Calcul d'une courbe de remous dans un canal à section paramétrée &#224; surface libre
     20-*&lt;formulaire|lechapt_calmon&gt; : Calculs pour une conduite circulaire en charge avec la formule de Lechapt et Calmon
    2021[en]Calculator for performing calculations in hydraulic adapted to canals and rivers. The plugin comes
    21 as models to be inserted into articles, sections or skeletons.
     22as forms to be inserted into articles, sections or skeletons.
    2223
    23 Calculation modules available:
    24 -* &lt;hyd|courberemous&gt; : Calculation of a backwater curve in a trapezoidal channel with free surface
    25         </multi>
    26         </description>
    27         <icon>logo32.png</icon>
    28         <categorie>divers</categorie>
    29         <lien>http://sic.g-eau.net/spip.php?rubrique80</lien>
    30         <necessite id="SPIP" version="[2.0.10;2.1.99]" />
    31         <etat>dev</etat>
    32         <prefix>hydraulic</prefix>
    33         <pipeline>
    34                 <nom>insert_head</nom>
    35                 <inclure>hydraulic_pipelines.php</inclure>
    36         </pipeline>
     24Calculation forms available:
     25-* &lt;formulaire|courbe_remous&gt; : Calculation of a backwater curve in a parametrized section channel with free surface
     26-* &lt;formulaire|lechapt_calmon&gt; : Calculations on hydraulic head for a circular pipe with Lechapt and Calmon formula
     27    </multi>
     28    </description>
     29    <icon>logo32.png</icon>
     30    <categorie>divers</categorie>
     31    <lien>http://sic.g-eau.net/spip.php?rubrique80</lien>
     32    <necessite id="SPIP" version="[2.1.0;2.1.99]" />
     33    <etat>dev</etat>
     34    <prefix>hydraulic</prefix>
     35    <fonctions>hydraulic_fonctions.php</fonctions>
     36    <pipeline>
     37        <nom>insert_head</nom>
     38        <inclure>hydraulic_pipelines.php</inclure>
     39    </pipeline>
    3740</plugin>
Note: See TracChangeset for help on using the changeset viewer.