Changeset 58731 in spip-zone


Ignore:
Timestamp:
Feb 20, 2012, 5:02:42 PM (8 years ago)
Author:
dorch@…
Message:

Modification de la méthode de calcul avec le Newton (dérivées analytiques).

Location:
_plugins_/hydraulic/branches/v0.3
Files:
5 edited

Legend:

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

    r56971 r58731  
    250250        if(isset($tr['X1']) && !(($cle = array_search($rX,$tr['X1'])) === false)) {
    251251            $echo .= '<td>'.format_nombre($tr['Y1'][$cle],$iPrec).'</td>';
    252             $echo .= '<td>'.format_nombre($oSection->ReCalcFr($oParam, $tr['Y1'][$cle]),$iPrec).'</td>';
     252            $echo .= '<td>'.format_nombre($oSection->Calc('Fr', $tr['Y1'][$cle]),$iPrec).'</td>';
    253253        }
    254254        else {
     
    257257        if(isset($tr['X2']) && !(($cle = array_search($rX,$tr['X2'])) === false)) {
    258258            $echo .= '<td>'.format_nombre($tr['Y2'][$cle],$iPrec).'</td>';
    259             $echo .= '<td>'.format_nombre($oSection->ReCalcFr($oParam, $tr['Y2'][$cle]),$iPrec).'</td>';
     259            $echo .= '<td>'.format_nombre($oSection->Calc('Fr', $tr['Y2'][$cle]),$iPrec).'</td>';
    260260        }
    261261        else {
  • _plugins_/hydraulic/branches/v0.3/hyd_inc

    • Property svn:ignore set to
      *.bat
  • _plugins_/hydraulic/branches/v0.3/hyd_inc/calcul.php

    r56971 r58731  
    2424   for($x = $xDeb + $dx; ($dx > 0 && $x <= $xFin) || ($dx < 0 && $x >= $xFin); $x += $dx) {
    2525      $trX[] = round($x,$iPrec);
    26       $trY[] = (real)$oSection->CalcPasX($oParam, $oSection->rY);
    27       if($oParam->rDx > 0 xor !($oSection->rY < $oSection->rHautCritique)) {
     26      $trY[] = (real)$oSection->CalcY_M1(end($trY));
     27      if($oParam->rDx > 0 xor !(end($trY) < $oSection->rHautCritique)) {
    2828         $oLog->Add(_T('hydraulic:arret_calcul').' '.$x. ' m');
    2929         break;
  • _plugins_/hydraulic/branches/v0.3/hyd_inc/newton.class.php

    r56649 r58731  
    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=50;
    4848
    49    abstract public function CalcFn($rX);
     49    /**
     50     * Calcul de la fonction f(x) dont on cherche le zéro.
     51     * @param $rX x
     52     * @return Calcul de la fonction
     53     */
     54    abstract protected function CalcFn($rX);
    5055
    51    private function CalcDer($x) {
    52       return ($this->CalcFn($x+$this->rDx)-$this->CalcFn($x-$this->rDx))/(2*$this->rDx);
    53    }
     56    /**
     57     * Calcul de la dérivée f'(x) (peut être redéfini pour calcul analytique)
     58     * @param $rX x
     59     * @return Calcul de la fonction
     60     */
     61    protected function CalcDer($x) {
     62        spip_log('Newton:CalcDer $rX='.$x,'hydraulic');
     63        return ($this->CalcFn($x+$this->rDx)-$this->CalcFn($x-$this->rDx))/(2*$this->rDx);
     64    }
    5465
    55    private function FuzzyEqual($rFn) {
    56       return (abs($rFn) < $this->rTol);
    57    }
     66    /**
     67     * Test d'égalité à une tolérance près
     68     * @param $rFn x
     69     * @return True si égal, False sinon
     70     */
     71    private function FuzzyEqual($rFn) {
     72        return (abs($rFn) < $this->rTol);
     73    }
    5874
    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    }
     75    /**
     76     * Fonction récursive de calcul de la suite du Newton
     77     * @param $rX x
     78     * @return Solution du zéro de la fonction
     79     */
     80    public function Newton($rX) {
     81        $this->iCpt++;
     82        $rFn=$this->CalcFn($rX);
     83        //echo $this->iCpt.' - f('.$rX.') = '.$rFn;
     84        if($this->FuzzyEqual($rFn) || $this->iCpt >= $this->iCptMax) {
     85            return $rX;
     86        }
     87        else {
     88            $rDer=$this->CalcDer($rX);
     89            //echo ' - f\\\' = '.$rDer.'<br/>';
     90            if($rDer!=0) {
     91                return $this->Newton($rX-$rFn/$rDer);
     92            }
     93            else {
     94                // Echec de la résolution
     95                return false;
     96            }
     97        }
     98    }
    7499}
    75100
  • _plugins_/hydraulic/branches/v0.3/hyd_inc/section.class.php

    r56649 r58731  
    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    }
    43 }
     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
     41    function __construct($rYCL,$rKs, $rQ, $rLong, $rIf, $rDx, $rPrec) {
     42        $this->rYCL=(real) $rYCL;
     43        $this->rKs=(real) $rKs;
     44        $this->rQ=(real) $rQ;
     45        $this->rLong=(real) $rLong;
     46        $this->rIf=(real) $rIf;
     47        $this->rDx=(real) $rDx;
     48        $this->rPrec=(real) $rPrec;
     49    }
     50}
     51
     52/**
     53 * Gestion commune pour les différents types de section
     54 */
    4455abstract 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
     56    //~ public $rS;             /// Surface hydraulique
     57    //~ public $rP;             /// Périmètre hydraulique
     58    //~ public $rR;             /// Rayon hydraulique
     59    //~ public $rB;             /// Largeur au miroir
     60    //~ public $rJ;             /// Perte de charge
     61    //~ public $rFr;                /// Froude
     62    public $rY;          /// Tirant d'eau
     63    public $rHautCritique;  /// Tirant d'eau critique
     64    public $rHautNormale;   /// Tirant d'eau normal
     65    protected $oP;   /// Paramètres du système canal (classe oParam)
     66    /**
     67     * Tableau contenant les données dépendantes du tirant d'eau $this->rY.
     68     *
     69     * Les clés du tableau peuvent être :
     70     * - S : la surface hydraulique
     71     * - P : le périmètre hydraulique
     72     * - R : le rayon hydraulique
     73     * - B : la largeur au miroir
     74     * - J : la perte de charge
     75     * - Fr : le nombre de Froude
     76     * - dS : la dérivée de S par rapport Y
     77     * - dP : la dérivée de P par rapport Y
     78     * - dR : la dérivée de R par rapport Y
     79     * - dB : la dérivée de B par rapport Y
     80     */
     81    private $arCalc = array();
     82
     83    /**
     84     * Construction de la classe.
     85     * Calcul des hauteurs normale et critique
     86     */
     87    public function __construct($oP) {
    5688      //spip_log($this,'hydraulic');
     89      $this->oP = $oP;
    5790      $oHautCritique = new cHautCritique($this, $oP);
    5891      $this->rHautCritique = $oHautCritique->Newton($oP->rPrec);
    5992      $oHautNormale= new cHautNormale($this, $oP);
    6093      $this->rHautNormale = $oHautNormale->Newton($this->rHautCritique);
     94    }
     95
     96    /**
     97     * Efface toutes les données calculées pour forcer le recalcul
     98     */
     99    public function Reset() {
     100        $this->arCalc = array();
     101    }
     102
     103    /**
     104     * Calcul des données à la section
     105     * @param $sDonnee Clé de la donnée à calculer (voir $this->$arCalc)
     106     * @param $bRecalc Pour forcer le recalcul de la donnée
     107     * @return la donnée calculée
     108     */
     109    public function Calc($sDonnee, $rY = false) {
     110        if($rY!==false) {
     111            //~ spip_log('Calc('.$sDonnee.') rY='.$rY,'hydraulic');
     112            $this->rY = $rY;
     113            if(isset($this->arCalc[$sDonnee])) {
     114                // On efface toutes les données calculées pour forcer le calcul
     115                $this->Reset();
     116            }
     117        }
     118
     119        if(!isset($this->arCalc[$sDonnee])) {
     120            // La donnée a besoin d'être calculée
     121            switch($sDonnee) {
     122                case 'S' :
     123                    $this->arCalc[$sDonnee] = $this->CalcS();
     124                    break;
     125                case 'P' :
     126                    $this->arCalc[$sDonnee] = $this->CalcP();
     127                    break;
     128                case 'R' :
     129                    $this->arCalc[$sDonnee] = $this->CalcR();
     130                    break;
     131                case 'B' :
     132                    $this->arCalc[$sDonnee] = $this->CalcB();
     133                    break;
     134                case 'J' :
     135                    $this->arCalc[$sDonnee] = $this->CalcJ();
     136                    break;
     137                case 'Fr' :
     138                    $this->arCalc[$sDonnee] = $this->CalcFr();
     139                    break;
     140                case 'dS' :
     141                    $this->arCalc[$sDonnee] = $this->CalcSder();
     142                    break;
     143                case 'dP' :
     144                    $this->arCalc[$sDonnee] = $this->CalcPder();
     145                    break;
     146                case 'dR' :
     147                    $this->arCalc[$sDonnee] = $this->CalcRder();
     148                    break;
     149                case 'dB' :
     150                    $this->arCalc[$sDonnee] = $this->CalcBder();
     151            }
     152        }
     153        //~ spip_log('Calc('.$sDonnee.')='.$this->arCalc[$sDonnee],'hydraulic');
     154        return $this->arCalc[$sDonnee];
     155    }
     156
     157    /**
     158     * Calcul de la surface hydraulique.
     159     * Le résultat doit être stocké dans $this->rS
     160     * @return La surface hydraulique
     161     */
     162    abstract protected function CalcS();
     163
     164    /**
     165     * Calcul de dérivée de la surface hydraulique par rapport au tirant d'eau.
     166     * @return dS
     167     */
     168    abstract protected function CalcSder();
     169
     170   /**
     171    * Calcul du périmètre hydraulique.
     172    * @return Le périmètre hydraulique
     173    */
     174    abstract protected function CalcP();
     175
     176    /**
     177     * Calcul de dérivée du périmètre hydraulique par rapport au tirant d'eau.
     178     * @return dP
     179     */
     180    abstract protected function CalcPder();
     181
     182   /**
     183    * Calcul du rayon hydraulique.
     184    * @return Le rayon hydraulique
     185    */
     186    protected function CalcR() {
     187        return $this->Calc('S')/$this->Calc('P');
     188    }
     189
     190    /**
     191     * Calcul de dérivée du rayon hydraulique par rapport au tirant d'eau.
     192     * @return dR
     193     */
     194    protected function CalcRder() {
     195        return ($this->Calc('dS')*$this->Calc('P')-$this->Calc('S')*$this->Calc('dP'))/pow($this->Calc('P'),2);
     196    }
     197
     198   /**
     199    * Calcul de la largeur au miroir.
     200    * @return La largeur au miroir
     201    */
     202    abstract protected function CalcB();
     203
     204    /**
     205     * Calcul de dérivée de la largeur au miroir par rapport au tirant d'eau.
     206     * @return dB
     207     */
     208    abstract protected function CalcBder();
     209
     210   /**
     211    * Calcul de la perte de charge par la formule de Manning-Strickler.
     212    * @return La perte de charge
     213    */
     214    private function CalcJ() {
     215        return pow($this->oP->rQ/$this->Calc('S')/$this->oP->rKs,2)/pow($this->Calc('R'),4/3);
     216    }
     217
     218   /**
     219    * Calcul du nombre de Froude.
     220    * @return Le nombre de Froude
     221    */
     222    private function CalcFr() {
     223        return $this->oP->rQ/$this->Calc('S')*sqrt($this->Calc('B')/$this->Calc('S')/$this->oP->rG);
    61224   }
    62225
    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;
     226   /**
     227    * Calcul du point suivant de la courbe de remous par la méthode Euler explicite.
     228    * @return Tirant d'eau
     229    */
     230    public function CalcY_M1($Y) {
     231        $this->Reset(); // On réinitialise toutes les données dépendant de la ligne d'eau
     232        $this->rY = $Y; // Tirant d'eau initial pour le calcul du point suivant
     233        return $Y-($this->oP->rDx*($this->oP->rIf-$this->Calc('J'))/(1-pow($this->Calc('Fr'),2)));
    70234   }
    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    }
    107 
    108 }
     235}
     236
     237
     238/**
     239 * Calculs de la section trapézoïdale
     240 */
    109241class 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    }
    134 }
     242   public $rLargeurFond;    /// Largeur au fond
     243   public $rFruit;          /// Fruit des berges
     244
     245
     246    function __construct($oP,$rLargeurFond, $rFruit) {
     247        $this->rLargeurFond=(real) $rLargeurFond;
     248        $this->rFruit=(real) $rFruit;
     249        parent::__construct($oP);
     250    }
     251
     252    protected function CalcB() {
     253        return $this->rLargeurFond+2*$this->rFruit*$this->rY;
     254    }
     255
     256    protected function CalcP() {
     257        return $this->rLargeurFond+2*sqrt(1+pow($this->rFruit,2))*$this->rY;
     258    }
     259
     260    protected function CalcS() {
     261        return $this->rY*($this->rLargeurFond+$this->rFruit*$this->rY);
     262    }
     263
     264    /**
     265     * Calcul de dérivée de la surface hydraulique par rapport au tirant d'eau.
     266     * @return dS
     267     */
     268    protected function CalcSder() {
     269        return $this->rLargeurFond + 2*$this->rFruit*$this->rY;
     270    }
     271
     272    /**
     273     * Calcul de dérivée du périmètre hydraulique par rapport au tirant d'eau.
     274     * @return dP
     275     */
     276    protected function CalcPder() {
     277        return 2*sqrt(1+$this->rFruit*$this->rFruit);
     278    }
     279
     280    /**
     281     * Calcul de dérivée de la largeur au miroir par rapport au tirant d'eau.
     282     * @return dB
     283     */
     284    protected function CalcBder() {
     285        return 2*$this->rLargeurFond*$this->rFruit;
     286    }
     287}
     288
     289/**
     290 * Calculs de la section rectangulaire
     291 */
     292class cSnRectangulaire extends acSection {
     293   public $rLargeurFond; /// largeur au fond
     294
     295    function __construct($oP,$rLargeurFond, $rFruit) {
     296        $this->rLargeurFond=(real) $rLargeurFond;
     297        parent::__construct($oP);
     298    }
     299
     300    protected function CalcB() {
     301        return $this->rLargeurFond;
     302    }
     303
     304    protected function CalcP() {
     305        return $this->rLargeurFond+2*$this->rY;
     306    }
     307
     308    protected function CalcS() {
     309        return $this->rY*$this->rLargeurFond;
     310    }
     311
     312    /**
     313     * Calcul de dérivée de la surface hydraulique par rapport au tirant d'eau.
     314     * @return dS
     315     */
     316    protected function CalcSder() {
     317        return $this->rLargeurFond;
     318    }
     319
     320    /**
     321     * Calcul de dérivée du périmètre hydraulique par rapport au tirant d'eau.
     322     * @return dP
     323     */
     324    protected function CalcPder() {
     325        return 2;
     326    }
     327
     328    /**
     329     * Calcul de dérivée de la largeur au miroir par rapport au tirant d'eau.
     330     * @return dB
     331     */
     332    protected function CalcBder() {
     333        return 0;
     334    }
     335}
     336
     337/**
     338 * Calcul de la hauteur critique
     339 */
    135340class 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 
    152 }
     341    private $oSn;
     342    private $oP;
     343
     344    /**
     345     * Constructeur de la classe
     346     * @param $oSn Section sur laquelle on fait le calcul
     347     * @param $oP Paramètres supplémentaires (Débit, précision...)
     348     */
     349    function __construct($oSn,cParam $oP) {
     350        $this->oSn = $oSn;
     351        $this->oP = $oP;
     352        $this->rTol=$oP->rPrec;
     353        $this->rDx=$oP->rPrec/10;
     354    }
     355
     356    /**
     357     * Calcul de la fonction dont on cherche le zéro
     358     * @param $rX Variable dont dépend la fonction
     359     */
     360    protected function CalcFn($rX) {
     361        // Initialisation des données de la section
     362        $this->oSn->Reset();
     363        $this->oSn->rY = $rX;
     364        // Calcul de la fonction
     365        $rFn = (pow($this->oP->rQ,2)/pow($this->oSn->Calc('S'),2)*($this->oSn->Calc('B')/$this->oSn->Calc('S')/$this->oP->rG)-1);
     366        spip_log('cHautCritique:CalcFn('.$rX.')='.$rFn,'hydraulic');
     367        return $rFn;
     368    }
     369
     370    /**
     371     * Calcul analytique de la dérivée de la fonction dont on cherche le zéro
     372     * @param $rX Variable dont dépend la fonction
     373     */
     374    protected function CalcDer($rX) {
     375        // L'initialisation à partir de $rX a été faite lors de l'appel à CalcFn
     376        $rDer = ($this->oSn->Calc('dB')*$this->oSn->Calc('S')-3*$this->oSn->Calc('B')*$this->oSn->Calc('dS'));
     377        $rDer = pow($this->oP->rQ,2)/$this->oP->rG * $rDer / pow($this->oSn->Calc('S'),4);
     378        spip_log('cHautCritique:CalcDer('.$rX.')='.$rDer,'hydraulic');
     379        return $rDer;
     380    }
     381}
     382
     383/**
     384 * Calcul de la hauteur normale
     385 */
    153386class 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    }
     387    private $oSn;
     388    private $rQ;
     389    private $rKs;
     390    private $rIf;
     391
     392    /**
     393     * Constructeur de la classe
     394     * @param $oSn Section sur laquelle on fait le calcul
     395     * @param $oP Paramètres supplémentaires (Débit, précision...)
     396     */
     397    function __construct(acSection $oSn, cParam $oP) {
     398        $this->oSn=$oSn;
     399        $this->rQ=$oP->rQ;
     400        $this->rKs=$oP->rKs;
     401        $this->rIf=$oP->rIf;
     402        $this->rG=$oP->rG;
     403        $this->rTol=$oP->rPrec;
     404        $this->rDx=$oP->rPrec/10;
     405    }
     406
     407    /**
     408     * Calcul de la fonction dont on cherche le zéro
     409     * @param $rX Variable dont dépend la fonction
     410     */
     411    protected function CalcFn($rX) {
     412        // Initialisation des données de la section
     413        $this->oSn->Reset();
     414        $this->oSn->rY = $rX;
     415        // Calcul de la fonction
     416        $rFn = ($this->rQ-$this->rKs*pow($this->oSn->Calc('R'),2/3)*$this->oSn->Calc('S')*sqrt($this->rIf));
     417        spip_log('cHautNormale:CalcFn('.$rX.')='.$rFn,'hydraulic');
     418        return $rFn;
     419    }
     420
     421    /**
     422     * Calcul analytique de la dérivée de la fonction dont on cherche le zéro
     423     * @param $rX Variable dont dépend la fonction
     424     */
     425    protected function CalcDer($rX) {
     426        // L'initialisation a été faite lors de l'appel à CalcFn
     427        $rDer = 2/3*$this->oSn->Calc('dR')*pow($this->oSn->Calc('R'),-1/3)*$this->oSn->Calc('S');
     428        $rDer += pow($this->oSn->Calc('R'),2/3)*$this->oSn->Calc('dS');
     429        $rDer *= -$this->rKs * sqrt($this->rIf);
     430        spip_log('cHautNormale:CalcDer('.$rX.')='.$rDer,'hydraulic');
     431        return $rDer;
     432    }
    175433}
    176434
Note: See TracChangeset for help on using the changeset viewer.