Changeset 95855 in spip-zone


Ignore:
Timestamp:
Mar 8, 2016, 3:38:04 PM (5 years ago)
Author:
dorch@…
Message:
  • Ajout d'un nouveau formulaire pour le calcul du régime uniforme
  • renommage du formulaire calcul_normale_critique en calcul_section (Attention perte de compatibilité ascendante)
  • Amélioration des CSS
  • Factorisation du code
Location:
_plugins_/hydraulic/trunk
Files:
5 added
20 edited
2 moved

Legend:

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

    r95022 r95855  
    304304    $tFlags = array();
    305305    $tAbs = array();
     306    $tRes = array();
     307    $rInit = $datas[$datas['ValCal']];
     308
    306309    for($i = $min; $i <= $max; $i+= $pas){
    307310        if(isset($datas['ValVar'])) {
    308311            $Ouv->Set($datas['ValVar'],$i);
    309312        }
    310         if(!isset($tRes)) {
    311             $rInit = $datas[$datas['ValCal']];
    312             $tRes = array();
    313         }
    314         else {
     313        if(end($tRes)!==false) {
    315314            // Solution initiale = dernière solution trouvée
    316315            $rInit = end($tRes);
  • _plugins_/hydraulic/trunk/formulaires/calcul_section.html

    r95854 r95855  
    1919</script>
    2020
    21 <form method="post" action="#ENV{action}" id="form_normale_critique">
     21<form method="post" action="#ENV{action}" id="form_calcul_section">
    2222    #ACTION_FORMULAIRE{#ENV{action}}
    2323    <table class="hyd_formulaire">
  • _plugins_/hydraulic/trunk/formulaires/calcul_section.php

    r95854 r95855  
    2929
    3030
    31 function formulaires_calcul_normale_critique_charger_dist() {
     31function formulaires_calcul_section_charger_dist() {
    3232    global $FCS;
    3333    return $FCS->charger();
     
    3535
    3636
    37 function formulaires_calcul_normale_critique_verifier_dist(){
     37function formulaires_calcul_section_verifier_dist(){
    3838    global $FCS;
    3939    return $FCS->verifier();
     
    4141
    4242
    43 function formulaires_calcul_normale_critique_traiter_dist(){
     43function formulaires_calcul_section_traiter_dist(){
    4444    global $FCS;
    4545    return $FCS->traiter();
  • _plugins_/hydraulic/trunk/formulaires/courbe_remous.php

    r95765 r95855  
    292292
    293293    // Récupération du graphique
    294     $echo .= $oGraph->GetGraph('courbe_remous',400,600);
     294    $echo .= $oGraph->GetGraph('graphique',400,600);
    295295
    296296
  • _plugins_/hydraulic/trunk/hyd_inc/courbe_remous.php

    r95765 r95855  
    2222   // Boucle de calcul de la courbe de remous
    2323    for($x = $xDeb + $dx; ($dx > 0 && $x <= $xFin) || ($dx < 0 && $x >= $xFin); $x += $dx) {
    24         $rY = (real)$oSection->CalcY(end($trY));
     24        $rY = (real)$oSection->Calc_Y(end($trY));
    2525        if($rY) {
    2626            if(end($trY) > $oSection->rHautNormale xor $rY > $oSection->rHautNormale) {
  • _plugins_/hydraulic/trunk/hyd_inc/dessinSection.class.php

    r95765 r95855  
    5050    private $largeurDessin; // Largeur du dessin en px
    5151    private $marges; // Marge à gauche et à droite du dessin pour le texte
    52     private $mesCouleurs = array('red', 'blue', 'orange', 'green', 'grey', 'black', 'pink');  // Couleur des différentes lignes
     52    private $mesCouleurs = array('red', 'blue', 'orange', 'green', 'grey', 'black', 'DarkMagenta ', 'cyan');  // Couleur des différentes lignes
    5353    private $sectionClass;
    5454    private $donnees = array();
  • _plugins_/hydraulic/trunk/hyd_inc/form_calcul_section.class.php

    r95765 r95855  
    6161        $valeurs = array(
    6262            'choix_section' => 'FT',
    63             'val_a_cal_nc'  => 'Hs',
     63            'val_a_cal'  => 'Hs',
    6464            'choix_champs_select' => $this->champs_select_calc
    6565        );
     
    6868
    6969    protected function calculer() {
    70         include_spip('hyd_inc/section.class');
     70        $this->creer_section_param();
    7171
    7272        // On transforme les champs du tableau des données du formulaire en variables
    73         foreach($this->data as $cle=>&$valeur){
    74             ${$cle} = &$valeur;
    75         }
    76         // On élimine les champs superflus correspondants au type de section non sélectionnés
    77         foreach(array_keys($this->data) as $k) {
    78             if(substr($k,0,1)=='F' && substr($k,0,3)!=$choix_section.'_') {
    79                 unset($this->data[$k]);
    80             }
    81         }
    82 
    83         // Instanciation des objets pour le calcul
    84         $oParam= new cParam($rKs, $rQ, $rIf, $rPrec, $rYB);
    85         switch($choix_section) {
    86             case 'FT':
    87                 include_spip('hyd_inc/sectionTrapez.class');
    88                 $oSection=new cSnTrapez($oLog,$oParam,$FT_rLargeurFond,$FT_rFruit);
    89                 break;
    90 
    91             case 'FR':
    92                 include_spip('hyd_inc/sectionRectang.class');
    93                 $oSection=new cSnRectang($oLog,$oParam,$FR_rLargeurFond);
    94                 break;
    95 
    96             case 'FC':
    97                 include_spip('hyd_inc/sectionCirc.class');
    98                 $oSection=new cSnCirc($oLog,$oParam,$FC_rD);
    99                 break;
    100 
    101             case 'FP':
    102                 include_spip('hyd_inc/sectionPuiss.class');
    103                 $oSection=new cSnPuiss($oLog,$oParam,$FP_rCoef,$FP_rLargeurBerge);
    104                 break;
    105 
    106             default:
    107                 include_spip('hyd_inc/sectionTrapez.class');
    108                 $oSection=new cSnTrapez($oLog,$oParam,$FT_rLargeurFond,$FT_rFruit);
    109 
    110         }
    111         $oSection->rY = $rY;
     73        extract($this->data, EXTR_OVERWRITE|EXTR_REFS);
    11274
    11375        if(isset($ValVar) && $ValVar != ''){
    11476            // Pointage de la variable qui varie sur le bon attribut
    115             if($ValVar == 'rY' or in_array($ValVar, $this->get_champs_section())){
    116                 $oSection->{$ValVar} = &$i;
     77            if($ValVar == 'rY' or in_array($ValVar, $this->get_champs_section($choix_section))){
     78                $this->oSn->{$ValVar} = &$i;
    11779            }
    11880            else{
    119                 $oParam->{$ValVar} = &$i;
     81                $this->oP->{$ValVar} = &$i;
    12082            }
    12183            // Définition de la variable à calculer
     
    13496        }
    13597
    136         $max += $pas/2;
    137 
    13898        $tRes = array(); // Tableau des résultats (ordonnées)
    13999        $tAbs = array(); // Tableau des abscisses
    140100        for($i = $min; $i <= $max; $i+= $pas){
    141             $oSection->Reset(true);
     101            $this->oSn->Reset(true);
    142102            $tAbs[] = $i;
    143103            foreach($tVarCal as $sCalc){
    144                 $rY = $oSection->rY;
     104                $rY = $this->oSn->rY;
    145105                if(!in_array($sCalc,array('Yn', 'Yc', 'Hsc'))){
    146                     $tRes[] = $oSection->Calc($sCalc);
     106                    $tRes[] = $this->oSn->Calc($sCalc);
    147107                }
    148108                else{
    149                     $tRes[] = $oSection->CalcGeo($sCalc);
     109                    $tRes[] = $this->oSn->CalcGeo($sCalc);
    150110                }
    151                 $oSection->rY = $rY;
     111                $this->oSn->rY = $rY;
    152112            }
    153113        }
    154         return array('abs'=>$tAbs,'res'=>$tRes,'tVarCal'=>$tVarCal,'oSection'=>$oSection);
     114        return array('abs'=>$tAbs,'res'=>$tRes,'tVarCal'=>$tVarCal);
    155115    }
    156116
     
    190150            }
    191151
    192             $lib_datas['rYB'] = $this->result['oSection']->oP->rYB;
     152            $lib_datas['rYB'] = $this->oP->rYB;
    193153            include_spip('hyd_inc/dessinSection.class');
    194             $dessinSection = new dessinSection(250, 400, 100, $this->result['oSection'], $lib_datas);
     154            $dessinSection = new dessinSection(250, 400, 100, $this->oSn, $lib_datas);
    195155            $echo.= $dessinSection->GetDessinSection();
    196156            return $echo;
  • _plugins_/hydraulic/trunk/hyd_inc/form_calcul_section_valacal.html

    r95765 r95855  
    44            <select name="val_a_cal" id="val_a_cal">
    55                <BOUCLE_champs_select_cal(POUR){tableau #ENV{choix_champs_select}}>
    6                     <option value="#CLE" [(#ENV{val_a_cal_nc}|=={#CLE}|?{'selected',''})]>[(#VALEUR|traduction_hydraulic)]</option>
     6                    <option value="#CLE" [(#ENV{val_a_cal}|=={#CLE}|?{'selected',''})]>[(#VALEUR|traduction_hydraulic)]</option>
    77                </BOUCLE_champs_select_cal>
    88            </select>
  • _plugins_/hydraulic/trunk/hyd_inc/form_lechapt_calmon.class.php

    r95765 r95855  
    119119    protected function calculer() {
    120120        // On transforme les champs du tableau des données du formulaire en variables
    121         foreach($this->data as $cle=>&$valeur){
    122             ${$cle} = &$valeur;
    123         }
     121        extract($this->data, EXTR_OVERWRITE|EXTR_REFS);
    124122        /*
    125123         * Selon la variable à calculer, on gère les valeurs = à 0  et les valeurs infinies
  • _plugins_/hydraulic/trunk/hyd_inc/form_section.abstract.class.php

    r95765 r95855  
    2525
    2626abstract class form_section extends formulaire {
     27
     28    protected $oSn; ///< Objet section
     29    protected $oP; ///< Objet paramètres de section
    2730
    2831    /*
     
    9598    }
    9699
    97     public function get_champs_section() {
     100    public function get_champs_section($choix_section) {
    98101        $ChampsSection = array();
    99102        foreach($this->saisies as $fs_cle=>$fs) {
    100             if(substr($fs_cle,0,1)=='F') {
     103            if(substr($fs_cle,0,2)==$choix_section) {
    101104                $ChampsSection = array_merge($ChampsSection,array_keys($fs[1]));
    102105            }
     
    105108            $Champ = substr($Champ,3);
    106109        }
     110        spip_log($ChampsSection,'hydraulic',_LOG_DEBUG);
    107111        return $ChampsSection;
     112    }
     113
     114
     115
     116    /** ************************************************************************
     117     * Récupération des libellés des champs des variables de calcul (fvc)
     118     ***************************************************************************/
     119    protected function get_champs_libelles() {
     120        $lib = array();
     121        foreach($this->saisies as $fs) {
     122            foreach($fs[1] as $cle=>$val) {
     123                if($fs[2]!='fix') {
     124                    if(substr($cle,0,1)!='F') {
     125                        $lib[$cle] = _T('hydraulic:'.$val[0]);
     126                    } else {
     127                        $lib[substr($cle,3)] = _T('hydraulic:'.$val[0]);
     128                    }
     129                }
     130            }
     131        }
     132        return $lib;
     133    }
     134
     135
     136    protected function creer_section_param() {
     137        include_spip('hyd_inc/section.class');
     138
     139        foreach(array_keys($this->data) as $k) {
     140            if(substr($k,0,1)=='F') {
     141                if(substr($k,0,3)==$this->data['choix_section'].'_') {
     142                    // On supprime le préfixe pour les champs dépendants du type de section
     143                    $this->data[substr($k,3)] = $this->data[$k];
     144                }
     145                // On élimine les champs avec le préfixe "type de section"
     146                unset($this->data[$k]);
     147            }
     148        }
     149        // On supprime aussi le préfixe sur ValCal et ValVar
     150        foreach(array('ValCal','ValVar') as $k) {
     151            if(isset($this->data[$k]) && substr($this->data[$k],0,1)=='F') {
     152                $this->data[$k] = substr($this->data[$k],3);
     153            }
     154        }
     155
     156        // On transforme les champs du tableau des données du formulaire en variables
     157        extract($this->data, EXTR_OVERWRITE|EXTR_REFS);
     158
     159        // Instanciation des objets pour le calcul
     160        $this->oP = new cParam($rKs, $rQ, $rIf, $rPrec, $rYB);
     161        switch($choix_section) {
     162            case 'FT':
     163                include_spip('hyd_inc/sectionTrapez.class');
     164                $this->oSn=new cSnTrapez($this->oLog,$this->oP,$rLargeurFond,$rFruit);
     165                break;
     166
     167            case 'FR':
     168                include_spip('hyd_inc/sectionRectang.class');
     169                $this->oSn=new cSnRectang($this->oLog,$this->oP,$rLargeurFond);
     170                break;
     171
     172            case 'FC':
     173                include_spip('hyd_inc/sectionCirc.class');
     174                $this->oSn=new cSnCirc($this->oLog,$this->oP,$rD);
     175                break;
     176
     177            case 'FP':
     178                include_spip('hyd_inc/sectionPuiss.class');
     179                $this->oSn=new cSnPuiss($this->oLog,$this->oP,$rCoef,$rLargeurBerge);
     180                break;
     181
     182            default:
     183                include_spip('hyd_inc/sectionTrapez.class');
     184                $this->oSn=new cSnTrapez($this->oLog,$this->oP,$rLargeurFond,$rFruit);
     185        }
     186        $this->oSn->rY = $rY;
    108187    }
    109188}
  • _plugins_/hydraulic/trunk/hyd_inc/formulaire.abstract.class.php

    r95765 r95855  
    11<?php
     2// Instanciation du journal de calcul
     3
     4
    25/** ****************************************************************************
    36 * Gestion des formulaires des calculettes pour l'hydraulique
     
    2629    protected $champs; ///< Liste des codes de champs du formulaire
    2730    protected $data; ///< Données du formulaire
    28     protected $sVarCal=''; ///< Champ à calculer par défaut
     31    protected $sVarCal=''; ///< Nom du champ à calculer par défaut
     32    public $VarCal; ///< Pointeur vers la variable de section qui sera calculée
    2933    protected $nb_col; ///< Nombre de colonnes du tableau du formulaire (2,4 ou 5)
    3034    /** Résultats du calcul - tableau associatif contenant :
     
    3438     *  -  Plus d'autres qui peuvent être définies et utilisées par la méthode 'afficher' des classes filles */
    3539    protected $result;
     40    protected $oLog; ///< Journal de calcul
    3641    private $bNoCache = true; ///< Utilisation du cache pour ne pas refaire les calculs (true pour débugage)
     42
     43    /// Nombre de pas de variation par défaut
     44    protected $nbPas = 15;
    3745
    3846    abstract protected function get_environnement();
     
    5260        spip_log($this->saisies,'hydraulic',_LOG_DEBUG);
    5361        spip_log($this->champs_fvc,'hydraulic',_LOG_DEBUG);
     62        include_spip('hyd_inc/log.class');
     63        $this->oLog = new cLog();
    5464    }
    5565
     
    107117                foreach($tChOblig as $cle1=>$valeur1){
    108118                    if($cle == $valeur1){
    109                         // ... alors on peut supprimer de notre tableau le champs calculé (il n'est pas obligatoire car grisé)
    110                         unset($tChOblig[$cle1]);
    111119                        // Permet de tasser le tableau
    112120                        $tChOblig = array_values($tChOblig);
     
    146154        foreach($this->champs_fvc as $cle){
    147155            $valeurs['choix_champs_'.$cle] = 'fix';
    148             $valeurs['val_min_'.$cle] = 1;
    149             $valeurs['val_max_'.$cle] = 2;
    150             $valeurs['pas_var_'.$cle] = 0.1;
     156            $valeurs['val_min_'.$cle] = $valeurs[$cle]/2;
     157            $valeurs['val_max_'.$cle] = $valeurs[$cle]*2;
     158            $valeurs['pas_var_'.$cle] = 1.5*$valeurs[$cle]/$this->nbPas;
    151159            if(_request('choix_champs_'.$cle)=='cal') {
    152160                $sVarCal = $cle;
     
    195203            $data[$champ] = str_replace(',','.',$data[$champ]); // Bug #574
    196204        }
    197         //spip_log($data,'hydraulic');
    198205        // On ajoute la langue en cours pour différencier le fichier de cache par langue
    199206        $data['sLang'] = $spip_lang;
     
    296303            $this->result = $this->calculer();
    297304        }
     305        spip_log($this->result,'hydraulic',_LOG_DEBUG);
    298306
    299307        // Affichage des résultats
     
    333341        }
    334342        $tLib = $this->get_champs_libelles(); // Libellé traduit des champs fvc
    335         $echo = '';
     343
     344        $echo = $this->oLog->Result(); // Insertion du journal de calcul
     345
    336346        if(!isset($data['ValVar'])) {
    337347            $data['ValVar']='';
     
    388398            // Récupération du graphique
    389399            $graph = $oGraph->GetGraph('graphique',400,600);
    390             $echo = $graph."\n";
    391         }
    392         $echo .= '<div class="hyd_inlineblock">'.$tableau_fixe.'</div>';
     400            $echo .= $graph."\n";
     401        }
     402        $echo .= '<div class="hyd_table">'.$tableau_fixe.'</div>';
    393403        if(isset($tableau_variable)) {
    394             $echo .= '<div class="hyd_inlineblock">'.$tableau_variable.'</div>';
     404            $echo .= '<div class="hyd_table">'.$tableau_variable.'</div>';
    395405        }
    396406        return $echo;
  • _plugins_/hydraulic/trunk/hyd_inc/log.class.php

    r93248 r95855  
    2323
    2424class cLog {
    25    public $txt;
     25    public $txt;
    2626
    27    function __construct() {
    28       $this->txt = '<div class="hyd_log">
    29             <div class="titre">'._T('hydraulic:log_titre').'</div>
    30             <ul>';
    31    }
     27    function __construct() {
     28        $this->txt = '';
     29    }
    3230
    33    public function Add($sTxt,$bErr=false) {
    34       $this->txt .= '<li';
    35       if($bErr) {$this->txt .= ' class="hyd_erreur"';}
    36       $this->txt .= '>'.$sTxt.'</li>';
    37    }
     31    public function Add($sTxt,$bErr=false) {
     32        spip_log($sTxt,'hydraulic',_LOG_INFO);
     33        $this->txt .= '<li';
     34        if($bErr) {$this->txt .= ' class="hyd_erreur"';}
     35        $this->txt .= '>'.$sTxt.'</li>';
     36    }
    3837
    39    public function Result() {
    40       return $this->txt.'</ul></div>';
    41    }
     38    public function Result() {
     39        if($this->txt!='') {
     40            return '<div class="hyd_log">
     41                <div class="titre">'._T('hydraulic:log_titre').'</div>
     42                <ul>'.$this->txt.'
     43                </ul></div>';
     44        } else {
     45            return '';
     46        }
     47    }
    4248}
    4349?>
  • _plugins_/hydraulic/trunk/hyd_inc/ouvrage.class.php

    r95765 r95855  
    7676    private $tP = array();
    7777
     78    public $VarCal; ///< Pointeur vers l'élément du tableau tP qui sera calculé
     79
    7880    const G = 9.81; /// Constante de gravité terrestre
    7981    const R2G = 4.42944; /// sqrt(2*self::gP);
    8082    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
    8383
    8484    /**
     
    135135     */
    136136    public function Calc($sCalc,$rInit=0.) {
    137         // Calcul du débit (facile !)
    138         spip_log("Ouv->Calc($sCalc)",'hydraulic.'._LOG_DEBUG);
    139         spip_log($this,'hydraulic.'._LOG_DEBUG);
     137        include_spip('hyd_inc/dichotomie.class');
    140138        if($sCalc=='Q') {
    141             return $this->OuvrageQ();
    142         }
    143         else {
    144             // Sinon calcul d'une autre donnée par dichotomie
    145             $rVarC = &$this->tP[$sCalc];
    146             $QT = $this->tP['Q']; // Débit recherché (Target)
    147             $XMinInit = 0;
    148             $rVarC = $XMinInit;
    149             list($Q1,$nFlag) = $this->OuvrageQ();
    150             $XMaxInit = $rInit*10; /// @todo Boucler la valeur max sur 10,100,1000,10000
    151             $rVarC = $XMaxInit;
    152             list($Q2,$nFlag) = $this->OuvrageQ();
    153             $DX = ($XMaxInit - $XMinInit) / floatval(self::IDEFINT);
    154             $nIterMax = floor(max($XMaxInit - $rInit,$rInit - $XMinInit) / $DX + 1);
    155             $Xmin = $rInit;
    156             $Xmax = $rInit;
    157             $X1 = $rInit;
    158             $X2 = $rInit;
    159             $rVarC = $rInit;
    160             list($Q,$nFlag) = $this->OuvrageQ();
    161             $Q1 = $Q;
    162             $Q2 = $Q;
    163             //echo "\nQT=$QT nIterMax=$nIterMax XMinInit=$XMinInit XMaxInit=$XMaxInit DX=$DX";
    164 
    165 
    166             for($nIter=1;$nIter<=$nIterMax;$nIter++) {
    167                 //Ouverture de l'intervalle des deux côtés puis à droite et à gauche
    168                 $Xmax = $Xmax + $DX;
    169                 if($Xmax > $XMaxInit xor $DX <= 0) $Xmax = $XMaxInit;
    170                 $rVarC = $Xmax;
    171                 list($Q,$nFlag) = $this->OuvrageQ();
    172                 if($Q1 < $Q2 xor $Q <= $Q2) {
    173                     $Q2 = $Q;
    174                     $X2 = $Xmax;
    175                 }
    176                 if($Q1 < $Q2 xor $Q >= $Q1) {
    177                     $Q1 = $Q;
    178                     $X1 = $Xmax;
    179                 }
    180                 $Xmin = $Xmin - $DX;
    181                 if($Xmin < $XMinInit xor $DX <= 0) {
    182                     $Xmin = $XMinInit;
    183                 }
    184                 $rVarC = $Xmin;
    185                 list($Q,$nFlag) = $this->OuvrageQ();
    186                 if($Q1 < $Q2 xor $Q <= $Q2) {
    187                     $Q2 = $Q;
    188                     $X2 = $Xmin;
    189                 }
    190                 if($Q1 < $Q2 xor $Q >= $Q1) {
    191                     $Q1 = $Q;
    192                     $X1 = $Xmin;
    193                 }
    194 
    195 /*
    196                 echo "\n".'nIter='.$nIter.' Xmin='.$Xmin.' Xmax='.$Xmax;
    197                 echo "\n".'X1='.$X1.' Q1='.$Q1.' X2='.$X2.' Q2='.$Q2;
    198                 echo "\n".'$QT > $Q1 xor $QT >= $Q2 = '.($QT > $Q1 xor $QT >= $Q2);
    199 */
    200 
    201                 if($QT > $Q1 xor $QT >= $Q2) {break;}
    202             }
    203 
    204             if($nIter >= self::IDEFINT) {
    205                 // Pas d'intervalle trouvé avec au moins une solution
    206                 if($Q2 < $QT and $Q1 < $QT) {
    207                     // Cote de l'eau trop basse pour passer le débit il faut ouvrir un autre ouvrage
    208                     $rVarC = $XmaxInit;
    209                 }
    210                 else {
    211                     // Cote de l'eau trop grande il faut fermer l'ouvrage
    212                     $rVarC = $XminInit;
    213 
    214                 }
    215                 list($Q,$nFlag) = $this->OuvrageQ();
    216                 $nFlag = -1;
    217             }
    218             else {
    219                 // Dichotomie
    220                 $X = $rInit;
    221                 for($nIter = 1; $nIter<=self::IDICMAX;$nIter++) {
    222                     $rVarC=$X;
    223                     list($Q,$nFlag) = $this->OuvrageQ();
    224                     if($QT!=0 && abs($Q/$QT-1.) <= $this->tP['rPrec']) {break;}
    225                     if($QT < $Q xor $Q1 <= $Q2) {
    226                         // QT < IQ et Q(X1) > Q(X2) ou pareil en inversant les inégalités
    227                         $X1=$rVarC;
    228                     }
    229                     else {
    230                         // QT < IQ et Q(X1) < Q(X2) ou pareil en inversant les inégalités
    231                         $X2=$rVarC;
    232                     }
    233                     $X=($X2+$X1)*0.5;
    234                 }
    235                 if($nIter == self::IDICMAX) {
    236                     //IF1 <-- -10 anomalie: la dichotomie n'a pas abouti en ITER iterations
    237                     $nFlag = -1;
    238                 }
    239             }
    240         }
    241         spip_log("Ouv->Calc rVarC=$rVarC nFlag=$nFlag",'hydraulic.'._LOG_DEBUG);
    242         return array($rVarC,$nFlag);
     139            // Calcul du débit par la loi d'ouvrage
     140            return OuvrageQ();
     141        } else {
     142            // Calcul indirect par dichotomie
     143            $this->VarCal = &$this->tP[$sCalc];
     144            $oDicho = new cDichotomie($this->oLog,$this,'OuvrageQ');
     145            return $oDicho->calculer($this->tP['Q'],$this->tP['rPrec'],$rInit);
     146        }
    243147    }
    244148
     
    248152     * @return array(0=> débit, 1=> Flag d'écoulement) (Voir Calc)
    249153     */
    250     private function OuvrageQ() {
     154    public function OuvrageQ() {
    251155        $nFlag=-1; // Initialisé à -1 pour détecter les modifications
    252156        $bSensAmAv = true; // Par défaut on considère le sens d'écoulement amont -> aval
  • _plugins_/hydraulic/trunk/hyd_inc/section.class.php

    r95765 r95855  
    110110    }
    111111
     112
    112113    /**
    113114     * Efface toutes les données calculées pour forcer le recalcul
     115     * @param $bGeo Réinitialise les données de géométrie aussi
    114116     */
    115117    public function Reset($bGeo=true) {
     
    119121      }
    120122    }
     123
    121124
    122125    /**
     
    154157            // La donnée a besoin d'être calculée
    155158            switch($sDonnee) {
    156                 case 'S' : // Surface mouillée
    157                     $this->arCalc[$sDonnee] = $this->CalcS();
    158                     break;
    159                 case 'P' : // Périmètre mouillé
    160                     $this->arCalc[$sDonnee] = $this->CalcP();
    161                     break;
    162                 case 'R' : // Rayon hydraulique
    163                     $this->arCalc[$sDonnee] = $this->CalcR();
    164                     break;
    165                 case 'B' : // Largeur au miroir
    166                     $this->arCalc[$sDonnee] = $this->CalcB();
    167                     break;
    168                 case 'J' : // Perte de charge linéaire
    169                     $this->arCalc[$sDonnee] = $this->CalcJ();
    170                     break;
    171                 case 'Fr' : // Froude
    172                     $this->arCalc[$sDonnee] = $this->CalcFr();
    173                     break;
    174                 case 'dP' : // dP/dY
    175                     $this->arCalc[$sDonnee] = $this->CalcPder();
    176                     break;
    177                 case 'dR' : // dR/dY
    178                     $this->arCalc[$sDonnee] = $this->CalcRder();
    179                     break;
    180                 case 'dB' : // dB/dY
    181                     $this->arCalc[$sDonnee] = $this->CalcBder();
    182                     break;
    183                 case 'V' : // Vitesse moyenne
    184                     $this->arCalc[$sDonnee] = $this->CalcV();
    185                     break;
    186                 case 'Hs' : // Charge spécifique
    187                     $this->arCalc[$sDonnee] = $this->CalcHs();
    188                     break;
    189                 case 'Yf' : // Tirant d'eau fluvial
    190                     $this->arCalc[$sDonnee] = $this->CalcYf();
    191                     break;
    192                 case 'Yt' : // Tirant d'eau torrentiel
    193                     $this->arCalc[$sDonnee] = $this->CalcYt();
    194                     break;
    195                 case 'Yco' : // Tirant d'eau conjugué
    196                     $this->arCalc[$sDonnee] = $this->CalcYco();
    197                     break;
    198                 case 'Tau0' : // Force tractrice ou contrainte de cisaillement
    199                     $this->arCalc[$sDonnee] = $this->CalcTau0();
    200                     break;
    201                 case 'SYg' : // Distance du centre de gravité de la section à la surface libre
    202                     $this->arCalc[$sDonnee] = $this->CalcSYg();
    203                 case 'dSYg' : // Dérivée Distance du centre de gravité de la section à la surface libre
    204                     $this->arCalc[$sDonnee] = $this->CalcSYgder();
    205                     break;
    206                 case 'Imp' : // Impulsion hydraulique
    207                     $this->arCalc[$sDonnee] = $this->CalcImp();
    208                     break;
    209                 case 'Alpha' : // Angle Alpha de la surface libre par rapport au fond pour les sections circulaires
    210                     $this->arCalc[$sDonnee] = $this->CalcAlpha();
    211                     break;
    212                 case 'dAlpha' : // Dérivée de l'angle Alpha de la surface libre par rapport au fond pour les sections circulaires
    213                     $this->arCalc[$sDonnee] = $this->CalcAlphaDer();
    214                     break;
    215159                case 'I-J' : // Variation linéaire de l'énergie spécifique (I-J) en m/m
    216160                    $this->arCalc[$sDonnee] = $this->oP->rIf-$this->Calc('J');
    217161                    break;
     162                default :
     163                    $Methode = 'Calc_'.$sDonnee;
     164                    $this->arCalc[$sDonnee] = $this->$Methode();
    218165            }
    219166        }
     
    221168        return $this->arCalc[$sDonnee];
    222169    }
    223 
    224170
    225171
     
    244190                case 'B' : // Largeur aux berges
    245191
    246                     $this->arCalcGeo[$sDonnee] = $this->CalcB();
     192                    $this->arCalcGeo[$sDonnee] = $this->Calc_B();
    247193                    if($this->arCalcGeo[$sDonnee] < $this->oP->rYB / 100) {
    248194                        // Section fermée
     
    253199                    $this->rLargeurBerge = $this->arCalcGeo[$sDonnee];
    254200                    break;
    255                 case 'S' : // Surface mouillée au niveau des berges
    256                     $this->arCalcGeo[$sDonnee] = $this->CalcS();
    257                     break;
    258                 case 'P' : // Périmètre mouillé au niveau des berges
    259                     $this->arCalcGeo[$sDonnee] = $this->CalcP();
    260                     break;
    261                 case 'Yc' : // Tirant d'eau critique
    262                     $this->arCalcGeo[$sDonnee] = $this->CalcYc();
    263                     break;
    264                 case 'Yn' : // Tirant d'eau normal
    265                     $this->arCalcGeo[$sDonnee] = $this->CalcYn();
    266                     break;
    267                 case 'Hsc' : // Charge spécifique critique
    268                     $this->arCalcGeo[$sDonnee] = $this->CalcHsc();
     201                default :
     202                    $Methode = 'Calc_'.$sDonnee;
     203                    $this->arCalcGeo[$sDonnee] = $this->$Methode();
    269204            }
    270205            //~ spip_log('CalcGeo('.$sDonnee.',rY='.$this->oP->rYB.')='.$this->arCalcGeo[$sDonnee],'hydraulic.'._LOG_DEBUG);
     
    274209    }
    275210
     211
    276212    /**
    277213     * Calcul de la surface hydraulique.
    278214     * @return La surface hydraulique
    279215     */
    280     protected function CalcS($rY) {
     216    protected function Calc_S($rY) {
    281217        //~ spip_log('section->CalcS(rY='.$rY.')='.($rY*$this->rLargeurBerge),'hydraulic.'._LOG_DEBUG);
    282218        return $rY*$this->rLargeurBerge;
     
    284220
    285221
     222    /**
     223     * Calcul de la dérivée surface hydraulique.
     224     * @return La surface hydraulique
     225     */
     226    protected function Calc_dS() {
     227        return $this->rLargeurBerge;
     228    }
     229
     230
    286231   /**
    287232    * Calcul du périmètre hydraulique.
    288233    * @return Le périmètre hydraulique
    289234    */
    290     protected function CalcP($rY=0) {
     235    protected function Calc_P($rY=0) {
    291236        //~ spip_log('section->CalcP(rY='.$rY.')='.(2*$rY),'hydraulic.'._LOG_DEBUG);
    292237        return 2*$rY;
    293238    }
     239
     240
    294241    /**
    295242     * Calcul de dérivée du périmètre hydraulique par rapport au tirant d'eau.
    296243     * @return dP
    297244     */
    298     protected function CalcPder() {
     245    protected function Calc_dP() {
    299246        return 2;
    300247    }
     248
    301249
    302250   /**
     
    304252    * @return Le rayon hydraulique
    305253    */
    306     protected function CalcR() {
     254    protected function Calc_R() {
    307255        if($this->Calc('P')!=0) {
    308256            return $this->Calc('S')/$this->Calc('P');
     
    313261    }
    314262
     263
    315264    /**
    316265     * Calcul de dérivée du rayon hydraulique par rapport au tirant d'eau.
    317266     * @return dR
    318267     */
    319     protected function CalcRder() {
     268    protected function Calc_dR() {
    320269        if($this->Calc('P')!=0) {
    321270            return ($this->Calc('B')*$this->Calc('P')-$this->Calc('S')*$this->Calc('dP'))/pow($this->Calc('P'),2);
     
    326275    }
    327276
     277
    328278   /**
    329279    * Calcul de la largeur au miroir.
    330280    * @return La largeur au miroir
    331281    */
    332     protected function CalcB() {
     282    protected function Calc_B() {
    333283        return $this->rLargeurBerge;
    334284    }
     285
     286
    335287    /**
    336288     * Calcul de dérivée de la largeur au miroir par rapport au tirant d'eau.
    337289     * @return dB
    338290     */
    339     protected function CalcBder() {
     291    protected function Calc_dB() {
    340292        return 0;
    341293    }
     294
    342295
    343296   /**
     
    345298    * @return La perte de charge
    346299    */
    347     private function CalcJ() {
     300    private function Calc_J() {
    348301        if($this->Calc('R')!=0) {
    349302            return pow($this->Calc('V')/$this->oP->rKs,2)/pow($this->Calc('R'),4/3);
     
    354307    }
    355308
     309
    356310   /**
    357311    * Calcul du nombre de Froude.
    358312    * @return Le nombre de Froude
    359313    */
    360     private function CalcFr() {
     314    private function Calc_Fr() {
    361315        if($this->Calc('S')!=0) {
    362316            return $this->oP->rQ/$this->Calc('S')*sqrt($this->Calc('B')/$this->Calc('S')/$this->oP->rG);
     
    370324    * Calcul de dy/dx
    371325    */
    372     private function CalcdYdX($Y) {
     326    private function Calc_dYdX($Y) {
    373327        // L'appel à Calc('J') avec Y en paramètre réinitialise toutes les données dépendantes de la ligne d'eau
    374328        return - ($this->oP->rIf - $this->Calc('J',$Y)) / (1 - pow($this->Calc('Fr',$Y),2));
     
    380334    * @return Tirant d'eau
    381335    */
    382     public function CalcY_Euler($Y) {
     336    public function Calc_Y_Euler($Y) {
    383337        // L'appel à Calc('J') avec Y en paramètre réinitialise toutes les données dépendantes de la ligne d'eau
    384         $Y2 = $Y+ $this->oP->rDx * $this->CalcdYdX($Y);
     338        $Y2 = $Y+ $this->oP->rDx * $this->Calc_dYdX($Y);
    385339        if($this->oP->rDx > 0 xor !($Y2 < $this->rHautCritique)) {
    386340            return false;
     
    395349    * @return Tirant d'eau
    396350    */
    397     public function CalcY_RK4($Y) {
     351    public function Calc_Y_RK4($Y) {
    398352        // L'appel à Calc('J') avec Y en paramètre réinitialise toutes les données dépendantes de la ligne d'eau
    399353        $rDx = $this->oP->rDx;
    400         $rk1 = $this->CalcdYdX($Y);
     354        $rk1 = $this->Calc_dYdX($Y);
    401355        if($this->oP->rDx > 0 xor !($Y + $rDx / 2 * $rk1 < $this->rHautCritique)) {return false;}
    402         $rk2 = $this->CalcdYdX($Y + $rDx / 2 * $rk1);
     356        $rk2 = $this->Calc_dYdX($Y + $rDx / 2 * $rk1);
    403357        if($this->oP->rDx > 0 xor !($Y + $rDx / 2 * $rk2 < $this->rHautCritique)) {return false;}
    404         $rk3 = $this->CalcdYdX($Y + $rDx / 2 * $rk2);
     358        $rk3 = $this->Calc_dYdX($Y + $rDx / 2 * $rk2);
    405359        if($this->oP->rDx > 0 xor !($Y + $rDx / 2 * $rk3 < $this->rHautCritique)) {return false;}
    406         $rk4 = $this->CalcdYdX($Y + $rDx * $rk3);
     360        $rk4 = $this->Calc_dYdX($Y + $rDx * $rk3);
    407361        if($this->oP->rDx > 0 xor !($Y + $rDx / 6 * ($rk1 + 2 * ($rk2 + $rk3) + $rk4) < $this->rHautCritique)) {return false;}
    408362        return $Y + $rDx / 6 * ($rk1 + 2 * ($rk2 + $rk3) + $rk4);
     
    414368    * @return Tirant d'eau
    415369    */
    416     public function CalcY($rY) {
    417         $funcCalcY = 'CalcY_'.$this->oP->sResolution;
     370    public function Calc_Y($rY) {
     371        $funcCalcY = 'Calc_Y_'.$this->oP->sResolution;
    418372        if(method_exists($this,$funcCalcY)) {
    419373            return $this->$funcCalcY($rY);
     
    423377    }
    424378
     379
    425380   /**
    426381    * Calcul de la vitesse moyenne.
    427382    * @return Vitesse moyenne
    428383    */
    429     private function CalcV() {
     384    private function Calc_V() {
    430385        if($this->Calc('S')!=0) {
    431386            return $this->oP->rQ/$this->Calc('S');
     
    436391    }
    437392
     393
    438394   /**
    439395    * Calcul de la charge spécifique.
    440396    * @return Charge spécifique
    441397    */
    442     private function CalcHs() {
     398    private function Calc_Hs() {
    443399        return $this->rY+pow($this->Calc('V'),2)/(2*$this->oP->rG);
    444400    }
     
    449405    * @return Charge spécifique critique
    450406    */
    451     private function CalcHsc() {
     407    private function Calc_Hsc() {
    452408        $this->Swap(true); // On mémorise les données hydrauliques en cours
    453409        // On calcule la charge avec la hauteur critique
     
    463419    * @return tirant d'eau critique
    464420    */
    465     private function CalcYc() {
     421    private function Calc_Yc() {
    466422        $oHautCritique = new cHautCritique($this, $this->oP);
    467423        if(!$this->rHautCritique = $oHautCritique->Newton($this->oP->rYB) or !$oHautCritique->HasConverged()) {
     
    475431    * @return tirant d'eau normal
    476432    */
    477     private function CalcYn() {
     433    private function Calc_Yn() {
    478434        if($this->oP->rIf <= 0) {
    479435            $this->rHautNormale = false;
     
    488444    }
    489445
     446
    490447   /**
    491448    * Calcul du tirant d'eau fluvial.
    492449    * @return tirant d'eau fluvial
    493450    */
    494     private function CalcYf() {
     451    private function Calc_Yf() {
    495452        if($this->rY > $this->CalcGeo('Yc')) {
    496453            return $this->rY;
     
    502459    }
    503460
     461
    504462   /**
    505463    * Calcul du tirant d'eau torrentiel.
    506464    * @return tirant d'eau torrentiel
    507465    */
    508     private function CalcYt() {
     466    private function Calc_Yt() {
    509467        if($this->rY < $this->CalcGeo('Yc')) {
    510468            return $this->rY;
     
    516474    }
    517475
     476
    518477   /**
    519478    * Calcul du tirant d'eau conjugué.
    520479    * @return tirant d'eau conjugué
    521480    */
    522     protected function CalcYco() {
     481    protected function Calc_Yco() {
    523482        $oHautConj= new cHautConjuguee($this, $this->oP);
    524483        // Choisir une valeur initiale du bon côté de la courbe
     
    537496    }
    538497
     498
    539499   /**
    540500    * Calcul de la contrainte de cisaillement.
    541501    * @return contrainte de cisaillement
    542502    */
    543     private function CalcTau0() {
     503    private function Calc_Tau0() {
    544504        return 1000 * $this->oP->rG * $this->Calc('R') * $this->Calc('J');
    545505    }
     
    550510     * @return S x Yg
    551511     */
    552     protected function CalcSYg($rY) {
     512    protected function Calc_SYg($rY) {
    553513        return pow($rY,2) * $this->rLargeurBerge / 2;
    554514    }
     515
    555516
    556517    /**
     
    559520     * @return S x Yg
    560521     */
    561     protected function CalcSYgder($rY) {
     522    protected function Calc_dSYg($rY) {
    562523        return $rY * $this->rLargeurBerge;
    563524    }
     
    568529     * @return Impulsion hydraulique
    569530     */
    570     protected function CalcImp() {
     531    protected function Calc_Imp() {
    571532        return 1000 * ($this->oP->rQ * $this->Calc('V') + $this->oP->rG * $this->Calc('SYg'));
    572533    }
     534
    573535
    574536    /**
     
    576538     * @return Angle Alpha pour une section circulaire, 0 sinon.
    577539     */
    578     protected function CalcAlpha(){
     540    protected function Calc_Alpha(){
    579541        return 0;
    580542    }
     543
    581544
    582545    /**
     
    584547     * @return Dérivée de l'angle Alpha pour une section circulaire, 0 sinon.
    585548     */
    586     protected function CalcAlphaDer(){
     549    protected function Calc_dAlpha(){
    587550        return 0;
    588551    }
  • _plugins_/hydraulic/trunk/hyd_inc/sectionCirc.class.php

    r93248 r95855  
    4444     * @return Alpha
    4545     */
    46     protected function CalcAlpha() {
     46    protected function Calc_Alpha() {
    4747        if($this->rY > $this->oP->rYB) {
    4848            $rY = $this->oP->rYB;
     
    7272     * @return dAlpha
    7373     */
    74     protected function CalcAlphaDer() {
     74    protected function Calc_dAlpha() {
    7575        if($this->rY <= 0 or $this->rY >= $this->rD or $this->rY > $this->oP->rYB) {
    7676            return 0;
     
    8585     * @return B
    8686     */
    87     protected function CalcB() {
     87    protected function Calc_B() {
    8888        if($this->rY > $this->oP->rYB) {
    89             return parent::CalcB();
     89            return parent::Calc_B();
    9090        }
    9191        else {
     
    9999     * @return B
    100100     */
    101      protected function CalcP($rY=0) {
     101     protected function Calc_P($rY=0) {
    102102        if($this->rY > $this->oP->rYB and !$this->bSnFermee) {
    103103            // On n'ajoute pas le périmètre dans le cas d'une fente de Preissmann
    104             return $this->CalcGeo('P') + parent::CalcP($this->rY-$this->oP->rYB);
     104            return $this->CalcGeo('P') + parent::Calc_P($this->rY-$this->oP->rYB);
    105105        }
    106106        else {
     
    114114     * @return S
    115115     */
    116     protected function CalcS($rY=0) {
     116    protected function Calc_S($rY=0) {
    117117        if($this->rY > $this->oP->rYB) {
    118             return $this->CalcGeo('S') + parent::CalcS($this->rY-$this->oP->rYB);
     118            return $this->CalcGeo('S') + parent::Calc_S($this->rY-$this->oP->rYB);
    119119        }
    120120        else {
     
    127127     * @return dS
    128128     */
    129     protected function CalcSder() {
     129    protected function Calc_dS() {
    130130        if($this->rY > $this->oP->rYB) {
    131             return parent::CalcSder();
     131            return parent::Calc_dS();
    132132        }
    133133        else {
     
    140140     * @return dP
    141141     */
    142     protected function CalcPder() {
     142    protected function Calc_dP() {
    143143        if($this->rY > $this->oP->rYB && !$this->bSnFermee) {
    144             return parent::CalcPder();
     144            return parent::Calc_dP();
    145145        }
    146146        else {
     
    153153     * @return dB
    154154     */
    155     protected function CalcBder() {
     155    protected function Calc_dB() {
    156156        if($this->rY > $this->oP->rYB) {
    157             return parent::CalcBder();
     157            return parent::Calc_dB();
    158158        }
    159159        else {
     
    168168     * @return S x Yg
    169169     */
    170     protected function CalcSYg($rY=0) {
     170    protected function Calc_SYg($rY=0) {
    171171        $SYg = sin($this->Calc('Alpha'))-pow(sin($this->Calc('Alpha')),3) / 3 - $this->Calc('Alpha') * cos($this->Calc('Alpha'));
    172172        $SYg = pow($this->rD,3) / 8 * $SYg;
     
    180180     * @return S x Yg
    181181     */
    182     protected function CalcSYgder($rY=0) {
     182    protected function Calc_dSYg($rY=0) {
    183183        $cos = cos($this->Calc('Alpha'));
    184184        $sin = sin($this->Calc('Alpha'));
  • _plugins_/hydraulic/trunk/hyd_inc/sectionPuiss.class.php

    r93248 r95855  
    4444     * @return Lambda
    4545     */
    46     protected function CalcAlpha() {
     46    protected function Calc_Alpha() {
    4747        return $this->rLargeurBerge/pow($this->oP->rYB,$this->rk);
    4848    }
     
    5252     * @return B
    5353     */
    54     protected function CalcB() {
     54    protected function Calc_B() {
    5555        if($this->rY >= $this->oP->rYB) {
    5656            return $this->rLargeurBerge;
     
    6363    /**
    6464     * Calcul du périmètre mouillé.
    65      * @param $rY Uniquement présent car la méthode parent à cet argument
     65     * @param $rY Uniquement présent car la méthode parent a cet argument
    6666     * @return B
    6767     */
    68      protected function CalcP($rY=0) {
     68     protected function Calc_P($rY=0) {
    6969        $n=100; /// Le nombre de partie pour le calcul de l'intégrale
    7070        $rLambda2 = pow($this->Calc('Alpha'),2);
     
    8585     * @return S
    8686     */
    87     protected function CalcS($rY=0) {
     87    protected function Calc_S($rY=0) {
    8888        return $this->Calc('Alpha')*pow($this->rY, $this->rk+1)/($this->rk+1);
    8989    }
     
    9494     * @return dP
    9595     */
    96     protected function CalcPder() {
     96    protected function Calc_dP() {
    9797        return 2 * sqrt(1+pow($this->rk*$this->Calc('Alpha')/2,2)*pow($this->rY,2*($this->rk-1)));
    9898    }
     
    102102     * @return dB
    103103     */
    104     protected function CalcBder() {
     104    protected function Calc_dB() {
    105105        return $this->Calc('Alpha')*$this->rk*pow($this->rY,$this->rk-1);
    106106    }
     
    112112     * @return S x Yg
    113113     */
    114     protected function CalcSYg($rY=0) {
     114    protected function Calc_SYg($rY=0) {
    115115        return $this->Calc('Alpha')*pow($this->rY, $this->rk+2)/(($this->rk+1)*($this->rk+2));
    116116    }
     
    121121     * @return S x Yg
    122122     */
    123     protected function CalcSYgder($rY=0) {
     123    protected function Calc_dSYg($rY=0) {
    124124        $SYg = $this->Calc('dAlpha')*pow($this->rY, $this->rk+2) + $this->Calc('Alpha')*pow($this->rY, $this->rk+1)*($this->rk+2);
    125125        return $SYg/(($this->rk+1)*($this->rk+2));
  • _plugins_/hydraulic/trunk/hyd_inc/sectionRectang.class.php

    r93248 r95855  
    4141     * @return Périmètre mouillé (m)
    4242     */
    43     protected function CalcP($rY=0) {
    44         return $this->rLargeurBerge+parent::CalcP($this->rY);
     43    protected function Calc_P($rY=0) {
     44        return $this->rLargeurBerge+parent::Calc_P($this->rY);
    4545    }
    4646
     
    5050     * @return Surface mouillée (m2)
    5151     */
    52     protected function CalcS($rY=0) {
    53         return parent::CalcS($this->rY);
     52    protected function Calc_S($rY=0) {
     53        return parent::Calc_S($this->rY);
    5454    }
    5555
     
    6060     * @return SYg
    6161     */
    62     protected function CalcSYg($rY=0) {
    63         return parent::CalcSYg($this->rY);
     62    protected function Calc_SYg($rY=0) {
     63        return parent::Calc_SYg($this->rY);
    6464    }
    6565
     
    7070     * @return Dérivée de SYg par rapport à Y
    7171     */
    72     protected function CalcSYgder($rY=0) {
    73         return parent::CalcSYgder($this->rY);
     72    protected function Calc_dSYg($rY=0) {
     73        return parent::Calc_dSYg($this->rY);
    7474    }
    7575
  • _plugins_/hydraulic/trunk/hyd_inc/sectionTrapez.class.php

    r95022 r95855  
    4040    }
    4141
    42     protected function CalcB($bBerge=false) {
     42    protected function Calc_B($bBerge=false) {
    4343        if(!$bBerge && $this->rY > $this->oP->rYB) {
    4444            return $this->rLargeurBerge;
     
    5454     * @return Périmètre mouillé (m)
    5555     */
    56     protected function CalcP($rY=0) {
     56    protected function Calc_P($rY=0) {
    5757        if($this->rY > $this->oP->rYB) {
    58             $P = $this->CalcGeo('P') + parent::CalcP($this->rY-$this->oP->rYB);
     58            $P = $this->CalcGeo('P') + parent::Calc_P($this->rY-$this->oP->rYB);
    5959        }
    6060        else {
     
    7171     * @return Surface mouillée (m2)
    7272     */
    73     protected function CalcS($rY=0) {
     73    protected function Calc_S($rY=0) {
    7474        if($this->rY > $this->oP->rYB) {
    75             $S = $this->CalcGeo('S') + parent::CalcS($this->rY-$this->oP->rYB);
     75            $S = $this->CalcGeo('S') + parent::Calc_S($this->rY-$this->oP->rYB);
    7676        }
    7777        else {
     
    8686     * @return dS
    8787     */
    88     protected function CalcSder() {
     88    protected function Calc_dS() {
    8989        if($this->rY > $this->oP->rYB) {
    90             return parent::CalcSder();
     90            return parent::Calc_dS();
    9191        }
    9292        else {
     
    9999     * @return dP
    100100     */
    101     protected function CalcPder() {
     101    protected function Calc_dP() {
    102102        if($this->rY > $this->oP->rYB) {
    103             return parent::CalcPder();
     103            return parent::Calc_dP();
    104104        }
    105105        else {
     
    112112     * @return dB
    113113     */
    114     protected function CalcBder() {
     114    protected function Calc_dB() {
    115115        if($this->rY > $this->oP->rYB) {
    116             return parent::CalcBder();
     116            return parent::Calc_dB();
    117117        }
    118118        else {
     
    127127     * @return S x Yg
    128128     */
    129     protected function CalcSYg($rY=0) {
     129    protected function Calc_SYg($rY=0) {
    130130        return ($this->rLargeurFond / 2 + $this->rFruit * $this->rY / 3) * pow($this->rY,2);
    131131    }
     
    137137     * @return S x Yg
    138138     */
    139     protected function CalcSYgder($rY=0) {
     139    protected function Calc_dSYg($rY=0) {
    140140        $SYg = $this->rFruit / 3 * pow($this->rY,2);
    141141        $SYg += ($this->rLargeurFond / 2 + $this->rFruit * $this->rY / 3) * 2 * $this->rY;
  • _plugins_/hydraulic/trunk/hydraulic.css.html

    r95765 r95855  
    55.hyd_log {
    66    border: 1px solid black;
    7     margin: 1.8em 1.15em;
     7    margin: 1.8em 0;
    88    padding: 0.65em;
    99    display: block;
     
    1111    width: 100%;
    1212    border-radius: 10px;
     13    text-align: left;
     14    box-sizing: border-box;
    1315}
    1416
     
    9294}
    9395
    94 #jqplot, #jqplot, #jqplot{
    95     margin: 0 auto;
     96#jqplot_graphique {
     97    margin: 2em auto;
    9698}
    9799
     
    125127}
    126128
    127 .hyd_inlineblock {
     129.hyd_table {
    128130    display: inline-block;
    129131    vertical-align: top;
  • _plugins_/hydraulic/trunk/lang/hydraulic_en.php

    r95765 r95855  
    4343    'donnee_calc'       => "Data to compute",
    4444    'debit'             => "Flow (m<sup>3</sup>/s)",
     45    'dichotomie_intervalle' => "Target value out of search interval",
     46    'dichotomie_non_convergence' => "Non convergence of dichotomy at required accuracy, found value correspond to a discharge of ",
    4547    // E
    4648    'erreur_obligatoire' => "This field is required",
  • _plugins_/hydraulic/trunk/lang/hydraulic_fr.php

    r95765 r95855  
    4343    'donnee_calc'       => "Donnée à calculer",
    4444    'debit'             => "Débit (m<sup>3</sup>/s)",
     45    'dichotomie_intervalle' => "La valeur cible se trouve en dehors de l'intervalle de recherche",
     46    'dichotomie_non_convergence' => "Non convergence de la dichotomie à la précision demandée, la valeur trouvée correspond à un débit de",
    4547    // E
    4648    'erreur_obligatoire' => "Ce champ est obligatoire",
  • _plugins_/hydraulic/trunk/plugin.xml

    r95765 r95855  
    55    <auteur>David Dorchies, Médéric Dulondel</auteur>
    66    <licence>GNU/GLP</licence>
    7     <version>0.7.3</version>
     7    <version>0.8.0</version>
    88    <necessite id="lib:dist" src="https://bitbucket.org/cleonello/jqplot/downloads/jquery.jqplot.1.0.8r1250.zip" />
    99    <slogan>
     
    1919-* &lt;formulaire|courbe_remous&gt; : Calcul d'une courbe de remous dans un canal à section paramétrée &#224; surface libre
    2020-* &lt;formulaire|lechapt_calmon&gt; : Calculs pour une conduite circulaire en charge avec la formule de Lechapt et Calmon
    21 -* &lt;formulaire|calcul_normale_critique&gt; : Calcul des paramètres hydrauliques d'une section paramétrée
     21-* &lt;formulaire|calcul_section&gt; : Calcul des paramètres hydrauliques d'une section paramétrée
     22-* &lt;formulaire|calcul_regime_uniforme&gt; : Calcul du régime uniforme sur une section paramétrée
    2223-* &lt;formulaire|calcul_ouvrages&gt; : Calcul des paramètres hydrauliques d'un ouvrage (seuil, vanne...)
    2324[en]Calculator for performing calculations in hydraulic adapted to canals and rivers. The plugin comes
     
    2728-* &lt;formulaire|courbe_remous&gt; : Calculation of a backwater curve in a parametrized section channel with free surface
    2829-* &lt;formulaire|lechapt_calmon&gt; : Calculations on hydraulic head for a circular pipe with Lechapt and Calmon formula
    29 -* &lt;formulaire|calcul_normale_critique&gt; : Calculation of hydraulic parameters in a parametrized section
     30-* &lt;formulaire|calcul_section&gt; : Calculation of hydraulic parameters in a parametrized section
     31-* &lt;formulaire|calcul_regime_uniforme&gt; : Calculation of uniform regime in a parametrized section
    3032-* &lt;formulaire|calcul_ouvrages&gt; : Calculation of hydraulic parameters of a device (weir, gate...)
    3133    </multi>
Note: See TracChangeset for help on using the changeset viewer.