Changeset 59544 in spip-zone


Ignore:
Timestamp:
Mar 19, 2012, 9:53:18 AM (8 years ago)
Author:
dorch@…
Message:

575: Ajouter la section circulaire (http://sic.g-eau.net/mantis/view.php?id=575)
+ Hauteur de berge et calcul des débordement sur les autres types de section.

Location:
_plugins_/hydraulic/branches/v0.3
Files:
10 edited
2 moved

Legend:

Unmodified
Added
Removed
  • _plugins_/hydraulic/branches/v0.3/formulaires/courbe_remous.html

    r59311 r59544  
    22
    33<script language="javascript" type="text/javascript" src="#CHEMIN{js/hyd_fonctions.js}"></script>
    4 <script> 
     4<script>
    55//Permet d'afficher ou cacher les champs correspondant à une section.
    66function afficher_cacher() {
    7        
    8         var section = getSelectValue('choix_section');
     7
     8   var section = getSelectValue('choix_section');
    99    var f = document.getElementById("form_courbe_remous");
    1010    if(f) {
    1111       var champs = f.getElementsByTagName("tr");
    1212       for(var i=0, n=champs.length; i<n; i++) {
    13                    
    14                    
     13
     14
    1515          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';
     16            document.getElementById((champs[i].getAttribute("id"))).style.display='table-row';
    2117
    22                  }
    23                        
    24            }
     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      }
    2525    }
    26        
     26
    2727}
    2828</script>
     
    3232   <table class="hyd_formulaire">
    3333      <tbody>
    34                         <tr id="type_section_field">
    35                                 <td colspan="2"><div class="hyd_formulaire_chapitre"><:hydraulic:type_section:></div></td>
    36                         </tr>
     34         <tr id="type_section_field">
     35            <td colspan="2"><div class="hyd_formulaire_chapitre"><:hydraulic:type_section:></div></td>
     36         </tr>
    3737
    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                                                 <option value="FT" [(#ENV{lTypeSection}|=={'FT'}|?{'selected',''})]><:hydraulic:section_trap:></option>
    46                                                 <option value="FR" [(#ENV{lTypeSection}|=={'FR'}|?{'selected',''})]><:hydraulic:section_rect:></option>
    47                                                 <option value="FC" [(#ENV{lTypeSection}|=={'FC'}|?{'selected',''})]><:hydraulic:section_circ:></option>
    48                                                 <option value="FP" [(#ENV{lTypeSection}|=={'FP'}|?{'selected',''})]><:hydraulic:section_puiss:></option>
    49                                         </select>
    50                  
    51                                         [<div class='hyd_erreur'>(#ENV**{erreurs}|table_valeur{[(#VALEUR|table_valeur{0})]})</div>]
    52                                 </td>
    53                                                
    54                         </tr>
    55                        
    56                
     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                  <option value="FT" [(#ENV{lTypeSection}|=={'FT'}|?{'selected',''})]><:hydraulic:section_trap:></option>
     46                  <option value="FR" [(#ENV{lTypeSection}|=={'FR'}|?{'selected',''})]><:hydraulic:section_rect:></option>
     47                  <option value="FC" [(#ENV{lTypeSection}|=={'FC'}|?{'selected',''})]><:hydraulic:section_circ:></option>
     48                  <option value="FP" [(#ENV{lTypeSection}|=={'FP'}|?{'selected',''})]><:hydraulic:section_puiss:></option>
     49               </select>
     50
     51               [<div class='hyd_erreur'>(#ENV**{erreurs}|table_valeur{[(#VALEUR|table_valeur{0})]})</div>]
     52            </td>
     53
     54         </tr>
     55
     56
    5757            <BOUCLE_fieldChamps(POUR){tableau #ENV{mes_saisies}}>
    58                                
    59                                  #SET{id_fieldset, #CLE}
    60                                
    61                                  <tr id="#GET{id_fieldset}_field" style="display:[(#CLE|match{^([(#ENV{lTypeSection})]|Caract_bief|Cond_lim|Param_calc)$}|?{'table-row','none'})];">   
    62                                          <td colspan="2"><div class="hyd_formulaire_chapitre">[(#VALEUR|table_valeur{0}|traduction_libelle)]</div></td>
    63                                 </tr>
    64                                
    65                                 <BOUCLE_champsLib(POUR){tableau (#VALEUR|table_valeur{1})}>
    66                                                                                
    67                                         <tr id="#GET{id_fieldset}_#CLE" style="display:[(#GET{id_fieldset}|match{^([(#ENV{lTypeSection})]|Caract_bief|Cond_lim|Param_calc)$}|?{'table-row','none'})];">
    68                                                 <td align="right" width="65%">
    69                                                         [(#VALEUR|table_valeur{0}|traduction_libelle)] :       
    70                                                 </td>
    71                                                
    72                                                 <td width="35%">
    73                                                    <input type="text" value="[(#ENV{#GET{id_fieldset}_#CLE})]" maxlength="30" name="#GET{id_fieldset}_#CLE">
    74                                                    [<div class='hyd_erreur'>(#ENV**{erreurs}|table_valeur{#GET{id_fieldset}_#CLE})</div>]
    75                                                 </td>
    76                                                
    77                                         </tr>
    78                                        
    79                                 </BOUCLE_champsLib>
    8058
    81                         </BOUCLE_fieldChamps>
     59             #SET{id_fieldset, #CLE}
    8260
    83                         <tr>
    84                                 <td colspan="2" class="hyd_bouton_submit">
    85                                    <input type="submit" value="<:hydraulic:calculer_remous:>">
    86                                 </td>
    87                         </tr>
    88                        
     61             <tr id="#GET{id_fieldset}_field" style="display:[(#CLE|match{^([(#ENV{lTypeSection})]|Caract_bief|Cond_lim|Param_calc)$}|?{'table-row','none'})];">
     62                <td colspan="2"><div class="hyd_formulaire_chapitre">[(#VALEUR|table_valeur{0}|traduction_hydraulic)]</div></td>
     63            </tr>
     64
     65            <BOUCLE_champsLib(POUR){tableau (#VALEUR|table_valeur{1})}>
     66
     67               <tr id="#GET{id_fieldset}_#CLE" style="display:[(#GET{id_fieldset}|match{^([(#ENV{lTypeSection})]|Caract_bief|Cond_lim|Param_calc)$}|?{'table-row','none'})];">
     68                  <td align="right" width="65%">
     69                     [(#VALEUR|table_valeur{0}|traduction_hydraulic)] :
     70                  </td>
     71
     72                  <td width="35%">
     73                     <input type="text" value="[(#ENV{#GET{id_fieldset}_#CLE})]" maxlength="30" name="#GET{id_fieldset}_#CLE">
     74                     [<div class='hyd_erreur'>(#ENV**{erreurs}|table_valeur{#GET{id_fieldset}_#CLE})</div>]
     75                  </td>
     76
     77               </tr>
     78
     79            </BOUCLE_champsLib>
     80
     81         </BOUCLE_fieldChamps>
     82
     83         <tr>
     84            <td colspan="2" class="hyd_bouton_submit">
     85               <input type="submit" value="<:hydraulic:calculer_remous:>">
     86            </td>
     87         </tr>
     88
    8989      </tbody>
    9090   </table>
  • _plugins_/hydraulic/branches/v0.3/formulaires/courbe_remous.php

    r59347 r59544  
    7878                                             'rKs'    =>array('coef_strickler',50),
    7979                                             'rLong'  =>array('longueur_bief', 50),
    80                                              'rIf'    =>array('pente_fond', 0.005)
     80                                             'rIf'    =>array('pente_fond', 0.005),
     81                                             'rYBerge'     =>array('haut_berge',1)
    8182                                            )
    8283                ),
     
    140141
    141142function formulaires_courbe_remous_verifier_dist(){
     143
     144
    142145    $erreurs = array();
    143146    $datas = array();
     
    166169function formulaires_courbe_remous_traiter_dist(){
    167170    global $spip_lang;
    168 /*
    169 $fdbg = fopen('debug.log','w');
    170 */
    171171    include_spip('hyd_inc/section.class');
    172172    include_spip('hyd_inc/cache');
    173173    include_spip('hyd_inc/log.class');
    174     include_spip('hyd_inc/calcul');
     174    include_spip('hyd_inc/courbe_remous');
    175175    include_spip('hyd_inc/graph.class');
    176176
     
    212212    }
    213213
    214     // Initialisation du format d'affichage des réels
    215     $iPrec=(int)-log10($Param_calc_rPrec);
    216 
    217214    // Contrôle du nombre de pas d'espace maximum
    218215    $iPasMax = 1000;
     
    224221
    225222    // Enregistrement des paramètres dans les classes qui vont bien
    226     $oParam= new cParam($Cond_lim_rYaval,$Caract_bief_rKs,$Cond_lim_rQ,$Caract_bief_rLong,$Caract_bief_rIf,$Param_calc_rDx,$Param_calc_rPrec);
     223    $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);
    227224
    228225    switch($lTypeSection) {
    229226        case 'FT':
    230227            include_spip('hyd_inc/sectionTrapez.class');
    231             $oSection=new cSnTrapez($oParam,$FT_rLarg,$FT_rFruit);
     228            $oSection=new cSnTrapez($oLog,$oParam,$FT_rLarg,$FT_rFruit);
    232229            break;
    233230
    234231        case 'FR':
    235232            include_spip('hyd_inc/sectionRectang.class');
    236             $oSection=new cSnRectang($oParam,$FR_rLarg);
     233            $oSection=new cSnRectang($oLog,$oParam,$FR_rLarg);
    237234            break;
    238235
    239236        case 'FC':
    240237            include_spip('hyd_inc/sectionCirc.class');
    241             $oSection=new cSnCirc($oParam,$FC_rDiam);
     238            $oSection=new cSnCirc($oLog,$oParam,$FC_rDiam);
    242239            break;
    243240
     
    247244        default:
    248245            include_spip('hyd_inc/sectionTrapez.class.php');
    249             $oSection=new cSnTrapeze($oParam,$FT_rLarg,$FT_rFruit);
    250     }
    251 
    252 
     246            $oSection=new cSnTrapeze($oLog,$oParam,$FT_rLarg,$FT_rFruit);
     247    }
    253248
    254249    /***************************************************************************
     
    258253    if(!$bNoCache && is_file(HYD_CACHE_DIRECTORY.$CacheFileName)) {
    259254        // On récupère toutes les données dans un cache déjà créé
    260         list($tr,$sLog) = ReadCacheFile($CacheFileName);
     255        list($tr,$sLog,$oSection->rHautCritique,$oSection->rHautNormale) = ReadCacheFile($CacheFileName);
    261256    }
    262257    else {
    263258        // On calcule les données pour créer un cache et afficher le résultat
    264         $oLog->Add(_T('hydraulic:h_critique').' = '.format_nombre($oSection->rHautCritique,$iPrec).' m');
    265         $oLog->Add(_T('hydraulic:h_normale').' = '.format_nombre($oSection->rHautNormale,$iPrec).' m');
     259        $oLog->Add(_T('hydraulic:largeur_berge').' = '.format_nombre($oSection->rLargeurBerge,$oParam->iPrec).' m');
     260        $oLog->Add(_T('hydraulic:h_critique').' = '.format_nombre($oSection->CalcGeo('Yc'),$oParam->iPrec).' m');
     261        $oLog->Add(_T('hydraulic:h_normale').' = '.format_nombre($oSection->CalcGeo('Yn'),$oParam->iPrec).' m');
    266262
    267263        // Calcul depuis l'aval
    268264        if($oSection->rHautCritique <= $Cond_lim_rYaval) {
    269265            $oLog->Add(_T('hydraulic:calcul_fluvial'));
    270             list($tr['X1'],$tr['Y1']) = calcul_courbe_remous($oParam,$oSection,$oLog,$iPrec);
     266            list($tr['X1'],$tr['Y1']) = calcul_courbe_remous($oParam,$oSection,$oLog,$oParam->iPrec);
    271267        }
    272268        else {
     
    279275            $oParam->rYCL = $Cond_lim_rYamont; // Condition limite amont
    280276            $oParam->rDx = -$oParam->rDx; // un pas négatif force le calcul à partir de l'amont
    281             list($tr['X2'],$tr['Y2']) = calcul_courbe_remous($oParam,$oSection,$oLog,$iPrec);
     277            list($tr['X2'],$tr['Y2']) = calcul_courbe_remous($oParam,$oSection,$oLog,$oParam->iPrec);
    282278        }
    283279        else {
     
    288284        $sLog = $oLog->Result();
    289285        //Enregistrement des données dans fichier cache
    290         WriteCacheFile($CacheFileName,array($tr,$sLog));
     286        WriteCacheFile($CacheFileName,array($tr,$sLog,$oSection->rHautCritique,$oSection->rHautNormale));
    291287    }
    292288    //Construction d'un tableau des indices x combinant les abscisses des 2 lignes d'eau
     
    303299    ****************************************************************************/
    304300    $oGraph = new cGraph();
    305     // Ligne d'eau fluviale
     301    // Cote des berges
     302    $oGraph->AddSerie(
     303        'berge',
     304        $trX,
     305        $oParam->rYB,  // La cote des berges sera calculée à partir de la pente fournie dans GetGraph
     306        '#C58f50',
     307        'lineWidth:1');
     308    // Cote du fond
     309    $oGraph->AddSerie(
     310        'fond',
     311        $trX,
     312        0,  // La cote du fond sera calculée à partir de la pente fournie dans GetGraph
     313        '#753f00',
     314        'lineWidth:1, fill:true');
     315   // Ligne d'eau fluviale
    306316    if(isset($tr['Y1'])) {
    307317        $oGraph->AddSerie(
     
    309319            $tr['X1'],
    310320            $tr['Y1'],
    311             '#00a3cd',
     321            '#0093bd',
    312322            'lineWidth:3, showMarker:true, markerOptions:{style:\'filledCircle\', size:8}');
    313323    }
     
    321331            'lineWidth:3, showMarker:true, markerOptions:{style:\'filledCircle\', size:8}');
    322332    }
    323     // Cote du fond
    324     $oGraph->AddSerie(
    325         'fond',
    326         $trX,
    327         0,  // La cote du fond sera calculée à partir de la pente fournie dans GetGraph
    328         '#753f00',
    329         'lineWidth:1, fill:true');
    330333    // Hauteur critique
    331334    $oGraph->AddSerie(
     
    334337        $oSection->rHautCritique,  // La cote du fond sera calculée à partir de la pente fournie dans GetGraph
    335338        '#ff0000',
    336         'lineWidth:1');
     339        'lineWidth:2');
    337340    // Hauteur normale
    338341    $oGraph->AddSerie(
     
    341344        $oSection->rHautNormale,  // La cote du fond sera calculée à partir de la pente fournie dans GetGraph
    342345        '#a4c537',
    343         'lineWidth:1');
     346        'lineWidth:2');
    344347
    345348    // Décalage des données par rapport au fond
     
    375378        $echo.='<tr class="';
    376379        $echo.=($i%2==0)?'row_even':'row_odd';
    377         $echo.='"><td>'.format_nombre($rX,$iPrec).'</td>';
     380        $echo.='"><td>'.format_nombre($rX,$oParam->iPrec).'</td>';
    378381        if(isset($tr['X1']) && !(($cle = array_search($rX,$tr['X1'])) === false)) {
    379             $echo .= '<td>'.format_nombre($tr['Y1'][$cle],$iPrec).'</td>';
    380             $echo .= '<td>'.format_nombre($oSection->Calc('Fr', $tr['Y1'][$cle]),$iPrec).'</td>';
     382            $echo .= '<td>'.format_nombre($tr['Y1'][$cle],$oParam->iPrec).'</td>';
     383            $echo .= '<td>'.format_nombre($oSection->Calc('Fr', $tr['Y1'][$cle]),$oParam->iPrec).'</td>';
    381384        }
    382385        else {
     
    384387        }
    385388        if(isset($tr['X2']) && !(($cle = array_search($rX,$tr['X2'])) === false)) {
    386             $echo .= '<td>'.format_nombre($tr['Y2'][$cle],$iPrec).'</td>';
    387             $echo .= '<td>'.format_nombre($oSection->Calc('Fr', $tr['Y2'][$cle]),$iPrec).'</td>';
     389            $echo .= '<td>'.format_nombre($tr['Y2'][$cle],$oParam->iPrec).'</td>';
     390            $echo .= '<td>'.format_nombre($oSection->Calc('Fr', $tr['Y2'][$cle]),$oParam->iPrec).'</td>';
    388391        }
    389392        else {
  • _plugins_/hydraulic/branches/v0.3/hyd_inc/courbe_remous.php

    r59537 r59544  
    1919   $trX[] = (real)round($xDeb,$iPrec);
    2020   $trY[] = (real)$oParam->rYCL;
    21    $oSection->rY = (real)$oParam->rYCL;
    2221
    2322   // Boucle de calcul de la courbe de remous
  • _plugins_/hydraulic/branches/v0.3/hyd_inc/newton.class.php

    r59347 r59544  
    4949    private $rFnPrec=0; /// Mémorisation du Fn précédent pour détecter le changement de signe
    5050    private $iOscil=0; /// Nombre de changement de signe de Delta
     51    private $oLog;
    5152
    5253    /**
     
    8485        $this->iCpt++;
    8586        $rFn=$this->CalcFn($rX);
    86         //~ echo('</br>Newton '.$this->iCpt.' Relax='.$this->rRelax.'- f('.$rX.') = '.$rFn);
     87        //echo('</br>Newton '.$this->iCpt.' Relax='.$this->rRelax.'- f('.$rX.') = '.$rFn);
    8788        if($this->FuzzyEqual($rFn) || $this->iCpt >= $this->iCptMax) {
    8889            return $rX;
     
    9091        else {
    9192            $rDer=$this->CalcDer($rX);
    92             //~ echo(' - f\' = '.$rDer);
     93            //echo(' - f\' = '.$rDer);
    9394            if($rDer!=0) {
     95/*
    9496                if($this->rRelax > 1) {
    9597                    // On réduit progressivement le coef de relaxation
    96                     $this->rRelax *= 0.25;
     98                    $this->rRelax *= 1;
    9799                }
     100*/
    98101                if($rFn < 0 xor $this->rFnPrec < 0) {
    99102                    $this->nOscil++;
     
    102105                        $this->rRelax = 1;
    103106                    }
    104                     else {
     107                    elseif($this->nOscil>2) {
    105108                        // On est dans le cas d'une oscillation autour de la solution
    106109                        // On réduit le coefficient de relaxation
     
    111114                $this->rFnPrec = $rFn;
    112115                $Delta = $rFn / $rDer;
    113                 while($rX - $Delta*$this->rRelax <= 0 && $this->rRelax > 1E-5) {
     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) {
    114122                    // On diminue le coeficient de relaxation si on passe en négatif
    115                     $this->rRelax *= 0.1;
     123                    $rRelax *= 0.5; // Mais on ne le mémorise pas pour les itérations suivantes
    116124                }
    117                 while(abs($Delta*$this->rRelax) < $this->rTol && $this->rRelax < 2^20) {
    118                     // On augmente le coefficicient de relaxation s'il est trop petit
    119                     $this->rRelax *= 2; // Mais on ne le mémorise pas pour les itérations suivantes
    120                 }
    121                 $rX = $rX - $Delta*$this->rRelax;
     125                $rX = $rX - $Delta*$rRelax;
    122126                $this->rDelta = $Delta;
    123127                if($rX<0) {$rX = $this->rTol;} // Aucune valeur recherchée ne peut être négative ou nulle
     
    130134        }
    131135    }
     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        }
    132148}
    133149
  • _plugins_/hydraulic/branches/v0.3/hyd_inc/section.class.php

    r59347 r59544  
    3838    public $rPrec;  /// Précision de calcul et d'affichage
    3939    public $rG=9.81;/// Constante de gravité
    40 
    41     function __construct($rYCL,$rKs, $rQ, $rLong, $rIf, $rDx, $rPrec) {
     40    public $iPrec;  /// Précision en nombre de décimales
     41
     42    function __construct($rYCL,$rKs, $rQ, $rLong, $rIf, $rDx, $rPrec, $rYB) {
    4243        $this->rYCL=(real) $rYCL;
    4344        $this->rKs=(real) $rKs;
     
    4748        $this->rDx=(real) $rDx;
    4849        $this->rPrec=(real) $rPrec;
     50        $this->rYB=(real) $rYB;
     51        $this->iPrec=(int)-log10($rPrec);
    4952    }
    5053}
    5154
    5255/**
    53  * Gestion commune pour les différents types de section
     56 * Gestion commune pour les différents types de section.
     57 * Comprend les formules pour la section rectangulaire pour gérer les débordements
    5458 */
    5559abstract class acSection {
     
    6064    //~ public $rJ;             /// Perte de charge
    6165    //~ public $rFr;                /// Froude
    62     public $rY;          /// Tirant d'eau
     66    protected $rY=0;          /// Tirant d'eau
    6367    public $rHautCritique;  /// Tirant d'eau critique
    6468    public $rHautNormale;   /// Tirant d'eau normal
    6569    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)
    6673    /**
    6774     * Tableau contenant les données dépendantes du tirant d'eau $this->rY.
     
    8087     */
    8188    private $arCalc = array();
     89    protected $arCalcGeo = array(); /// Données ne dépendant pas de la cote de l'eau
    8290
    8391    /**
     
    8593     * Calcul des hauteurs normale et critique
    8694     */
    87     public function __construct($oP) {
     95    public function __construct(&$oLog,&$oP) {
     96      $this->oP = &$oP;
     97      $this->CalcGeo('B');
    8898      //spip_log($this,'hydraulic');
    89       $this->oP = $oP;
    90       $oHautCritique = new cHautCritique($this, $oP);
    91       $this->rHautCritique = $oHautCritique->Newton($oP->rPrec);
    92       $oHautNormale= new cHautNormale($this, $oP);
    93       $this->rHautNormale = $oHautNormale->Newton($this->rHautCritique);
    9499    }
    95100
     
    97102     * Efface toutes les données calculées pour forcer le recalcul
    98103     */
    99     public function Reset() {
     104    public function Reset($bGeo=true) {
    100105        $this->arCalc = array();
     106        if($bGeo) {
     107         $this->arCalcGeo = array();
     108      }
    101109    }
    102110
     
    109117    public function Calc($sDonnee, $rY = false) {
    110118        if($rY!==false && $rY!=$this->rY) {
    111             spip_log('Calc('.$sDonnee.') rY='.$rY,'hydraulic');
     119            //spip_log('Calc('.$sDonnee.') rY='.$rY,'hydraulic');
    112120            $this->rY = $rY;
    113             // On efface toutes les données calculées pour forcer le calcul
    114             $this->Reset();
     121            // On efface toutes les données dépendantes de Y pour forcer le calcul
     122            $this->Reset(false);
    115123        }
    116124
     
    154162                    $this->arCalc[$sDonnee] = $this->CalcHs();
    155163                    break;
    156                 case 'Yc' : // Tirant d'eau critique
    157                     $this->arCalc[$sDonnee] = $this->CalcYc();
    158                     break;
    159                 case 'Yn' : // Tirant d'eau normal
    160                     $this->arCalc[$sDonnee] = $this->CalcYn();
    161                     break;
    162164                case 'Yf' : // Tirant d'eau fluvial
    163165                    $this->arCalc[$sDonnee] = $this->CalcYf();
     
    186188            }
    187189        }
    188         spip_log('Calc('.$sDonnee.')='.$this->arCalc[$sDonnee],'hydraulic');
     190        //spip_log('Calc('.$sDonnee.')='.$this->arCalc[$sDonnee],'hydraulic');
    189191        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                case 'Yg' : // Distance du centre de gravité de la section à la surface libre
     234                    $this->arCalcGeo[$sDonnee] = $this->CalcYg();
     235                    break;
     236            }
     237        }
     238        //spip_log('CalcGeo('.$sDonnee.')='.$this->arCalcGeo[$sDonnee],'hydraulic');
     239        return $this->arCalcGeo[$sDonnee];
    190240    }
    191241
     
    194244     * @return La surface hydraulique
    195245     */
    196     abstract protected function CalcS();
     246    protected function CalcS($rY) {
     247        return $rY*$this->rLargeurBerge;
     248    }
    197249
    198250    /**
     
    200252     * @return dS
    201253     */
    202     abstract protected function CalcSder();
     254    protected function CalcSder() {
     255        return $this->rLargeurBerge;
     256    }
    203257
    204258   /**
     
    206260    * @return Le périmètre hydraulique
    207261    */
    208     abstract protected function CalcP();
    209 
     262    protected function CalcP($rY) {
     263        return 2*$rY;
     264    }
    210265    /**
    211266     * Calcul de dérivée du périmètre hydraulique par rapport au tirant d'eau.
    212267     * @return dP
    213268     */
    214     abstract protected function CalcPder();
     269    protected function CalcPder() {
     270        return 2;
     271    }
    215272
    216273   /**
     
    244301    * @return La largeur au miroir
    245302    */
    246     abstract protected function CalcB();
    247 
     303    protected function CalcB() {
     304        return $this->rLargeurBerge;
     305    }
    248306    /**
    249307     * Calcul de dérivée de la largeur au miroir par rapport au tirant d'eau.
    250308     * @return dB
    251309     */
    252     abstract protected function CalcBder();
     310    protected function CalcBder() {
     311        return 0;
     312    }
    253313
    254314   /**
     
    273333    */
    274334    public function CalcY_M1($Y) {
    275         $this->Reset(); // On réinitialise toutes les données dépendant de la ligne d'eau
    276         $this->rY = $Y; // Tirant d'eau initial pour le calcul du point suivant
    277         return $Y-($this->oP->rDx*($this->oP->rIf-$this->Calc('J'))/(1-pow($this->Calc('Fr'),2)));
     335        // L'appel à Calc('J') avec Y en paramètre réinitialise toutes les données dépendantes de la ligne d'eau
     336        return $Y-($this->oP->rDx*($this->oP->rIf-$this->Calc('J',$Y))/(1-pow($this->Calc('Fr',$Y),2)));
    278337    }
    279338
     
    299358    */
    300359    private function CalcYc() {
    301         $oHautCritique = new cHautCritique($this, $oP);
    302         return $oHautCritique->Newton($oP->rPrec);
     360        $oHautCritique = new cHautCritique($this, $this->oP);
     361        if(!$this->rHautCritique = $oHautCritique->Newton($this->oP->rPrec) or !$oHautCritique->HasConverged()) {
     362         $this->oLog(_T('hydraulic:h_critique').' : '._T('hydraulic:newton_non_convergence'));
     363      }
     364      return $this->rHautCritique;
    303365    }
    304366
     
    308370    */
    309371    private function CalcYn() {
    310         $oHautNormale= new cHautNormale($this, $oP);
    311         return $oHautNormale->Newton($this->Calc('Yc'));
     372        $oHautNormale= new cHautNormale($this, $this->oP);
     373        if(!$this->rHautNormale = $oHautNormale->Newton($this->CalcGeo('Yc')) or !$oHautNormale->HasConverged()) {
     374         $this->oLog(_T('hydraulic:h_normale').' : '._T('hydraulic:newton_non_convergence'));
     375      }
     376        return $this->rHautNormale;
    312377    }
    313378
     
    360425     * @return Distance du centre de gravité de la section à la surface libre
    361426     */
    362     abstract protected function CalcYg();
    363 
     427    protected function CalcYg($rY) {
     428        return $rY / 2;
     429    }
    364430    /**
    365431     * Calcul de l'impulsion hydraulique.
     
    413479     */
    414480    protected function CalcFn($rX) {
    415         // Initialisation des données de la section
    416         $this->oSn->Reset();
    417         $this->oSn->rY = $rX;
    418481        // Calcul de la fonction
    419         $rFn = (pow($this->oP->rQ,2)/pow($this->oSn->Calc('S'),2)*($this->oSn->Calc('B')/$this->oSn->Calc('S')/$this->oP->rG)-1);
     482        $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);
    420483        spip_log('cHautCritique:CalcFn('.$rX.')='.$rFn,'hydraulic');
    421484        return $rFn;
     
    449512     * @param $oP Paramètres supplémentaires (Débit, précision...)
    450513     */
    451     function __construct(acSection $oSn, cParam $oP) {
     514    function __construct($oSn, cParam $oP) {
    452515        $this->oSn=$oSn;
    453516        $this->rQ=$oP->rQ;
     
    464527     */
    465528    protected function CalcFn($rX) {
    466         // Initialisation des données de la section
    467         $this->oSn->Reset();
    468         $this->oSn->rY = $rX;
    469529        // Calcul de la fonction
    470         $rFn = ($this->rQ-$this->rKs*pow($this->oSn->Calc('R'),2/3)*$this->oSn->Calc('S')*sqrt($this->rIf));
     530        $rFn = ($this->rQ-$this->rKs*pow($this->oSn->Calc('R',$rX),2/3)*$this->oSn->Calc('S',$rX)*sqrt($this->rIf));
    471531        spip_log('cHautNormale:CalcFn('.$rX.')='.$rFn,'hydraulic');
    472532        return $rFn;
     
    515575     */
    516576    protected function CalcFn($rX) {
    517         // Initialisation des données de la section
    518         $this->oSnCal->Reset();
    519         $this->oSnCal->rY = $rX;
    520577        // Calcul de la fonction
    521         $rFn = $this->rY - $rX + ($this->rV2+pow($this->oSnCal->Calc('V'),2))/(2*$this->rG);
     578        $rFn = $this->rY - $rX + ($this->rV2+pow($this->oSnCal->Calc('V',$rX),2))/(2*$this->rG);
    522579        spip_log('cHautCorrespondante:CalcFn('.$rX.')='.$rFn,'hydraulic');
    523580        return $rFn;
  • _plugins_/hydraulic/branches/v0.3/hyd_inc/sectionCirc.class.php

    r59347 r59544  
    3333    private $rAlpha;    /// Angle de la surface libre par rapport au fond
    3434
    35     function __construct($oP,$rD) {
     35    function __construct(&$oLog,&$oP,$rD) {
    3636        $this->rD=(real) $rD;
    37         parent::__construct($oP);
     37        if($oP->rYB > $rD) {$oP->rYB = $rD;} // On place la berge au sommet du cercle
     38        parent::__construct($oLog,$oP);
    3839    }
    3940
     
    4344     */
    4445    protected function CalcAlpha() {
    45         if($this->rY <= 0) {
    46             spip_log('CalcAlpha('.$this->rY.')=0','hydraulic');
     46                if($this->rY > $this->oP->rYB) {
     47                        $rY = $this->oP->rYB;
     48                }
     49                else {
     50                        $rY = $this->rY;
     51                }
     52        if($rY <= 0) {
    4753            return 0;
    4854        }
    49         elseif($this->rY > $this->rD) {
    50             spip_log('CalcAlpha('.$this->rY.')='.pi(),'hydraulic');
     55        elseif($rY > $this->rD) {
    5156            return pi();
    5257        }
    5358        else {
    54             $alpha = acos(1.-$this->rY/($this->rD/2.));
     59            $alpha = acos(1.-$rY/($this->rD/2.));
    5560            if($alpha > pi()) {
    56                 spip_log('CalcAlpha('.$this->rY.')='.pi(),'hydraulic');
    5761                return pi();
    5862            }
    5963            else {
    60                 spip_log('CalcAlpha('.$this->rY.')='.$alpha,'hydraulic');
    6164                return $alpha;
    6265            }
     
    6972     */
    7073    protected function CalcAlphaDer() {
    71         if($this->rY <= 0 or $this->rY > $this->rD) {
    72             spip_log('CalcAlphaDer('.$this->rY.')=0','hydraulic');
     74        if($this->rY <= 0 or $this->rY > $this->rD or $this->rY > $this->oP->rYB) {
    7375            return 0;
    7476        }
    7577        else {
    76             spip_log('CalcAlphaDer('.$this->rY.')='.(2. / $this->rD / sqrt(1 - pow(1 - 2 * $this->rY / $this->rD,2))),'hydraulic');
    7778            return 2. / $this->rD / sqrt(1. - pow(1. - 2. * $this->rY / $this->rD,2));
    7879        }
     
    8485     */
    8586    protected function CalcB() {
    86         return $this->rD * sin($this->Calc('Alpha'));
     87                if($this->rY > $this->oP->rYB) {
     88                        return parent::CalcB();
     89                }
     90                else {
     91                        return $this->rD * sin($this->Calc('Alpha'));
     92                }
    8793    }
    8894
     
    9298     */
    9399     protected function CalcP() {
    94         return $this->rD * $this->Calc('Alpha');
     100                if($this->rY > $this->oP->rYB and !$this->bSnFermee) {
     101                        // On n'ajoute pas le périmètre dans le cas d'une fente de Preissmann
     102                        return $this->CalcGeo('P') + parent::CalcP($this->rY-$this->oP->rYB);
     103                }
     104                else {
     105                        return $this->rD * $this->Calc('Alpha');
     106                }
    95107    }
    96108
     
    100112     */
    101113    protected function CalcS() {
    102         return pow($this->rD,2) / 4 * ($this->Calc('Alpha') - sin($this->Calc('Alpha')) * cos($this->Calc('Alpha')));
     114                if($this->rY > $this->oP->rYB) {
     115                        return $this->CalcGeo('S') + parent::CalcS($this->rY-$this->oP->rYB);
     116                }
     117                else {
     118                        return pow($this->rD,2) / 4 * ($this->Calc('Alpha') - sin($this->Calc('Alpha')) * cos($this->Calc('Alpha')));
     119                }
    103120    }
    104121
     
    108125     */
    109126    protected function CalcSder() {
    110         return $this->Calc('dAlpha') * $this->rD / 4 * cos(2 * $this->Calc('Alpha'));
     127                if($this->rY > $this->oP->rYB) {
     128                        return parent::CalcSder();
     129                }
     130                else {
     131                        return pow($this->rD,2) / 4 * $this->Calc('dAlpha') * (1 - cos(2 * $this->Calc('Alpha')));
     132                }
    111133    }
    112134
     
    116138     */
    117139    protected function CalcPder() {
    118         return $this->rD * $this->Calc('dAlpha');
     140                if($this->rY > $this->oP->rYB && !$this->bSnFermee) {
     141                        return parent::CalcPder();
     142                }
     143                else {
     144                        return $this->rD * $this->Calc('dAlpha');
     145                }
    119146    }
    120147
     
    124151     */
    125152    protected function CalcBder() {
    126         return $this->rD * $this->Calc('dAlpha') * cos($this->Calc('Alpha'));
     153                if($this->rY > $this->oP->rYB) {
     154                        return parent::CalcBder();
     155                }
     156                else {
     157                        return $this->rD * $this->Calc('dAlpha') * cos($this->Calc('Alpha'));
     158                }
    127159    }
    128160
  • _plugins_/hydraulic/branches/v0.3/hyd_inc/sectionRectang.class.php

    r59347 r59544  
    3030 */
    3131class cSnRectang extends acSection {
    32    public $rLargeurFond; /// largeur au fond
    3332
    34     function __construct($oP,$rLargeurFond) {
    35         $this->rLargeurFond=(real) $rLargeurFond;
    36         parent::__construct($oP);
    37     }
    38 
    39     protected function CalcB() {
    40         return $this->rLargeurFond;
     33    function __construct(&$oLog,&$oP,$rLargeurFond) {
     34                $this->rLargeurBerge = $rLargeurFond;
     35        parent::__construct($oLog,$oP);
    4136    }
    4237
    4338    protected function CalcP() {
    44         return $this->rLargeurFond+2*$this->rY;
     39        return $this->rLargeurBerge+parent::CalcP($this->rY);
    4540    }
    4641
    4742    protected function CalcS() {
    48         return $this->rY*$this->rLargeurFond;
    49     }
    50 
    51     /**
    52      * Calcul de dérivée de la surface hydraulique par rapport au tirant d'eau.
    53      * @return dS
    54      */
    55     protected function CalcSder() {
    56         return $this->rLargeurFond;
    57     }
    58 
    59     /**
    60      * Calcul de dérivée du périmètre hydraulique par rapport au tirant d'eau.
    61      * @return dP
    62      */
    63     protected function CalcPder() {
    64         return 2;
    65     }
    66 
    67     /**
    68      * Calcul de dérivée de la largeur au miroir par rapport au tirant d'eau.
    69      * @return dB
    70      */
    71     protected function CalcBder() {
    72         return 0;
     43        return parent::CalcS($this->rY);
    7344    }
    7445
     
    7849     */
    7950    protected function CalcYg() {
    80         return $this->rY / 2;
     51        return parent::CalcYg($this->rY);
    8152    }
    8253
  • _plugins_/hydraulic/branches/v0.3/hyd_inc/sectionTrapez.class.php

    r59347 r59544  
    3434
    3535
    36     function __construct($oP,$rLargeurFond, $rFruit) {
     36    function __construct(&$oLog,&$oP,$rLargeurFond, $rFruit) {
    3737        $this->rLargeurFond=(real) $rLargeurFond;
    3838        $this->rFruit=(real) $rFruit;
    39         parent::__construct($oP);
     39        parent::__construct($oLog,$oP);
    4040    }
    4141
    42     protected function CalcB() {
    43         return $this->rLargeurFond+2*$this->rFruit*$this->rY;
     42    protected function CalcB($bBerge=false) {
     43                if(!$bBerge && $this->rY > $this->oP->rYB) {
     44                        return $this->rLargeurBerge;
     45                }
     46                else {
     47                        return $this->rLargeurFond+2*$this->rFruit*$this->rY;
     48                }
    4449    }
    4550
    4651    protected function CalcP() {
    47         return $this->rLargeurFond+2*sqrt(1+pow($this->rFruit,2))*$this->rY;
     52        if($this->rY > $this->oP->rYB) {
     53                        return $this->CalcGeo('P') + parent::CalcP($this->rY-$this->oP->rYB);
     54                }
     55                else {
     56                        return $this->rLargeurFond+2*sqrt(1+pow($this->rFruit,2))*$this->rY;
     57                }
    4858    }
    4959
    5060    protected function CalcS() {
    51         return $this->rY*($this->rLargeurFond+$this->rFruit*$this->rY);
     61                if($this->rY > $this->oP->rYB) {
     62                        return $this->CalcGeo('S') + parent::CalcS($this->rY-$this->oP->rYB);
     63                }
     64                else {
     65                        return $this->rY*($this->rLargeurFond+$this->rFruit*$this->rY);
     66                }
    5267    }
    5368
     
    5772     */
    5873    protected function CalcSder() {
    59         return $this->rLargeurFond + 2*$this->rFruit*$this->rY;
     74                if($this->rY > $this->oP->rYB) {
     75                        return parent::CalcSder();
     76                }
     77                else {
     78                        return $this->rLargeurFond + 2*$this->rFruit*$this->rY;
     79                }
    6080    }
    6181
     
    6585     */
    6686    protected function CalcPder() {
    67         return 2*sqrt(1+$this->rFruit*$this->rFruit);
     87                if($this->rY > $this->oP->rYB) {
     88                        return parent::CalcPder();
     89                }
     90                else {
     91                        return 2*sqrt(1+$this->rFruit*$this->rFruit);
     92                }
    6893    }
    6994
     
    7398     */
    7499    protected function CalcBder() {
    75         return 2*$this->rLargeurFond*$this->rFruit;
     100                if($this->rY > $this->oP->rYB) {
     101                        return parent::CalcBder();
     102                }
     103                else {
     104                        return 2*$this->rLargeurFond*$this->rFruit;
     105                }
    76106    }
    77107
  • _plugins_/hydraulic/branches/v0.3/hydraulic_fonctions.php

    r59537 r59544  
    11<?php
    22
    3 function traduction_libelle ($param_a_traiter)
     3function traduction_hydraulic($param_a_traiter)
    44{
    5         return _T('hydraulic:'.$param_a_traiter);
     5   return _T('hydraulic:'.$param_a_traiter);
    66}
    77
  • _plugins_/hydraulic/branches/v0.3/lang/hydraulic_en.php

    r59347 r59544  
    66    'arret_calcul'    => "Calculation stopped: Critical elevation reached at abscissa",
    77    'acier_lamine'    => "Rolled steel - Smooth concrete",
     8    // B
     9    'berge'           => "Embankment",
    810    // C
    911    'calcul_caract'   => "The calculation has the following characteristics:",
     
    2426    'debit_amont'     => "Upstream flow (m3/s)",
    2527    'def_section_trap'=> "Definition of trapezoidal section",
    26         'diametre'                => "Diameter (m)",
     28   'diametre'       => "Diameter (m)",
    2729     // F
    2830    'fond'            => "Bottom",
     
    3739    'h_amont_imposee' => "Water level imposed at the upstream (m)",
    3840    'h_aval_imposee'  => "Downstream water level imposed (m)",
     41    'h_berge'         => "Embankment elevation (m)",
    3942    'h_critique'      => "Critical elevation",
    4043    'h_normale'       => "Normal elevation",
    4144    // L
    4245    'largeur_fond'    => "Width at bottom (m)",
     46    'largeur_berge'   => "Width at embankment level",
    4347    'ligne_eau_fluviale'  => "Subcritical water profile",
    4448    'ligne_eau_torrentielle'  => "Supercritical water profile",
    4549    'log_titre'       => "Calculation's log",
    4650    'longueur_bief'   => "Length of reach (m)",
     51    //N
     52    'newton_non_convergence' => "Non-convergence of the calculation (Newton's method)",
    4753    // P
    4854    'param_calcul'    => "Calculation parameters",
     
    5460    'pas_calcul_depuis_aval' => 'Downstream boundary condition < Critical elevation : no possible calculation from downstream',
    5561    'pas_calcul_depuis_amont' => 'Upstream boundary condition < Critical elevation : no possible calculation from upstream',
    56         'pas_var' => "With a variation step of",
     62   'pas_var' => "With a variation step of",
    5763    'pvc' => "PVC - Polyethylene",
    5864    'param_Q' => "Q: Flow (m³ / s)",
  • _plugins_/hydraulic/branches/v0.3/lang/hydraulic_fr.php

    r59347 r59544  
    66    'arret_calcul'    => "Arrêt du calcul : Hauteur critique atteinte à l'abscisse",
    77    'acier_lamine'    => "Acier laminé - Béton lisse",
     8    // B
     9    'berge'           => "Berge",
    810    // C
    911    'calcul_caract'   => "Le calcul a les caractéristiques suivantes :",
     
    2729    'def_section_circ'=> "Définition de la section circulaire",
    2830    'def_section_puis'=> "Définition de la section puissance",
    29         'diametre'                => "Diamètre (m)",
     31   'diametre'       => "Diamètre (m)",
    3032    // F
    3133    'fond'            => "Fond",
     
    4042    'h_amont_imposee' => "Hauteur d'eau imposée à l'amont (m)",
    4143    'h_aval_imposee'  => "Hauteur d'eau aval imposée (m)",
     44    'h_berge'         => "Hauteur de berge (m)",
    4245    'h_critique'      => "Hauteur critique",
    4346    'h_normale'       => "Hauteur normale",
    4447    // L
    4548    'largeur_fond'    => "Largeur au fond (m)",
     49    'largeur_berge'   => "Largeur au niveau des berges",
    4650    'ligne_eau_fluviale'  => "Ligne d'eau fluviale",
    4751    'ligne_eau_torrentielle'  => "Ligne d'eau torrentielle",
    4852    'log_titre'       => "Journal des calculs",
    4953    'longueur_bief'   => "Longueur du bief (m)",
     54    //N
     55    'newton_non_convergence' => "Non convergence du calcul (Méthode de Newton)",
    5056    // P
    5157    'param_calcul'    => "Paramètres de calcul",
  • _plugins_/hydraulic/branches/v0.3/plugin.xml

    r59347 r59544  
    55    <auteur>David Dorchies, Médéric Dulondel</auteur>
    66    <licence>GNU/GLP</licence>
    7     <version>0.4.0</version>
     7    <version>0.4.1</version>
    88    <necessite id="lib:dist" src="https://bitbucket.org/cleonello/jqplot/downloads/jquery.jqplot.1.0.0b2_r1012.zip" />
    99    <slogan>
     
    2323
    2424Calculation forms available:
    25 -* &lt;hyd|courberemous&gt; : Calculation of a backwater curve in a parametrized section channel with free surface
    26 -* &lt;hyd|courberemous&gt; : Calculations on hydraulic head for a circular pipe with Lechapt and Calmon formula
     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
    2727    </multi>
    2828    </description>
     
    3333    <etat>dev</etat>
    3434    <prefix>hydraulic</prefix>
    35     <fonctions>hydraulic_traductions.php</fonctions>
     35    <fonctions>hydraulic_fonctions.php</fonctions>
    3636    <pipeline>
    3737        <nom>insert_head</nom>
Note: See TracChangeset for help on using the changeset viewer.