source: spip-zone/_plugins_/hydraulic/branches/v0.3/hyd_inc/section.class.php @ 60927

Last change on this file since 60927 was 60927, checked in by dorch@…, 7 years ago
  • 0000583: [Section] Dessiner le profil de la section (mederic) - fermé.
  • 0000693: [Section] Dessin du profil de la section > Dessiner la forme de la section (dorch) - fermé.
File size: 23.5 KB
Line 
1<?php
2/**
3 *      @file section.class.php
4 *      Gestion des calculs au niveau des Sections
5 */
6
7/*      Copyright 2009-2012 Dorch <dorch@dorch.fr>
8 *
9 *      This program is free software; you can redistribute it and/or modify
10 *      it under the terms of the GNU General Public License as published by
11 *      the Free Software Foundation; either version 2 of the License, or
12 *      (at your option) any later version.
13 *
14 *      This program is distributed in the hope that it will be useful,
15 *      but WITHOUT ANY WARRANTY; without even the implied warranty of
16 *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17 *      GNU General Public License for more details.
18 *
19 *      You should have received a copy of the GNU General Public License
20 *      along with this program; if not, write to the Free Software
21 *      Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
22 *      MA 02110-1301, USA.
23 */
24
25// Chargement de la classe pour la méthode de Newton
26include_spip('hyd_inc/newton.class');
27
28/**
29 * Gestion des Paramètres du canal (hors section)
30 */
31class cParam {
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    public $rYB;    /// Hauteur de berge
42
43    function __construct($rKs, $rQ, $rIf, $rPrec, $rYB, $rYCL = 0, $rDx = 0, $rLong = 0) {
44        $this->rYCL=(real) $rYCL;
45        $this->rKs=(real) $rKs;
46        $this->rQ=(real) $rQ;
47        $this->rLong=(real) $rLong;
48        $this->rIf=(real) $rIf;
49        $this->rDx=(real) $rDx;
50        $this->rPrec=(real) $rPrec;
51        $this->rYB=(real) $rYB;
52        $this->iPrec=(int)-log10($rPrec);
53    }
54}
55
56/**
57 * Gestion commune pour les différents types de section.
58 * Comprend les formules pour la section rectangulaire pour gérer les débordements
59 */
60abstract class acSection {
61    //~ public $rS;             /// Surface hydraulique
62    //~ public $rP;             /// Périmètre hydraulique
63    //~ public $rR;             /// Rayon hydraulique
64    //~ public $rB;             /// Largeur au miroir
65    //~ public $rJ;             /// Perte de charge
66    //~ public $rFr;                /// Froude
67    public $rY=0;          /// Tirant d'eau
68    public $rHautCritique;  /// Tirant d'eau critique
69    public $rHautNormale;   /// Tirant d'eau normal
70    public $oP;   /// Paramètres du système canal (classe oParam)
71    protected $oLog; /// Pour l'affichage du journal de calcul
72    public $rLargeurBerge; /// largeur au débordement
73    protected $bSnFermee = false; /// true si la section est fermée (fente de Preissmann)
74    /**
75     * Tableau contenant les données dépendantes du tirant d'eau $this->rY.
76     *
77     * Les clés du tableau peuvent être :
78     * - S : la surface hydraulique
79     * - P : le périmètre hydraulique
80     * - R : le rayon hydraulique
81     * - B : la largeur au miroir
82     * - J : la perte de charge
83     * - Fr : le nombre de Froude
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    private $rY_old ; /// Mémorisation du tirant d'eau pour calcul intermédiaire
92    private $arCalc_old = array(); /// Mémorisation des données hydrauliques pour calcul intermédiaire
93    /**
94     * Nombre de points nécessaires pour le dessin de la section (hors point de berge)
95     * Valeur de 1 par défaut pour les sections rectangulaires et trapézoïdales
96     */
97    protected $nbDessinPoints=1;
98
99    /**
100     * Construction de la classe.
101     * Calcul des hauteurs normale et critique
102     */
103    public function __construct(&$oLog,&$oP) {
104        $this->oP = &$oP;
105        $this->oLog = &$oLog;
106        $this->CalcGeo('B');
107        spip_log($this,'hydraulic');
108    }
109
110    /**
111     * Efface toutes les données calculées pour forcer le recalcul
112     */
113    public function Reset($bGeo=true) {
114        $this->arCalc = array();
115        if($bGeo) {
116         $this->arCalcGeo = array();
117      }
118    }
119
120    /**
121     * Mémorise les données hydraulique en cours ou les restitue
122     * @param bMem true pour mémorisation, false pour restitution
123     */
124    public function Swap($bMem) {
125        if($bMem) {
126            $this->rY_old = $this->rY;
127            $this->arCalc_old = $this->arCalc;
128        }
129        else {
130            $this->rY = $this->rY_old;
131            $this->arCalc = $this->arCalc_old;
132            $this->arCalc_old = array();
133        }
134    }
135
136
137    /**
138     * Calcul des données à la section
139     * @param $sDonnee Clé de la donnée à calculer (voir $this->$arCalc)
140     * @param $bRecalc Pour forcer le recalcul de la donnée
141     * @return la donnée calculée
142     */
143    public function Calc($sDonnee, $rY = false) {
144        if($rY!==false && $rY!=$this->rY) {
145            //spip_log('Calc('.$sDonnee.') rY='.$rY,'hydraulic');
146            $this->rY = $rY;
147            // On efface toutes les données dépendantes de Y pour forcer le calcul
148            $this->Reset(false);
149        }
150
151        if(!isset($this->arCalc[$sDonnee])) {
152            // La donnée a besoin d'être calculée
153            switch($sDonnee) {
154                case 'S' : // Surface mouillée
155                    $this->arCalc[$sDonnee] = $this->CalcS();
156                    break;
157                case 'P' : // Périmètre mouillé
158                    $this->arCalc[$sDonnee] = $this->CalcP();
159                    break;
160                case 'R' : // Rayon hydraulique
161                    $this->arCalc[$sDonnee] = $this->CalcR();
162                    break;
163                case 'B' : // Largeur au miroir
164                    $this->arCalc[$sDonnee] = $this->CalcB();
165                    break;
166                case 'J' : // Perte de charge linéaire
167                    $this->arCalc[$sDonnee] = $this->CalcJ();
168                    break;
169                case 'Fr' : // Froude
170                    $this->arCalc[$sDonnee] = $this->CalcFr();
171                    break;
172                case 'dP' : // dP/dY
173                    $this->arCalc[$sDonnee] = $this->CalcPder();
174                    break;
175                case 'dR' : // dR/dY
176                    $this->arCalc[$sDonnee] = $this->CalcRder();
177                    break;
178                case 'dB' : // dB/dY
179                    $this->arCalc[$sDonnee] = $this->CalcBder();
180                    break;
181                case 'V' : // Vitesse moyenne
182                    $this->arCalc[$sDonnee] = $this->CalcV();
183                    break;
184                case 'Hs' : // Charge spécifique
185                    $this->arCalc[$sDonnee] = $this->CalcHs();
186                    break;
187                case 'Yf' : // Tirant d'eau fluvial
188                    $this->arCalc[$sDonnee] = $this->CalcYf();
189                    break;
190                case 'Yt' : // Tirant d'eau torrentiel
191                    $this->arCalc[$sDonnee] = $this->CalcYt();
192                    break;
193                case 'Yco' : // Tirant d'eau conjugué
194                    $this->arCalc[$sDonnee] = $this->CalcYco();
195                    break;
196                case 'Tau0' : // Force tractrice ou contrainte de cisaillement
197                    $this->arCalc[$sDonnee] = $this->CalcTau0();
198                    break;
199                case 'SYg' : // Distance du centre de gravité de la section à la surface libre
200                    $this->arCalc[$sDonnee] = $this->CalcSYg();
201                    break;
202                case 'Imp' : // Impulsion hydraulique
203                    $this->arCalc[$sDonnee] = $this->CalcImp();
204                    break;
205                case 'Alpha' : // Angle Alpha de la surface libre par rapport au fond pour les sections circulaires
206                    $this->arCalc[$sDonnee] = $this->CalcAlpha();
207                    break;
208                case 'dAlpha' : // Dérivée de l'angle Alpha de la surface libre par rapport au fond pour les sections circulaires
209                    $this->arCalc[$sDonnee] = $this->CalcAlphaDer();
210                    break;
211                case 'I-J' : // Variation linéaire de l'énergie spécifique (I-J) en m/m
212                    $this->arCalc[$sDonnee] = $this->oP->rIf-$this->Calc('J');
213                    break;
214            }
215        }
216        //spip_log('Calc('.$sDonnee.')='.$this->arCalc[$sDonnee],'hydraulic');
217        return $this->arCalc[$sDonnee];
218    }
219
220    /**
221     * Calcul des données uniquement dépendantes de la géométrie de la section
222     * @param $sDonnee Clé de la donnée à calculer (voir $this->$arCalcGeo)
223     * @param $rY Hauteur d'eau
224     * @return la donnée calculée
225     */
226    public function CalcGeo($sDonnee) {
227        if($sDonnee != 'B' && !isset($this->arCalcGeo['B'])) {
228            // Si la largeur aux berges n'a pas encore été calculée, on commence par ça
229            $this->CalcGeo('B');
230        }
231        if(!isset($this->arCalcGeo[$sDonnee])) {
232            // La donnée a besoin d'être calculée
233            spip_log('CalcGeo('.$sDonnee.') rY='.$this->oP->rYB,'hydraulic');
234            $this->Swap(true); // On mémorise les données hydrauliques en cours
235            $this->Reset(false);
236            $this->rY = $this->oP->rYB;
237            switch($sDonnee) {
238                case 'B' : // Largeur aux berges
239                    $this->arCalcGeo[$sDonnee] = $this->CalcB();
240                    if($this->arCalcGeo[$sDonnee] < $this->oP->rYB / 100) {
241                        // Section fermée
242                        $this->bSnFermee = true;
243                        // On propose une fente de Preissmann égale à 1/100 de la hauteur des berges
244                        $this->arCalcGeo[$sDonnee] = $this->oP->rYB / 100;
245                    }
246                    $this->rLargeurBerge = $this->arCalcGeo[$sDonnee];
247                    break;
248                case 'S' : // Surface mouillée au niveau des berges
249                    $this->arCalcGeo[$sDonnee] = $this->CalcS();
250                    break;
251                case 'P' : // Périmètre mouillé au niveau des berges
252                    $this->arCalcGeo[$sDonnee] = $this->CalcP();
253                    break;
254                case 'Yc' : // Tirant d'eau critique
255                    $this->arCalcGeo[$sDonnee] = $this->CalcYc();
256                    break;
257                case 'Yn' : // Tirant d'eau normal
258                    $this->arCalcGeo[$sDonnee] = $this->CalcYn();
259                    break;
260                case 'Hsc' : // Charge spécifique critique
261                    $this->arCalcGeo[$sDonnee] = $this->CalcHsc();
262            }
263        }
264        $this->Swap(false); // On restitue les données hydrauliques en cours
265        spip_log('CalcGeo('.$sDonnee.')='.$this->arCalcGeo[$sDonnee],'hydraulic');
266        return $this->arCalcGeo[$sDonnee];
267    }
268
269    /**
270     * Calcul de la surface hydraulique.
271     * @return La surface hydraulique
272     */
273    protected function CalcS($rY) {
274        return $rY*$this->rLargeurBerge;
275    }
276
277
278   /**
279    * Calcul du périmètre hydraulique.
280    * @return Le périmètre hydraulique
281    */
282    protected function CalcP($rY) {
283        return 2*$rY;
284    }
285    /**
286     * Calcul de dérivée du périmètre hydraulique par rapport au tirant d'eau.
287     * @return dP
288     */
289    protected function CalcPder() {
290        return 2;
291    }
292
293   /**
294    * Calcul du rayon hydraulique.
295    * @return Le rayon hydraulique
296    */
297    protected function CalcR() {
298        if($this->Calc('P')!=0) {
299            return $this->Calc('S')/$this->Calc('P');
300        }
301        else {
302            return INF;
303        }
304    }
305
306    /**
307     * Calcul de dérivée du rayon hydraulique par rapport au tirant d'eau.
308     * @return dR
309     */
310    protected function CalcRder() {
311        if($this->Calc('P')!=0) {
312            return ($this->Calc('B')*$this->Calc('P')-$this->Calc('S')*$this->Calc('dP'))/pow($this->Calc('P'),2);
313        }
314        else {
315            return 0;
316        }
317    }
318
319   /**
320    * Calcul de la largeur au miroir.
321    * @return La largeur au miroir
322    */
323    protected function CalcB() {
324        return $this->rLargeurBerge;
325    }
326    /**
327     * Calcul de dérivée de la largeur au miroir par rapport au tirant d'eau.
328     * @return dB
329     */
330    protected function CalcBder() {
331        return 0;
332    }
333
334   /**
335    * Calcul de la perte de charge par la formule de Manning-Strickler.
336    * @return La perte de charge
337    */
338    private function CalcJ() {
339        if($this->Calc('R')!=0) {
340            return pow($this->Calc('V')/$this->oP->rKs,2)/pow($this->Calc('R'),4/3);
341        }
342        else {
343            return INF;
344        }
345    }
346
347   /**
348    * Calcul du nombre de Froude.
349    * @return Le nombre de Froude
350    */
351    private function CalcFr() {
352        if($this->Calc('S')!=0) {
353            return $this->oP->rQ/$this->Calc('S')*sqrt($this->Calc('B')/$this->Calc('S')/$this->oP->rG);
354        }
355        else {
356            return INF;
357        }
358    }
359
360   /**
361    * Calcul du point suivant de la courbe de remous par la méthode Euler explicite.
362    * @return Tirant d'eau
363    */
364    public function CalcY_M1($Y) {
365        // L'appel à Calc('J') avec Y en paramètre réinitialise toutes les données dépendantes de la ligne d'eau
366        return $Y-($this->oP->rDx*($this->oP->rIf-$this->Calc('J',$Y))/(1-pow($this->Calc('Fr',$Y),2)));
367    }
368
369   /**
370    * Calcul de la vitesse moyenne.
371    * @return Vitesse moyenne
372    */
373    private function CalcV() {
374        if($this->Calc('S')!=0) {
375            return $this->oP->rQ/$this->Calc('S');
376        }
377        else {
378            return INF;
379        }
380    }
381
382   /**
383    * Calcul de la charge spécifique.
384    * @return Charge spécifique
385    */
386    private function CalcHs() {
387        return $this->rY+pow($this->Calc('V'),2)/(2*$this->oP->rG);
388    }
389
390
391   /**
392    * Calcul de la charge spécifique critique.
393    * @return Charge spécifique critique
394    */
395    private function CalcHsc() {
396        $this->Swap(true); // On mémorise les données hydrauliques en cours
397        // On calcule la charge avec la hauteur critique
398        $rHsc = $this->Calc('Hs',$this->CalcGeo('Yc'));
399        // On restitue les données initiales
400        $this->Swap(false);
401        return $rHsc;
402    }
403
404
405   /**
406    * Calcul du tirant d'eau critique.
407    * @return tirant d'eau critique
408    */
409    private function CalcYc() {
410        $oHautCritique = new cHautCritique($this, $this->oP);
411        if(!$this->rHautCritique = $oHautCritique->Newton($this->oP->rYB) or !$oHautCritique->HasConverged()) {
412         $this->oLog->Add(_T('hydraulic:h_critique').' : '._T('hydraulic:newton_non_convergence'));
413      }
414      return $this->rHautCritique;
415    }
416
417   /**
418    * Calcul du tirant d'eau normal.
419    * @return tirant d'eau normal
420    */
421    private function CalcYn() {
422        $oHautNormale= new cHautNormale($this, $this->oP);
423        if(!$this->rHautNormale = $oHautNormale->Newton($this->CalcGeo('Yc')) or !$oHautNormale->HasConverged()) {
424            $this->oLog->Add(_T('hydraulic:h_normale').' : '._T('hydraulic:newton_non_convergence'));
425        }
426        return $this->rHautNormale;
427    }
428
429   /**
430    * Calcul du tirant d'eau fluvial.
431    * @return tirant d'eau fluvial
432    */
433    private function CalcYf() {
434        if($this->rY > $this->CalcGeo('Yc')) {
435            return $this->rY;
436        }
437        else {
438            $oHautCorrespondante= new cHautCorrespondante($this, $this->oP);
439            return $oHautCorrespondante->Newton($this->Calc('Yc')*2);
440        }
441    }
442
443   /**
444    * Calcul du tirant d'eau torrentiel.
445    * @return tirant d'eau torrentiel
446    */
447    private function CalcYt() {
448        if($this->rY < $this->CalcGeo('Yc')) {
449            return $this->rY;
450        }
451        else {
452            $oHautCorrespondante= new cHautCorrespondante($this, $this->oP);
453            return $oHautCorrespondante->Newton($this->CalcGeo('Yc')/2);
454        }
455    }
456
457   /**
458    * Calcul du tirant d'eau conjugué.
459    * @return tirant d'eau conjugué
460    */
461    private function CalcYco() {
462        return $this->rY*(sqrt(1 + 8 * pow($this->Calc('Fr'),2)) - 1) / 2;
463    }
464
465   /**
466    * Calcul de la contrainte de cisaillement.
467    * @return contrainte de cisaillement
468    */
469    private function CalcTau0() {
470        return 1000 * $this->oP->rG * $this->Calc('R') * $this->oP->rIf;
471    }
472
473    /**
474     * Calcul de la distance du centre de gravité de la section à la surface libre.
475     * @return Distance du centre de gravité de la section à la surface libre
476     */
477    protected function CalcSYg($rY) {
478        return $rY / 2;
479    }
480    /**
481     * Calcul de l'impulsion hydraulique.
482     * @return Impulsion hydraulique
483     */
484    protected function CalcImp() {
485        return 1000 * ($this->oP->rQ * $this->Calc('V') + $this->oP->rG * $this->Calc('SYg'));
486    }
487
488    /**
489     * Calcul de l'angle Alpha entre la surface libre et le fond pour les sections circulaires.
490     * @return Angle Alpha pour une section circulaire, 0 sinon.
491     */
492    protected function CalcAlpha(){
493        return 0;
494    }
495
496    /**
497     * Calcul de la dérivée de l'angle Alpha entre la surface libre et le fond pour les sections circulaires.
498     * @return Dérivée de l'angle Alpha pour une section circulaire, 0 sinon.
499     */
500    protected function CalcAlphaDer(){
501        return 0;
502    }
503
504
505    /**
506     * Fournit les coordonnées des points d'une demi section pour le dessin
507     * @return tableau de couples de coordonnées (x,y)
508     */
509    public function DessinCoordonnees() {
510        $rPas = $this->oP->rYB / $this->nbDessinPoints;
511        $tPoints = array();
512        $this->Swap(true); // On mémorise les données hydrauliques en cours
513        for($rY=0;$rY<$this->oP->rYB+$rPas/2;$rY+=$rPas) {
514            spip_log('DessinCoordonnees rY='.$rY,'hydraulic');
515            $tPoints['x'][] = $this->Calc('B',$rY)/2;
516            $tPoints['y'][] = $rY;
517        }
518        // On restitue les données initiales
519        $this->Swap(false);
520        return $tPoints;
521    }
522}
523
524
525/**
526 * Calcul de la hauteur critique
527 */
528class cHautCritique extends acNewton {
529    private $oSn;
530    private $oP;
531
532    /**
533     * Constructeur de la classe
534     * @param $oSn Section sur laquelle on fait le calcul
535     * @param $oP Paramètres supplémentaires (Débit, précision...)
536     */
537    function __construct($oSn,cParam $oP) {
538        $this->oSn = clone $oSn;
539        $this->oP = $oP;
540        parent::__construct($oP);
541    }
542
543    /**
544     * Calcul de la fonction dont on cherche le zéro
545     * @param $rX Variable dont dépend la fonction
546     */
547    protected function CalcFn($rX) {
548        // Calcul de la fonction
549        if($this->oSn->Calc('S',$rX)!=0) {
550            $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);
551        }
552        else {
553            $rFn = INF;
554        }
555        //spip_log('cHautCritique:CalcFn('.$rX.')='.$rFn,'hydraulic');
556        return $rFn;
557    }
558
559    /**
560     * Calcul analytique de la dérivée de la fonction dont on cherche le zéro
561     * @param $rX Variable dont dépend la fonction
562     */
563    protected function CalcDer($rX) {
564        if($this->oSn->Calc('S')!=0) {
565            // L'initialisation à partir de $rX a été faite lors de l'appel à CalcFn
566            $rDer = ($this->oSn->Calc('dB')*$this->oSn->Calc('S')-3*$this->oSn->Calc('B')*$this->oSn->Calc('B'));
567            $rDer = pow($this->oP->rQ,2)/$this->oP->rG * $rDer / pow($this->oSn->Calc('S'),4);
568        }
569        else {
570            $rDer = INF;
571        }
572
573        //spip_log('cHautCritique:CalcDer('.$rX.')='.$rDer,'hydraulic');
574        return $rDer;
575    }
576}
577
578/**
579 * Calcul de la hauteur normale
580 */
581class cHautNormale extends acNewton {
582    private $oSn;
583    private $rQ;
584    private $rKs;
585    private $rIf;
586
587    /**
588     * Constructeur de la classe
589     * @param $oSn Section sur laquelle on fait le calcul
590     * @param $oP Paramètres supplémentaires (Débit, précision...)
591     */
592    function __construct($oSn, cParam $oP) {
593        $this->oSn= clone $oSn;
594        $this->rQ=$oP->rQ;
595        $this->rKs=$oP->rKs;
596        $this->rIf=$oP->rIf;
597        $this->rG=$oP->rG;
598        parent::__construct($oP);
599    }
600
601    /**
602     * Calcul de la fonction dont on cherche le zéro
603     * @param $rX Variable dont dépend la fonction
604     */
605    protected function CalcFn($rX) {
606        // Calcul de la fonction
607        $rFn = ($this->rQ-$this->rKs*pow($this->oSn->Calc('R',$rX),2/3)*$this->oSn->Calc('S',$rX)*sqrt($this->rIf));
608        //spip_log('cHautNormale:CalcFn('.$rX.')='.$rFn,'hydraulic');
609        return $rFn;
610    }
611
612    /**
613     * Calcul analytique de la dérivée de la fonction dont on cherche le zéro
614     * @param $rX Variable dont dépend la fonction
615     */
616    protected function CalcDer($rX) {
617        // L'initialisation a été faite lors de l'appel à CalcFn
618        $rDer = 2/3*$this->oSn->Calc('dR')*pow($this->oSn->Calc('R'),-1/3)*$this->oSn->Calc('S');
619        $rDer += pow($this->oSn->Calc('R'),2/3)*$this->oSn->Calc('B');
620        $rDer *= -$this->rKs * sqrt($this->rIf);
621        //spip_log('cHautNormale:CalcDer('.$rX.')='.$rDer,'hydraulic');
622        return $rDer;
623    }
624}
625
626
627/**
628 * Calcul de la hauteur correspondante (charge égale)
629 */
630class cHautCorrespondante extends acNewton {
631    private $rY; // Tirant d'eau connu
632    private $rV2; // Vitesse moyenne au carré associée au tirant d'eau connu
633    private $oSnCal; // Section contenant les données de la section avec la hauteur à calculer
634    private $rG; // Constante de gravité
635
636    /**
637     * Constructeur de la classe
638     * @param $oSn Section sur laquelle on fait le calcul
639     * @param $oP Paramètres supplémentaires (Débit, précision...)
640     */
641    function __construct(acSection $oSn, cParam $oP) {
642        parent::__construct($oP);
643        $this->rY = $oSn->rY;
644        $this->rS2 = pow($oSn->Calc('S'),-2);
645        $this->oSn = clone $oSn;
646        $this->rQ2G = pow($oP->rQ,2)/(2*$oP->rG);
647    }
648
649    /**
650     * Calcul de la fonction dont on cherche le zéro
651     * @param $rX Variable dont dépend la fonction
652     */
653    protected function CalcFn($rX) {
654
655        // Calcul de la fonction
656        $rFn = $this->rY - $rX + ($this->rS2-pow($this->oSn->Calc('S',$rX),-2))*$this->rQ2G;
657        spip_log('cHautCorrespondante:CalcFn('.$rX.')='.$rFn,'hydraulic');
658        return $rFn;
659    }
660
661    /**
662     * Calcul analytique de la dérivée de la fonction dont on cherche le zéro
663     * @param $rX Variable dont dépend la fonction
664     */
665    protected function CalcDer($rX) {
666        // L'initialisation a été faite lors de l'appel à CalcFn
667        if($this->oSn->Calc('S')!=0) {
668            $rDer = -1 + 2 * $this->rQ2G * $this->oSn->Calc('B') / pow($this->oSn->Calc('S'),3);
669        }
670        else {
671            $rDer = INF;
672        }
673        spip_log('cHautCorrespondante:CalcDer('.$rX.')='.$rDer,'hydraulic');
674        return $rDer;
675    }
676
677}
678
679?>
Note: See TracBrowser for help on using the repository browser.