Changeset 60941 in spip-zone


Ignore:
Timestamp:
May 4, 2012, 6:54:22 PM (8 years ago)
Author:
dorch@…
Message:

Merge de la branche de développement vers trunk

Location:
_plugins_/hydraulic/trunk
Files:
7 edited

Legend:

Unmodified
Added
Removed
  • _plugins_/hydraulic/trunk/formulaires/calcul_normale_critique.php

    r60821 r60941  
    159159        }
    160160    }
    161    
     161
    162162    return $valeurs;
    163163}
     
    298298
    299299    $max += $pas/2;
    300    
     300
    301301    $bNoCache = false; // true pour débugage
    302         if(!$bNoCache && is_file(HYD_CACHE_DIRECTORY.$CacheFileName)) {
     302    if(!$bNoCache && is_file(HYD_CACHE_DIRECTORY.$CacheFileName)) {
    303303        // On récupère toutes les données dans un cache déjà créé
    304304        $result = ReadCacheFile($CacheFileName);
    305305    }
    306306    else{
    307                 for($i = $min; $i <= $max; $i+= $pas){
    308                         $oSection->Reset(true);
    309                         foreach($tVarCal as $sCalc){
    310                                 $rY = $oSection->rY;
    311                                 if(!in_array($sCalc,array('Yn', 'Yc', 'Hsc'))){
    312                                         $result[] = $oSection->Calc($sCalc);
    313                                 }
    314                                 else{
    315                                         $result[] = $oSection->CalcGeo($sCalc);
    316                                 }
    317                                 $oSection->rY = $rY;
    318                         }
    319                 }
    320                 //Enregistrement des données dans fichier cache
     307        for($i = $min; $i <= $max; $i+= $pas){
     308            $oSection->Reset(true);
     309            foreach($tVarCal as $sCalc){
     310                $rY = $oSection->rY;
     311                if(!in_array($sCalc,array('Yn', 'Yc', 'Hsc'))){
     312                    $result[] = $oSection->Calc($sCalc);
     313                }
     314                else{
     315                    $result[] = $oSection->CalcGeo($sCalc);
     316                }
     317                $oSection->rY = $rY;
     318            }
     319        }
     320        //Enregistrement des données dans fichier cache
    321321        WriteCacheFile($CacheFileName,$result);
    322         }
     322    }
    323323    /***************************************************************************
    324324    *                             Une valeur varie
     
    474474
    475475        $lib_datas['rYB'] = $oSection->oP->rYB;
    476         $dessinSection = new dessinSection(250, 200, $ncTypeSection, $oSection, $lib_datas);
     476        $dessinSection = new dessinSection(250, 200, $oSection, $lib_datas);
    477477        $echo.= $dessinSection->GetDessinSection();
    478478    }
  • _plugins_/hydraulic/trunk/hyd_inc/dessinSection.class.php

    r60821 r60941  
    55 *
    66 *
    7  * Copyright 2012 David Dorchies <dorch@dorch.fr>
     7 * Copyright 2012 Médéric Dulondel, David Dorchies <dorch@dorch.fr>
    88 *
    99 *
     
    4040
    4141/**
    42  * Classe pour l'affichage du dessin des section
     42 * Classe pour l'affichage du dessin des sections
    4343 *
    4444 * @date 10/04/2012
    45  * @author Médéric Dulondel
     45 * @author Médéric Dulondel, David Dorchies
    4646 *
    4747 */
    4848class dessinSection {
    49         private $hauteurDessin; // Hauteur du dessin en px
    50         private $largeurDessin; // Largeur du dessin en px
    51         private $mesCouleurs = array('red', 'blue', 'orange', 'green', 'grey', 'black');  // Couleur des différentes lignes
    52         private $tSection; // Choix de la section
    53         private $sectionClass;
    54         private $donnees = array();
    55        
    56     function __construct($hauteur, $largeur, $typeSection, $section, $lib_data) {
    57         $this->hauteurDessin = $hauteur;
    58         $this->largeurDessin = $largeur;
    59         $this->tSection = $typeSection;
    60         $this->sectionClass = $section;
    61                 $this->donnees = $lib_data;
    62     }
     49    private $hauteurDessin; // Hauteur du dessin en px
     50    private $largeurDessin; // Largeur du dessin en px
     51    private $mesCouleurs = array('red', 'blue', 'orange', 'green', 'grey', 'black');  // Couleur des différentes lignes
     52    private $sectionClass;
     53    private $donnees = array();
     54    private $rValMax = 0; // Hauteur maxi en m à figurer dans le dessin
     55    private $rSnXmax = 0; // Largeur maximum en m à figurer dans le dessin
    6356
    64         /*
    65          * Rajoute une ligne à notre dessin.
    66          * $color correspond à la couleur de la ligne
    67          * $val correspond à l'ordonnée exprimée en pixel de la ligne
    68          */
    69         function AddRow($color, $val){         
    70                 $ligneDessin = '$("#dessinSection").drawLine(0,'.$val.','.$this->largeurDessin.','.$val.', {color: "'.$color.'"});';
    71                 return $ligneDessin;
    72         }
    73        
    74         /*
    75          * Transforme des valeurs de tirants d'eau en leur valeur en pixel
    76          */
    77         function transformeValeur($tabDonnees){
    78                 // On détermine la valeur la plus grande dans le tableau
    79                 $ValMax = 0;
    80                 foreach($tabDonnees as $val){
    81                         if($val > $ValMax){
    82                                 $ValMax = $val;
    83                         }
    84                 }
    85                
    86                 // La valeur maximum de l'échelle correspondant à 10% de la hauteur afin de faire plus propre
    87                 $valEchelle = $this->hauteurDessin - ($this->hauteurDessin * 0.1);
    88                
    89                 // On transforme nos valeurs en leur attribuant la valeur en pixel et une couleur qui leur est associé
    90                 $result = array();
    91                 $couleur = 0;
    92                 foreach($tabDonnees as $cle=>$valeur){
    93                         $result[$cle][] = round($this->hauteurDessin - (($valeur*$valEchelle)/$ValMax), 1);
    94                         $result[$cle][] = $this->mesCouleurs[$couleur];
    95                         $couleur++;
    96                 }
     57    function __construct($hauteur, $largeur, &$section, $lib_data) {
     58        $this->hauteurDessin = (real) $hauteur;
     59        $this->largeurDessin = (real) $largeur;
     60        $this->sectionClass = &$section;
     61        $this->donnees = $lib_data;
     62        // On détermine la valeur la plus grande dans le tableau
     63        foreach($this->donnees as $val){
     64            if($val > $this->ValMax){
     65                $this->ValMax = $val;
     66            }
     67        }
     68        //spip_log($this,'hydraulic');
     69    }
    9770
    98                 asort($result);
     71    /**
     72     * Rajoute une ligne à notre dessin.
     73     * $color correspond à la couleur de la ligne
     74     * $val correspond à l'ordonnée exprimée en pixel de la ligne
     75     */
     76    function AddRow($color, $val){
     77        $ligneDessin = '$("#dessinSection").drawLine(0,'.$val.','.$this->largeurDessin.','.$val.', {color: "'.$color.'"});';
     78        return $ligneDessin;
     79    }
    9980
    100                 return $result;
    101         }
    102        
    103         // Retourne le dessin de la section
    104         function GetDessinSection(){
    105                 // On transforme nos valeurs en pixels
    106                 $mesDonnees = $this->transformeValeur($this->donnees);
    107                
    108                 // Hauteur dessin - Hauteur de berge, en format pixels
    109                 $diffHautBerge = $mesDonnees['rYB'][0];
     81    /**
     82     * Convertit un tirant d'eau en mètre en une ordonnée en pixels
     83     */
     84    private function GetDessinY($val) {
     85        // La valeur maximum de l'échelle  en px correspondant à 10% de la hauteur afin de faire plus propre
     86        return round($this->hauteurDessin * (1- 0.9*$val/$this->ValMax), 1)-2;
     87    }
    11088
    111                 // On définit le style de notre dessin
    112                 $dessin = '<style type="text/css">
    113                                         .canvas{
    114                                                 position: relative;
    115                                                 width:'.$this->largeurDessin.'px;
    116                                                 height:'.$this->hauteurDessin.'px;
    117                                         }
    118                                         </style>';
    119                
    120                 // On créé la base de notre dessin de section
    121                 $dessin.= '<script type="text/javascript">
    122                                         $(document).ready(function(){';
    123                        
    124                 $dessin.= '$("#dessinSection").drawLine(0, 0, 0,'.$diffHautBerge.', {stroke: 1});
    125                                    $("#dessinSection").drawLine('.$this->largeurDessin.', 0,'.$this->largeurDessin.','.$diffHautBerge.', {stroke: 1});';
    126                        
    127                 switch($this->tSection){
    128                         case 'FT':
    129                                 $dessin.= '$("#dessinSection").drawPolyline(
    130                                                         [0,'.($this->largeurDessin*0.25).','.($this->largeurDessin*0.75).','.$this->largeurDessin.'],
    131                                                         ['.$diffHautBerge.','.$this->hauteurDessin.','.$this->hauteurDessin.','.$diffHautBerge.'], {stroke: 4});';
    132                 break;
     89    /**
     90     * Convertit une largeur en mètre en une abscisse en pixels
     91     * @param $Axe détermine si le pixel est à droite (1) ou à gauche (-1) de l'axe de symétrie
     92     * @return Abscisse en pixel à dessiner
     93     */
     94    private function GetDessinX($val,$Axe) {
     95        return round(($this->largeurDessin-14) * (1/2 + $Axe*$val/$this->SnXmax), 1)+7;
     96    }
    13397
    134             case 'FR':
    135                                 $dessin.= '$("#dessinSection").drawPolyline(
    136                                                         [0,0,'.$this->largeurDessin.','.$this->largeurDessin.'],
    137                                                         ['.$diffHautBerge.','.$this->hauteurDessin.','. $this->hauteurDessin.','.$diffHautBerge.'], {stroke: 4});';
    138        
    139                 break;
     98    /**
     99     * Transforme le tableau de tirants d"eau et charges à afficher en pixel + attribution des couleurs
     100     */
     101    function transformeValeur($tabDonnees){
     102        // On transforme nos valeurs en leur attribuant la valeur en pixel et une couleur qui leur est associé
     103        $result = array();
     104        $couleur = 0;
     105        foreach($tabDonnees as $cle=>$valeur){
     106            $result[$cle][] = $this->GetDessinY($valeur);
     107            $result[$cle][] = $this->mesCouleurs[$couleur];
     108            $couleur++;
     109        }
    140110
    141             case 'FC':
    142                                         // Trouver une méthode de dessin pour les sections circulaires
    143                 break;
     111        asort($result);
    144112
    145             case 'FP':
    146                                 $dessin.= '$("#dessinSection").drawPolyline([0,0,'.$this->largeurDessin.','.$this->largeurDessin.'], [0,'.$this->hauteurDessin.','. $this->hauteurDessin.', 0]);';
    147        
    148                                 break;
     113        return $result;
     114    }
    149115
    150             default:
    151                
    152                 }                       
     116    // Retourne le dessin de la section
     117    function GetDessinSection(){
     118        // On transforme nos valeurs en pixels
     119        $mesDonnees = $this->transformeValeur($this->donnees);
    153120
    154                 // On ajoute les différentes lignes avec couleur + valeur
    155                 foreach($mesDonnees as $cle=>$valeur){
    156                         if($cle != 'rYB'){
    157                                 $dessin.= $this->AddRow($valeur[1], $valeur[0]);
    158                         }
    159                 }
    160                
    161                 $dessin.= '});
    162                         </script>';
     121        // Hauteur dessin - Hauteur de berge, en format pixels
     122        $diffHautBerge = $mesDonnees['rYB'][0];
    163123
    164                 //Div qui va contenir notre dessin de section
    165                 $dessin.='<div id="dessinSection" class="canvas">';
    166                
    167                 // Pour alterner le placement des libellés
    168                 $droiteGauche = 0;
    169                 // On rajoute les différents libelles avec la couleur qui va bien
    170                 foreach($mesDonnees as $cle=>$valeur){
    171                         if($cle != 'rYB'){
    172                                 $placement = ($droiteGauche%2==0)?'left: -80px':'right: -80px;';
    173                                 $dessin.= '<p style="position: absolute; top:'.($valeur[0]-8).'px;'.$placement.'; width: auto; display: inline-block; color:'.$valeur[1].'">'.$cle.' = '.round($this->donnees[$cle], $this->sectionClass->oP->iPrec).'</p>';
    174                                 $droiteGauche++;               
    175                         }       
    176                 }
    177                
    178                 $dessin.= '</div>';
    179        
    180                 return $dessin;
    181         }
     124        // On définit le style de notre dessin
     125        $dessin = '<style type="text/css">
     126                    .canvas{
     127                        position: relative;
     128                        width:'.$this->largeurDessin.'px;
     129                        height:'.$this->hauteurDessin.'px;
     130                    }
     131                    </style>';
     132
     133        // On créé la base de notre dessin de section
     134        $dessin.= '<script type="text/javascript">
     135                    $(document).ready(function(){';
     136        // Récupération des coordonnées de la section à dessiner
     137        $tCoordSn = $this->sectionClass->DessinCoordonnees();
     138
     139        // Détermination de la largeur max de la section
     140        $this->SnXmax = max($tCoordSn['x'])*2;
     141
     142        // Dessin des verticales au dessus des berges
     143        $LargeurBerge = $this->sectionClass->CalcGeo('B')/2;
     144        $xBergeGauche = $this->GetDessinX($LargeurBerge,-1);
     145        $xBergeDroite = $this->GetDessinX($LargeurBerge,1);
     146        $dessin.= '$("#dessinSection").drawLine('.$xBergeGauche.', 0, '.$xBergeGauche.','.$diffHautBerge.', {stroke: 1});
     147                   $("#dessinSection").drawLine('.$xBergeDroite.', 0,'.$xBergeDroite.','.$diffHautBerge.', {stroke: 1});';
     148
     149        // Dessin de la section
     150
     151        $tSnX = array();
     152        $tSnY = array();
     153        // Parcours des points à gauche
     154        for($i=count($tCoordSn['x'])-1; $i>=0; $i-=1) {
     155            $tSnX[] = $this->GetDessinX($tCoordSn['x'][$i],-1);
     156            $tSnY[] = $this->GetDessinY($tCoordSn['y'][$i]);
     157        }
     158        // Parcours des points à droite
     159        for($i=0; $i<count($tCoordSn['x']); $i++) {
     160            $tSnX[] = $this->GetDessinX($tCoordSn['x'][$i],1);
     161            $tSnY[] = $this->GetDessinY($tCoordSn['y'][$i]);
     162        }
     163        $dessin.=   '$("#dessinSection").drawPolyline(
     164                        ['.implode(',',$tSnX).'],
     165                        ['.implode(',',$tSnY).'], {stroke: 4});';
     166
     167        // On ajoute les différentes lignes avec couleur + valeur
     168        foreach($mesDonnees as $cle=>$valeur){
     169            if($cle != 'rYB'){
     170                $dessin.= $this->AddRow($valeur[1], $valeur[0]);
     171            }
     172        }
     173
     174        $dessin.= '});
     175            </script>';
     176
     177        //Div qui va contenir notre dessin de section
     178        $dessin.='<div id="dessinSection" class="canvas">';
     179
     180        // Pour alterner le placement des libellés
     181        $droiteGauche = 0;
     182        // On rajoute les différents libelles avec la couleur qui va bien
     183        foreach($mesDonnees as $cle=>$valeur){
     184            if($cle != 'rYB'){
     185                $placement = ($droiteGauche%2==0)?'left: -80px':'right: -80px;';
     186                $dessin.= '<p style="position: absolute; top:'.($valeur[0]-8).'px;'.$placement.'; width: auto; display: inline-block; color:'.$valeur[1].'">'.$cle.' = '.round($this->donnees[$cle], $this->sectionClass->oP->iPrec).'</p>';
     187                $droiteGauche++;
     188            }
     189        }
     190
     191        $dessin.= '</div>';
     192
     193        return $dessin;
     194    }
    182195}
    183196?>
  • _plugins_/hydraulic/trunk/hyd_inc/ouvrage.class.php

    r60821 r60941  
    3434class cOuvrage {
    3535    private $oLog;  /// Journal des calculs
    36     private $nL;      /// Loi d'ouvrage
    37     private $nLS;     /// Loi pour la surverse
    38     private $Cd;    /// Coefficients de débit de l'ouvrage
     36    /**
     37     * Loi de débit pour l'ouvrage. Valeurs possibles :
     38     * - 1 - Déversoir/Orifice Cemagref 88 : Type 1,2,3 + Surverse
     39     * - 2 - Vanne de fond/Seuil Cemagref 88 : Type 1,2,3 + Surverse
     40     * - 3 - Seuil dénoyé : Type 3 + Surverse
     41     * - 4 - Seuil noyé : Type 3 + Surverse
     42     * - 5 - Vanne dénoyé : Type 1,2
     43     * - 6 - Vanne noyé : Type 1,2
     44     * - 7 - Cunge 1980 : Type 1,2,3 + Surverse
     45     * - 8 - Déversoir/Orifice Cemagref 02 : Type 4,5
     46     * - 9 - Vanne de fond/Seuil Cemagref 02 : Type 4,5
     47     */
     48    private $nL;
     49    /**
     50     * Loi de débit pour la surverse. Valeurs possibles :
     51     * - 1 - Déversoir/Orifice Cemagref 88
     52     * - 2 - Vanne de fond/Seuil Cemagref 88
     53     * - 3 - Seuil dénoyé
     54     * - 4 - Seuil noyé
     55     * - 7 - Cunge 1980
     56     */
     57    private $nLS;
    3958    /**
    4059     * Tableau contenant les paramètres de l'ouvrage.
     
    5372     * - CT : Coefficient de débit partie triangulaire pour les trapézoïdales
    5473     * - CS : Coefficient de débit de la surverse
     74     * - P : Précision du calcul
    5575     */
    5676    private $tP = array();
    5777
    58     const G = 9.81;
    59     const R2G = 4.42944; //sqrt(2*self::gP);
    60     const R32 = 2.59807; // 3*sqrt(3)/2;
     78    const G = 9.81; /// Constante de gravité terrestre
     79    const R2G = 4.42944; /// sqrt(2*self::gP);
     80    const R32 = 2.59807; /// 3*sqrt(3)/2;
     81    const IDEFINT = 100; /// Pas de parcours de l'intervalle pour initialisation dichotomie
     82    const IDICMAX = 100; /// Itérations maximum de la dichotomie
    6183
    6284    /**
     
    7395        $this->nLS = $nLoiSurverse;
    7496        $this->tP = $tP;
    75         if(isset($tP['C'])) {
    76             // Lois avec un coef de débit
    77             $this->Cd = $tP['C'];
    78         }
    79         elseif(isset($tP['CR']) and isset($tP['CR'])) {
    80             // Lois des vannes et seuils trapézoïdaux
    81             $this->Cd = array($tP['CR'],$tP['CT']);
    82         }
    83         else {
    84             echo 'absence de coefficient de débit';
    85         }
    8697        //spip_log($this,'hydraulic');
    8798    }
     
    91102     * Mise à jour d'un paramètre de l'ouvrage
    92103     * @param $sMaj Variable à modifier (indice du tableau tP)
    93      * @param $rmaj Valeur de lavariable à mettre à jour
     104     * @param $rmaj Valeur de la variable à mettre à jour
    94105     */
    95106    public function Set($sMaj,$rMaj) {
     
    103114     * @param $rInit Valeur initiale pour le calcul
    104115     * @return array(0=> donnée calculée, 1=> Flag d'écoulement)
    105      */
    106     public function Calc($sCalc,$rInit=0) {
    107         $rVarC = &$this->tP[$sCalc];
    108 
     116     * Signification du Flag d'écoulement :
     117     * - -1 : erreur de calcul
     118     * -  0 : débit nul
     119     * -  1 : surface libre dénoyé
     120     * -  2 : surface libre noyé
     121     * -  3 : charge denoyé
     122     * -  4 : charge noyé partiel
     123     * -  5 : charge noyé total
     124     * - 11 : surverse dénoyé
     125     * - 12 : surverse noyé
     126     */
     127    public function Calc($sCalc,$rInit=0.) {
     128        //print_r($this->tP);
    109129        // Calcul du débit (facile !)
    110         if($sCalc=='Q') return $this->OuvrageQ();
    111 
    112         // Sinon calcul d'une autre donnée par dichotomie
    113 
     130        if($sCalc=='Q') {
     131            return $this->OuvrageQ();
     132        }
     133        else {
     134            // Sinon calcul d'une autre donnée par dichotomie
     135            $rVarC = &$this->tP[$sCalc];
     136            $QT = $this->tP['Q']; // Débit recherché (Target)
     137            $XMinInit = 0;
     138            $rVarC = $XMinInit;
     139            list($Q1,$nFlag) = $this->OuvrageQ();
     140            $XMaxInit = $rInit*10; /// @todo Boucler la valeur max sur 10,100,1000,10000
     141            $rVarC = $XMaxInit;
     142            list($Q2,$nFlag) = $this->OuvrageQ();
     143            $DX = ($XMaxInit - $XMinInit) / floatval(self::IDEFINT);
     144            $nIterMax = floor(max($XMaxInit - $rInit,$rInit - $XMinInit) / $DX + 1);
     145            $Xmin = $rInit;
     146            $Xmax = $rInit;
     147            $X1 = $rInit;
     148            $X2 = $rInit;
     149            $rVarC = $rInit;
     150            list($Q,$nFlag) = $this->OuvrageQ();
     151            $Q1 = $Q;
     152            $Q2 = $Q;
     153            //echo "\n".'nIterMax='.$nIterMax.'  XMinInit='.$XMinInit.'  XMaxInit='.$XMaxInit.'  DX='.$DX;
     154
     155
     156            for($nIter=1;$nIter<=$nIterMax;$nIter++) {
     157                //Ouverture de l'intervalle des deux côtés puis à droite et à gauche
     158                $Xmax = $Xmax + $DX;
     159                if($Xmax > $XMaxInit xor $DX <= 0) $Xmax = $XMaxInit;
     160                $rVarC = $Xmax;
     161                list($Q,$nFlag) = $this->OuvrageQ();
     162                if($Q1 < $Q2 xor $Q <= $Q2) {
     163                    $Q2 = $Q;
     164                    $X2 = $Xmax;
     165                }
     166                if($Q1 < $Q2 xor $Q >= $Q1) {
     167                    $Q1 = $Q;
     168                    $X1 = $Xmax;
     169                }
     170                $Xmin = $Xmin - $DX;
     171                if($Xmin < $XMinInit xor $DX <= 0) {
     172                    $Xmin = $XMinInit;
     173                }
     174                $rVarC = $Xmin;
     175                list($Q,$nFlag) = $this->OuvrageQ();
     176                if($Q1 < $Q2 xor $Q <= $Q2) {
     177                    $Q2 = $Q;
     178                    $X2 = $Xmin;
     179                }
     180                if($Q1 < $Q2 xor $Q >= $Q1) {
     181                    $Q1 = $Q;
     182                    $X1 = $Xmin;
     183                }
     184/*
     185                echo "\n".'nIter='.$nIter.' Xmin='.$Xmin.' Xmax='.$Xmax;
     186                echo "\n".'X1='.$X1.' Q1='.$Q1.' X2='.$X2.' Q2='.$Q2;
     187                echo "\n".'$QT > $Q1 xor $QT >= $Q2 = '.($QT > $Q1 xor $QT >= $Q2);
     188*/
     189                if($QT > $Q1 xor $QT >= $Q2) {break;}
     190            }
     191
     192            if($nIter >= self::IDEFINT) {
     193                // Pas d'intervalle trouvé avec au moins une solution
     194                if($Q2 < $QT and $Q1 < $QT) {
     195                    // Cote de l'eau trop basse pour passer le débit il faut ouvrir un autre ouvrage
     196                    $rVarC = $XmaxInit;
     197                }
     198                else {
     199                    // Cote de l'eau trop grande il faut fermer l'ouvrage
     200                    $rVarC = $XminInit;
     201
     202                }
     203                list($Q,$nFlag) = $this->OuvrageQ();
     204                $nFlag = -1;
     205            }
     206            else {
     207                // Dichotomie
     208                $X = $rInit;
     209                for($nIter = 1; $nIter<=self::IDICMAX;$nIter++) {
     210                    $rVarC=$X;
     211                    list($Q,$nFlag) = $this->OuvrageQ();
     212                    if(abs($Q/$QT-1.) <= $this->tP['P']) {break;}
     213                    if($QT < $Q xor $Q1 <= $Q2) {
     214                        // QT < IQ et Q(X1) > Q(X2) ou pareil en inversant les inégalités
     215                        $X1=$rVarC;
     216                    }
     217                    else {
     218                        // QT < IQ et Q(X1) < Q(X2) ou pareil en inversant les inégalités
     219                        $X2=$rVarC;
     220                    }
     221                    $X=($X2+$X1)*0.5;
     222                }
     223                if($nIter == self::IDICMAX) {
     224                    //IF1 <-- -10 anomalie: la dichotomie n'a pas abouti en ITER iterations
     225                    $nFlag = -1;
     226                }
     227            }
     228        }
    114229        return array($rVarC,$nFlag);
    115230    }
     
    118233    /**
    119234     * Calcul du débit à l'ouvrage
    120      * @param $sCalc Variable à calculer (indice du tableau tP)
    121      * @return array(0=> débit, 1=> Flag d'écoulement)
     235     * @return array(0=> débit, 1=> Flag d'écoulement) (Voir Calc)
    122236     */
    123237    private function OuvrageQ() {
    124         /**
    125          * Flag d'écoulement $nFlag :
    126          * - -1 : erreur de calcul
    127          * - 0 : débit nul
    128          * - 1 : surface libre dénoyé
    129          * - 2 : surface libre noyé
    130          * - 3 : charge denoyé
    131          * - 4 : charge noyé partiel
    132          * - 5 : charge noyé total
    133          * - 11 : surverse dénoyé
    134          * - 12 : surverse noyé
    135          */
    136238        $nFlag=-1; // Initialisé à -1 pour détecter les modifications
    137239        // Gestion des sens de l'écoulement
     
    164266        if($nFlag < 0) {
    165267            // On doit pouvoir calculer un débit sur l'ouvrage
    166             list($rQ,$nFlag)=$this->CalculQ($this->nL,$this->Cd);
     268            list($rQ,$nFlag)=$this->CalculQ($this->nL,$this->tP['C']);
    167269            if($this->nLS and isset($this->tP['H']) and $this->tP['W']+$this->tP['H'] < $this->tP['ZM']) {
    168270                // Vanne avec surverse autorisée et la cote amont est supérieure à la cote de surverse
    169                 list($rQS,$nFlagS)=$this->CalculQ($this->nLS,$this->CdS,$this->tP['ZM']-$this->tP['W']-$this->tP['H']);
     271                list($rQS,$nFlagS)=$this->CalculQ($this->nLS,$this->tP['CS'],$this->tP['ZM']-$this->tP['W']-$this->tP['H']);
    170272                $rQ += $rQS;
    171273                $nFlag = $nFlagS+10;
     
    180282            $this->tP['ZM'] = $ZM;
    181283        }
    182 
    183         return array($rQ,$nFlag);
    184     }
     284        //echo "\n".'OuvrageQ='.$rQ.' / '.$nFlag;
     285        return array($rQ,$nFlag);
     286    }
     287
    185288
    186289    /**
    187290     * Loi de vanne de fond dénoyée classique
    188291     * @param $rC Coefficient de débit
    189      * @return array(0=> débit, 1=> Flag d'écoulement)
     292     * @return array(0=> débit, 1=> Flag d'écoulement) (Voir Calc)
    190293     */
    191294    private function VanneDen($rC) {
     
    208311     * Loi de vanne de fond totalement noyée classique
    209312     * @param $rC Coefficient de débit
    210      * @return array(0=> débit, 1=> Flag d'écoulement)
     313     * @return array(0=> débit, 1=> Flag d'écoulement) (Voir Calc)
    211314     */
    212315    private function VanneNoy($rC) {
     
    230333     * @param $rC Coefficient de débit
    231334     * @param $rZ Cote de radier à retrancher pour la surverse
    232      * @return array(0=> débit, 1=> Flag d'écoulement)
     335     * @return array(0=> débit, 1=> Flag d'écoulement) (Voir Calc)
    233336     */
    234337    private function SeuilDen($rC,$rZ=0) {
     
    242345     * @param $rC Coefficient de débit
    243346     * @param $rZ Cote de radier à retrancher pour la surverse
    244      * @return array(0=> débit, 1=> Flag d'écoulement)
     347     * @return array(0=> débit, 1=> Flag d'écoulement) (Voir Calc)
    245348     */
    246349    private function SeuilNoy($rC,$rZ=0) {
     
    255358     * @param $rC Coefficient de débit
    256359     * @param $rZ Cote de radier à retrancher pour la surverse
    257      * @return array(0=> débit, 1=> Flag d'écoulement)
     360     * @return array(0=> débit, 1=> Flag d'écoulement) (Voir Calc)
    258361     */
    259362    private function CalculQ($nLoi,$rC,$rZ=0) {
  • _plugins_/hydraulic/trunk/hyd_inc/section.class.php

    r60821 r60941  
    3939    public $rG=9.81;/// Constante de gravité
    4040    public $iPrec;  /// Précision en nombre de décimales
     41    public $rYB;    /// Hauteur de berge
    4142
    4243    function __construct($rKs, $rQ, $rIf, $rPrec, $rYB, $rYCL = 0, $rDx = 0, $rLong = 0) {
     
    9091    private $rY_old ; /// Mémorisation du tirant d'eau pour calcul intermédiaire
    9192    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;
    9298
    9399    /**
     
    137143    public function Calc($sDonnee, $rY = false) {
    138144        if($rY!==false && $rY!=$this->rY) {
    139             spip_log('Calc('.$sDonnee.') rY='.$rY,'hydraulic');
     145            //spip_log('Calc('.$sDonnee.') rY='.$rY,'hydraulic');
    140146            $this->rY = $rY;
    141147            // On efface toutes les données dépendantes de Y pour forcer le calcul
     
    208214            }
    209215        }
    210         spip_log('Calc('.$sDonnee.')='.$this->arCalc[$sDonnee],'hydraulic');
     216        //spip_log('Calc('.$sDonnee.')='.$this->arCalc[$sDonnee],'hydraulic');
    211217        return $this->arCalc[$sDonnee];
    212218    }
     
    496502    }
    497503
     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    }
    498522}
    499523
     
    650674        return $rDer;
    651675    }
     676
    652677}
    653678
  • _plugins_/hydraulic/trunk/hyd_inc/sectionCirc.class.php

    r60821 r60941  
    3232    public $rD;      /// Diamètre du cercle
    3333    private $rAlpha;    /// Angle de la surface libre par rapport au fond
     34    protected $nbDessinPoints=50;
    3435
    3536    function __construct(&$oLog,&$oP,$rD) {
     
    7273     */
    7374    protected function CalcAlphaDer() {
    74         if($this->rY <= 0 or $this->rY > $this->rD or $this->rY > $this->oP->rYB) {
     75        if($this->rY <= 0 or $this->rY >= $this->rD or $this->rY > $this->oP->rYB) {
    7576            return 0;
    7677        }
  • _plugins_/hydraulic/trunk/hyd_inc/sectionPuiss.class.php

    r60821 r60941  
    3232    protected $rk;      /// Coefficient de forme compris entre 0 et 1
    3333    //$LargeurBerge => La largeur des berges est déjà présente dans acSection
     34    protected $nbDessinPoints=50;
    3435
    3536    function __construct(&$oLog,&$oP,$rk,$rLargeurBerge) {
  • _plugins_/hydraulic/trunk/plugin.xml

    r60821 r60941  
    55    <auteur>David Dorchies, Médéric Dulondel</auteur>
    66    <licence>GNU/GLP</licence>
    7     <version>0.5.1</version>
     7    <version>0.5.2</version>
    88    <necessite id="lib:dist" src="https://bitbucket.org/cleonello/jqplot/downloads/jquery.jqplot.1.0.0b2_r1012.zip" />
    99    <slogan>
     
    3333    <lien>http://sic.g-eau.net/spip.php?rubrique80</lien>
    3434    <necessite id="SPIP" version="[2.1.0;2.1.99]" />
     35    <necessite id="spip_bonux" version="[1.8.7;]" />
    3536    <etat>dev</etat>
    3637    <prefix>hydraulic</prefix>
Note: See TracChangeset for help on using the changeset viewer.