Changeset 103586 in spip-zone


Ignore:
Timestamp:
Mar 26, 2017, 9:25:06 PM (3 years ago)
Author:
dorch@…
Message:

Courbe de remous : ajout d'une variable calculée et réusinage pour utilisation du framework de formulaire hydraulic

Location:
_plugins_/hydraulic/trunk
Files:
3 added
1 deleted
15 edited

Legend:

Unmodified
Added
Removed
  • _plugins_/hydraulic/trunk/formulaires/calcul_regime_uniforme.html

    r103348 r103586  
    1 [<div class='hyd_formulaire_erreur '><span>(#ENV*{message_erreur})</span></div>]
    2 <script language="javascript" type="text/javascript" src="#CHEMIN{js/hyd_fonctions.js}"></script>
    3 
    4 <form method="post" action="#ENV{action}#VAL{#hyd_resultat}" id="form_regime_uniforme">
    5         #ACTION_FORMULAIRE{#ENV{action}}
    6         <table class="hyd_formulaire">
    7                 <tbody>
    8 
    9                         <!-- On génère les champs du formulaire en suivant le tableau saisies -->
    10                         <INCLURE{fond=hyd_inc/formulaire_champs,env}>
    11 
    12                         <tr>
    13                                 <td colspan="4" class="hyd_bouton_submit">
    14                                         <input type="submit" value="<:hydraulic:calculer:>">
    15                                 </td>
    16                         </tr>
    17 
    18                 </tbody>
    19         </table>
    20 </form>
     1<INCLURE{fond=formulaires/hydraulic,env}>
    212
    223<script language="javascript">
     
    245        sectionDisplayFieldset();
    256</script>
    26 [<div id="hyd_resultat">(#ENV*{message_ok})</div>]
  • _plugins_/hydraulic/trunk/formulaires/calcul_section.html

    r103348 r103586  
    1 [<div class='hyd_formulaire_erreur '><span>(#ENV*{message_erreur})</span></div>]
    2 <script language="javascript" type="text/javascript" src="#CHEMIN{js/hyd_fonctions.js}"></script>
    3 
    41<script>
    52        function gestion_radios_extra(nom,valeur) {
     
    1916</script>
    2017
    21 <form method="post" action="#ENV{action}#VAL{#hyd_resultat}" id="form_calcul_section">
    22         #ACTION_FORMULAIRE{#ENV{action}}
    23         <table class="hyd_formulaire">
    24                 <tbody>
     18<INCLURE{fond=formulaires/hydraulic,env}>
    2519
    26                         <!-- On génère les champs du formulaire en suivant le tableau saisies -->
    27                         <INCLURE{fond=hyd_inc/formulaire_champs,env}>
    28 
    29                         <tr>
    30                                 <td colspan="4" class="hyd_bouton_submit">
    31                                         <input type="submit" value="<:hydraulic:calculer:>">
    32                                 </td>
    33                         </tr>
    34 
    35                 </tbody>
    36         </table>
    37 </form>
    38 
    39 <script language="javascript">
     20<script>
    4021        // Affichage des champs du type de section sélectionné uniquement
    4122        sectionDisplayFieldset();
    4223</script>
    43 [<div id="hyd_resultat">(#ENV*{message_ok})</div>]
  • _plugins_/hydraulic/trunk/formulaires/cond_distri.html

    r103348 r103586  
    1 [<div class='hyd_formulaire_erreur '><span>(#ENV*{message_erreur})</span></div>]
    2 <script language="javascript" type="text/javascript" src="#CHEMIN{js/hyd_fonctions.js}"></script>
    3 
    4 <form method="post" action="#ENV{action}#VAL{#hyd_resultat}" id="form_cond_distri">
    5         #ACTION_FORMULAIRE{#ENV{action}}
    6         <table class="hyd_formulaire">
    7                 <tbody>
    8 
    9                         <!-- On génère les champs du formulaire en suivant le tableau saisies -->
    10                         <INCLURE{fond=hyd_inc/formulaire_champs,env}>
    11 
    12                         <tr>
    13                                 <td colspan="5" class="hyd_bouton_submit">
    14                                         <input type="submit" value="<:hydraulic:calculer:>">
    15                                 </td>
    16                         </tr>
    17 
    18                 </tbody>
    19         </table>
    20 </form>
    21 
    22 [<div id="hyd_resultat">(#ENV*{message_ok})</div>]
     1<INCLURE{fond=formulaires/hydraulic,env}>
  • _plugins_/hydraulic/trunk/formulaires/courbe_remous.html

    r103348 r103586  
    1 [<div class='hyd_formulaire_erreur '><span>(#ENV*{message_erreur})</span></div>]
     1<INCLURE{fond=formulaires/hydraulic,env}>
    22
    3 <script language="javascript" type="text/javascript" src="#CHEMIN{js/hyd_fonctions.js}"></script>
    43<script>
    5         //Permet d'afficher ou cacher les champs correspondant à une section.
    6         function afficher_cacher() {
    7                 var section = getSelectValue('choix_section_cr');
    8                 // On récupère tous le formulaire
    9                 var f = document.getElementById("form_courbe_remous");
    10                 if(f) {
    11                         // On récupère seulement les lignes <tr> du formulaire stocké dans f
    12                         var champs = f.getElementsByTagName("tr");
    13                         // On parcourt tous les <tr> du formulaire
    14                         for(var i=0, n=champs.length; i<n; i++) {
    15                                 // Si le champ appartient à la section choisis , alors on l'affiche.
    16                                 if((champs[i].getAttribute("id") != null) &&((champs[i].getAttribute("id")).substr(0,2) == section)){
    17                                         document.getElementById((champs[i].getAttribute("id"))).style.display='table-row';
    18                                 }
    19                                 // Sinon si il appartient aux autres sections, alors on le masque
    20                                 else if((champs[i].getAttribute("id") != null) &&((champs[i].getAttribute("id")).substr(0,1) == 'F')) {
    21                                         document.getElementById((champs[i].getAttribute("id"))).style.display='none';
    22                                 }
    23                         }
    24                 }
    25         }
     4        // Affichage des champs du type de section sélectionné uniquement
     5        sectionDisplayFieldset();
    266</script>
    27 <div class="formulaire_spip form_courbe_remous">
    28         <form method="post" action="#ENV{action}#VAL{#hyd_resultat}" id="form_courbe_remous">
    29                 #ACTION_FORMULAIRE{#ENV{action}}
    30                 <table class="hyd_formulaire">
    31                         <tbody>
    32                                 <tr id="type_section_field_cr">
    33                                         <td colspan="2"><div class="hyd_formulaire_chapitre"><:hydraulic:type_section:></div></td>
    34                                 </tr>
    35 
    36                                 <tr id="type_section_choix_cr">
    37                                         <td align="right">
    38                                                 <:hydraulic:choix_section:>
    39                                         </td>
    40 
    41                                         <!-- On génére les options du select, correspondant aux types de section -->
    42                                         <td>
    43                                                 <select name="crTypeSection" id="choix_section_cr" onChange="afficher_cacher();">
    44                                                         <BOUCLE_selectOptions(POUR){tableau #ENV{mes_saisies}}>
    45                                                                 #SET{test, #VALEUR|table_valeur{0}|decoupeIdSection}
    46                                                                 <BOUCLE_choixSection(CONDITION){si #CLE|substr{0,1}|== {'F'}}>
    47                                                                         <option value="#CLE" [(#ENV{crTypeSection}|=={#CLE}|?{'selected',''})]>#GET{test}</option>
    48                                                                 </BOUCLE_choixSection>
    49                                                         </BOUCLE_selectOptions>
    50                                                 </select>
    51 
    52                                                 [<div class='hyd_erreur'>(#ENV**{erreurs}|table_valeur{[(#VALEUR|table_valeur{0})]})</div>]
    53                                         </td>
    54 
    55                                 </tr>
    56 
    57                                 <BOUCLE_fieldChamps(POUR){tableau #ENV{mes_saisies}}>
    58 
    59                                         #SET{id_fieldset, #CLE}
    60 
    61                                         <!-- Fieldset des champs-->
    62                                         <tr id="#GET{id_fieldset}_field" style="display:[(#CLE|match{^([(#ENV{crTypeSection})]|c_bief|Cond_lim|Param_calc)$}|?{'table-row','none'})];">
    63                                                 <td colspan="2"><div class="hyd_formulaire_chapitre">[(#VALEUR|table_valeur{0}|traduction_hydraulic)]</div></td>
    64                                         </tr>
    65 
    66                                         <BOUCLE_champsLib(POUR){tableau (#VALEUR|table_valeur{1})}>
    67 
    68                                                 <!-- Tous les champs d'un seul fieldset -->
    69                                                 <tr id="#GET{id_fieldset}_[(#CLE)]" style="display:[(#GET{id_fieldset}|match{^([(#ENV{crTypeSection})]|c_bief|Cond_lim|Param_calc)$}|?{'table-row','none'})];" [(#ENV**{erreurs}|table_valeur{#GET{id_fieldset}_[(#CLE)]}|oui) class="hyd_erreur"]>
    70                                                         <td align="right" width="65%">
    71                                                                 [(#VALEUR|table_valeur{0}|traduction_hydraulic)]
    72                                                         </td>
    73 
    74                                                         <td width="35%" >
    75                                                                 [<span class='hyd_erreur'>(#ENV**{erreurs}|table_valeur{#GET{id_fieldset}_[(#CLE)]})</span>]
    76                                                                 <input type="text" value="[(#ENV{#GET{id_fieldset}_[(#CLE)]})]" maxlength="30" name="#GET{id_fieldset}_[(#CLE)]">
    77                                                         </td>
    78 
    79                                                 </tr>
    80 
    81                                         </BOUCLE_champsLib>
    82 
    83                                 </BOUCLE_fieldChamps>
    84                                 <tr>
    85                                         <td align="right">
    86                                                 <:hydraulic:choix_resolution:>
    87                                         </td>
    88 
    89                                         <!-- On génére les options du select, correspondant aux types de section -->
    90                                         <td>
    91                                                 [<div class='hyd_erreur'>(#ENV**{erreurs}|table_valeur{choix_resolution})</div>]
    92                                                 <select name="choix_resolution" id="choix_resolution">
    93                                                         <option value="Trapez" [(#ENV{choix_resolution}|=={Trapez}|?{'selected',''})]>
    94                                                                 <:hydraulic:integration_trapez:>
    95                                                         </option>
    96                                                         <option value="RK4" [(#ENV{choix_resolution}|=={RK4}|?{'selected',''})]>
    97                                                                 <:hydraulic:runge_kutta:>
    98                                                         </option>
    99                                                         <option value="Euler" [(#ENV{choix_resolution}|=={Euler}|?{'selected',''})]>
    100                                                                 <:hydraulic:euler_explicite:>
    101                                                         </option>
    102                                                 </select>
    103                                         </td>
    104                                 </tr>
    105 
    106                                 <tr>
    107                                         <td colspan="2" class="hyd_bouton_submit">
    108                                                 <input type="submit" value="<:hydraulic:calculer_remous:>">
    109                                         </td>
    110                                 </tr>
    111 
    112                         </tbody>
    113                 </table>
    114         </form>
    115 </div>
    116 [<div id="hyd_resultat">(#ENV*{message_ok})</div>]
  • _plugins_/hydraulic/trunk/formulaires/courbe_remous.php

    r103454 r103586  
    22/**
    33 *      @file formulaires/courbe_remous.php
    4  *      Fonctions du formulaire CVT pour les courbes de remous
     4 *      Formulaire CVT pour le calcul d'une courbe de remous
    55 */
    66
    7 /*      Copyright 2009-2012 Dorch <dorch@dorch.fr>, Médéric Dulondel
     7/*      Copyright 2017 David Dorchies
    88 *
    99 *      This program is free software; you can redistribute it and/or modify
     
    2424
    2525
    26 /* Tableau des champs à afficher dans le formulaire.
    27  * On travaille avec les libelles non traduits pour pouvoir gérer
    28  * le multilinguisme.
    29  */
    30 function mes_saisies() {
     26include_spip('hyd_inc/form_courbe_remous.class');
     27global $FCR; // Nécessaire car nous ne sommes pas dans l'environnement global
     28$FCR = new form_courbe_remous;
    3129
    32         // On récupère les champs communs à tous les formulaires à savoir les champs de section.
    33         include_spip('hyd_inc/section');
    34         $fieldset_champs = mes_saisies_section(true);
    35 
    36         $fieldset_champs['Cond_lim']    = array(
    37                 'condition_limite',
    38                 array(
    39                         'rQ'     =>array('debit_amont',2,'op'),
    40                         'rYaval' =>array('h_aval_imposee',0.4,'pn'),
    41                         'rYamont'=>array('h_amont_imposee',0.15,'pn')
    42                 )
    43         );
    44 
    45         $fieldset_champs['Param_calc']  = array(
    46                 'param_calcul',
    47                 array(
    48                         'rDx'    =>array('pas_discret',5,'op'),
    49                         'rPrec'  =>array('precision_calc',0.001,'op')
    50                 )
    51         );
    52         return $fieldset_champs;
     30function formulaires_courbe_remous_charger_dist() {
     31        global $FCR;
     32        return $FCR->charger();
    5333}
    5434
    5535
    56 // Définition des champs à lire dans le formulaire
    57 function getChamps() {
    58 
    59         $tSaisie = mes_saisies();
    60         $sTypeSection = _request('crTypeSection');
    61         $tData = array();
    62 
    63         foreach($tSaisie as $IdFS=>$FieldSet) {
    64                 // Si ce n'est pas une section ou la section définie...
    65                 if((substr($IdFS,0,1) != 'F') || ($IdFS == $sTypeSection)){
    66                         // ... alors on parcourt notre deuxième tableau en ajoutant les champs nécessaires.
    67                         foreach($FieldSet[1] as $Cle=>$Champ) {
    68                                 $tData[$IdFS.'_'.$Cle] = _request($IdFS.'_'.$Cle); // Valeur dans le formulaire
    69                                 $tCtrl[$IdFS.'_'.$Cle] = $Champ[2]; // Codes de vérification
    70                         }
    71                 }
    72         }
    73         return array($tData,$tCtrl);
     36function formulaires_courbe_remous_verifier_dist() {
     37        global $FCR;
     38        return $FCR->verifier();
    7439}
    7540
    7641
    77 function formulaires_courbe_remous_charger_dist() {
    78         // On charge les saisies et les champs qui nécessitent un accès par les fonctions
    79         $tSaisie_section = mes_saisies();
    80         $valeurs = array(
    81                 'crTypeSection' => 'FT',
    82                 'mes_saisies' => $tSaisie_section
    83         );
    84 
    85         // On charge tous les champs avec leur valeur
    86         foreach($tSaisie_section as $CleFD=>$FieldSet) {
    87                 foreach($FieldSet[1] as $Cle=>$Champ) {
    88                         $valeurs[$CleFD.'_'.$Cle] = $Champ[1];
    89                 }
    90         }
    91     $valeurs['choix_resolution'] = _request('choix_resolution');
    92 
    93         return $valeurs;
    94 }
    95 
    96 function formulaires_courbe_remous_verifier_dist() {
    97         $erreurs = array();
    98         list($tData,$tCtrl) = getChamps();
    99         include_spip('hyd_inc/formulaire');
    100         return hyd_formulaires_verifier($tData,$tCtrl);
    101 }
    102 
    103 function formulaires_courbe_remous_traiter_dist() {
    104         global $spip_lang;
    105         include_spip('hyd_inc/section.class');
    106         include_spip('hyd_inc/cache');
    107         include_spip('hyd_inc/log.class');
    108         include_spip('hyd_inc/courbe_remous');
    109         include_spip('hyd_inc/graph.class');
    110 
    111         $datas = array();
    112         $echo = '';
    113         $tSaisie = mes_saisies();
    114         $tChUtil = array();
    115         $crTypeSection = _request('crTypeSection');
    116 
    117         // On récupère tous les champs utiles, à savoir les champs fixes, et les champs appartenant à la section choisie
    118         foreach($tSaisie as $IdFS=>$FieldSet) {
    119                 if((substr($IdFS,0,1) != 'F') || ($IdFS == $crTypeSection)){
    120                         foreach($FieldSet[1] as $Cle=>$Champ) {
    121                                 $tChUtil[] = $IdFS.'_'.$Cle;
    122                         }
    123                 }
    124         }
    125 
    126         //On récupère tous les champs utiles dans le tableau datas
    127         foreach($tChUtil as $champ) {
    128                 if (_request($champ)){
    129                         $datas[$champ] = _request($champ);
    130                 }
    131 
    132                 $datas[$champ] = str_replace(',','.',$datas[$champ]); // Bug #574
    133         }
    134 
    135         // On ajoute la langue en cours pour différencier le fichier de cache par langue
    136         $datas['sLang'] = $spip_lang;
    137 
    138         // Nom du fichier en cache pour calcul déjà fait
    139         $CacheFileName=md5(serialize($datas));
    140 
    141         // Initialisation de la classe chargée d'afficher le journal de calcul
    142         $oLog = new cLog();
    143 
    144         //Transformation des variables contenues dans $datas
    145         foreach($datas as $champ=>$data) {
    146                 ${$champ}=$data;
    147         }
    148 
    149         // Contrôle du nombre de pas d'espace maximum
    150         $iPasMax = 1000;
    151         if($c_bief_rLong / $Param_calc_rDx > $iPasMax) {
    152                 $Param_calc_rDx = $c_bief_rLong / $iPasMax;
    153                 $oLog->Add(_T('hydraulic:pas_nombre').' > '.$iPasMax.' => '._T('hydraulic:pas_ajustement').$Param_calc_rDx.' m');
    154         }
    155         //spip_log(array($Cond_lim_rYaval,$c_bief_rKs,$Cond_lim_rQ,$c_bief_rLong,$c_bief_rIf,$Param_calc_rDx,$Param_calc_rPrec),'hydraulic');
    156 
    157         // Enregistrement des paramètres dans les classes qui vont bien
    158         $oParam= new cParam($c_bief_rKs,$Cond_lim_rQ,$c_bief_rIf,$Param_calc_rPrec,$c_bief_rYB);
    159 
    160         // Création d'un objet de type Section selon la section choisie.
    161         switch($crTypeSection) {
    162                 case 'FT':
    163                 include_spip('hyd_inc/sectionTrapez.class');
    164                 $oSection=new cSnTrapez($oLog,$oParam,$FT_rLargeurFond,$FT_rFruit);
    165                 break;
    166 
    167                 case 'FR':
    168                 include_spip('hyd_inc/sectionRectang.class');
    169                 $oSection=new cSnRectang($oLog,$oParam,$FR_rLargeurFond);
    170                 break;
    171 
    172                 case 'FC':
    173                 include_spip('hyd_inc/sectionCirc.class');
    174                 $oSection=new cSnCirc($oLog,$oParam,$FC_rD);
    175                 break;
    176 
    177                 case 'FP':
    178                 include_spip('hyd_inc/sectionPuiss.class');
    179                 $oSection=new cSnPuiss($oLog,$oParam,$FP_rCoef,$FP_rLargeurBerge);
    180                 break;
    181 
    182                 default:
    183                 include_spip('hyd_inc/sectionTrapez.class');
    184                 $oSection=new cSnTrapeze($oLog,$oParam,$FT_rLargeurFond,$FT_rFruit);
    185         }
    186 
    187         /***************************************************************************
    188         *                        Calcul de la ligne d'eau
    189         ****************************************************************************/
    190         $bNoCache = true; // false pour activer le cache !!!! BUG : Il manque la méthode résolution comme clé de différenciation de $CacheFileName !!!!
    191         if(!$bNoCache && is_file(HYD_CACHE_DIRECTORY.$CacheFileName)) {
    192                 // On récupère toutes les données dans un cache déjà créé
    193                 list($aC,$sLog,$oSection->rHautCritique,$oSection->rHautNormale) = ReadCacheFile($CacheFileName);
    194         }
    195         else {
    196                 // On calcule les données pour créer un cache et afficher le résultat
    197                 $oLog->Add(_T('hydraulic:largeur_berge').' = '.format_nombre($oSection->rLargeurBerge,$oParam->iPrec).' m');
    198                 $oLog->Add(_T('hydraulic:h_critique').' = '.format_nombre($oSection->CalcGeo('Yc'),$oParam->iPrec).' m');
    199                 $oLog->Add(_T('hydraulic:h_normale').' = '.format_nombre($oSection->CalcGeo('Yn'),$oParam->iPrec).' m');
    200 
    201                 // Calcul des courbes de remous
    202                 $aC = array(); // deux items (Flu et Tor) composé d'un vecteur avec key=X et value=Y
    203 
    204                 // Calcul depuis l'aval
    205                 if($oSection->rHautCritique <= $Cond_lim_rYaval) {
    206                         $oLog->Add(_T('hydraulic:calcul_fluvial'));
    207                         $oCRF = new cCourbeRemous($oLog, $oParam, $oSection, $Param_calc_rDx);
    208                         $aC['Flu'] = $oCRF->calcul($Cond_lim_rYaval, $c_bief_rLong, _request('choix_resolution'));
    209                 }
    210                 else {
    211                         $oLog->Add(_T('hydraulic:pas_calcul_depuis_aval'));
    212                 }
    213 
    214                 // Calcul depuis l'amont
    215                 if($oSection->rHautCritique >= $Cond_lim_rYamont) {
    216                         $oLog->Add(_T('hydraulic:calcul_torrentiel'));
    217                         $oCRT = new cCourbeRemous($oLog, $oParam, $oSection, -$Param_calc_rDx);
    218                         $aC['Tor'] = $oCRT->calcul($Cond_lim_rYamont, $c_bief_rLong, _request('choix_resolution'));
    219                 }
    220                 else {
    221                         $oLog->Add(_T('hydraulic:pas_calcul_depuis_amont'));
    222                 }
    223                 spip_log($oParam,'hydraulic',_LOG_DEBUG);
    224                 spip_log($aC,'hydraulic',_LOG_DEBUG);
    225 
    226                 // Détection du ressaut hydraulique
    227                 $bDetectRessaut = true;
    228                 if($bDetectRessaut && isset($aC['Flu']) && isset($aC['Tor'])) {
    229                         if(count($aC['Flu']) > count($aC['Tor']) || (count($aC['Flu']) == count($aC['Tor']) && $oSection->Calc('Imp', end($aC['Flu'])) > $oSection->Calc('Imp', end($aC['Tor'])))) {
    230                                 // La courbe fluviale va jusqu'au bout
    231                                 $sCC = 'Flu';
    232                                 $sCN = 'Tor';
    233                                 $iSens = 1; // On cherche l'aval du ressaut
    234                                 $sSens = _T('hydraulic:amont');
    235                         } else {
    236                                 // La courbe torrentielle va jusqu'au bout
    237                                 $sCC = 'Tor';
    238                                 $sCN = 'Flu';
    239                                 $iSens = -1; // On cherche l'amont du ressaut
    240                                 $sSens = _T('hydraulic:aval');
    241                         }
    242                         $trX = array_reverse(array_keys($aC[$sCN])); // Parcours des sections de la ligne d'eau la plus courte
    243                         $bRessaut = false;
    244                         foreach($trX as $rX) {
    245                                 // Calcul de l'abscisse de la section dans l'autre régime
    246                                 $Yco = $oSection->Calc('Yco', $aC[$sCN][$rX]); // Y conjugué
    247                                 $rLongRst = 5 * abs($aC[$sCN][$rX] - $Yco); // Longueur du ressaut
    248                                 $xRst = $rX + round($iSens * $rLongRst / $Param_calc_rDx) * $Param_calc_rDx; // Abscisse où comparer Yconj et Y
    249                                 $xRst = sprintf('%1.'.round($oParam->iPrec).'f',$xRst);
    250                                 //spip_log("\nrX=$rX xRst=$xRst Yco=$Yco",'hydraulic',_LOG_DEBUG);
    251                                 if(isset($aC[$sCC][$xRst])) {
    252                                         // Hauteur décalée de la longueur du ressaut (il faut gérer la pente du fond)
    253                                         $Ydec = $aC[$sCC][$xRst] + $rLongRst * $oParam->rIf * $iSens;
    254                                         spip_log("\nrX=$rX xRst=$xRst Yco=$Yco Ydec=$Ydec",'hydraulic',_LOG_DEBUG);
    255                                         if(($Yco - $Ydec) > 0) {
    256                                                 $oLog->Add(_T('hydraulic:ressaut_hydrau', array('Xmin'=>min($rX,$xRst), 'Xmax'=>max($rX,$xRst))));
    257                                                 spip_log("rX=$rX xRst=$xRst",'hydraulic',_LOG_DEBUG);
    258                                                 // Modification de la ligne d'eau CC
    259                                                 foreach(array_keys($aC[$sCN]) as $rXCC) {
    260                                                         if($iSens * ($rXCC - $rX) < 0) {
    261                                                                 unset($aC[$sCC][$rXCC]);
    262                                                         } elseif($rXCC == $rX) {
    263                                                                 $aC[$sCC][$rXCC] = $aC[$sCN][$rXCC];
    264                                                                 break;
    265                                                         }
    266                                                 }
    267                                                 // Modification de la ligne d'eau CN
    268                                                 foreach($trX as $rXCN) {
    269                                                         if($iSens * ($rXCN - $xRst) > 0) {
    270                                                                 unset($aC[$sCN][$rXCN]);
    271                                                         } elseif($rXCN == $xRst) {
    272                                                                 $aC[$sCN][$rXCN] = $aC[$sCC][$rXCN];
    273                                                                 break;
    274                                                         }
    275                                                 }
    276                                                 $bRessaut = true;
    277                                                 break;
    278                                         }
    279                                 }
    280                         }
    281                         if(!$bRessaut) {
    282                                 // Le ressaut est en dehors du canal
    283                                 $oLog->Add(_T('hydraulic:ressaut_dehors', array('Sens' => $sSens, 'X' => end($trX))));
    284                                 $aC[$sCN] = array();
    285                         }
    286                 }
    287 
    288                 //Production du journal de calcul
    289                 $sLog = $oLog->Result();
    290                 //Enregistrement des données dans fichier cache
    291                 WriteCacheFile($CacheFileName,array($aC,$sLog,$oSection->rHautCritique,$oSection->rHautNormale));
    292         }
    293         //Construction d'un tableau des indices x combinant les abscisses des 2 lignes d'eau
    294         $trX = array();
    295         if(isset($aC['Flu'])) $trX = array_merge($trX, array_keys($aC['Flu']));
    296         if(isset($aC['Tor'])) $trX = array_merge($trX, array_keys($aC['Tor']));
    297         $trX = array_unique($trX, SORT_NUMERIC);
    298         sort($trX, SORT_NUMERIC);
    299         //~ spip_log($tr,'hydraulic'); // Debug
    300 
    301 
    302         /***************************************************************************
    303         *                        Affichage du graphique
    304         ****************************************************************************/
    305         $oGraph = new cGraph();
    306         // Cote des berges
    307         $oGraph->AddSerie(
    308                 'berge',
    309                 $trX,
    310                 $oParam->rYB,  // La cote des berges sera calculée à partir de la pente fournie dans GetGraph
    311                 '#C58f50',
    312                 'lineWidth:1'
    313         );
    314         // Cote du fond
    315         $oGraph->AddSerie(
    316                 'fond',
    317                 $trX,
    318                 0,  // La cote du fond sera calculée à partir de la pente fournie dans GetGraph
    319                 '#753f00',
    320                 'lineWidth:1, fill:true'
    321         );
    322         // Ligne d'eau fluviale
    323         if(isset($aC['Flu'])) {
    324                 $oGraph->AddSerie(
    325                         'ligne_eau_fluviale',
    326                         array_keys($aC['Flu']),
    327                         array_values($aC['Flu']),
    328                         '#0093bd',
    329                         'lineWidth:3, showMarker:true, markerOptions:{style:\'filledCircle\', size:8}'
    330                 );
    331         }
    332         // Ligne d'eau torrentielle
    333         if(isset($aC['Tor'])) {
    334                 $oGraph->AddSerie(
    335                         'ligne_eau_torrentielle',
    336                         array_keys($aC['Tor']),
    337                         array_values($aC['Tor']),
    338                         '#77a3cd',
    339                         'lineWidth:3, showMarker:true, markerOptions:{style:\'filledCircle\', size:8}'
    340                 );
    341         }
    342         // Hauteur critique
    343         if(is_numeric($oSection->rHautCritique)) {
    344                 $oGraph->AddSerie(
    345                         'h_critique',
    346                         $trX,
    347                         $oSection->rHautCritique,  // La cote du fond sera calculée à partir de la pente fournie dans GetGraph
    348                         '#ff0000',
    349                         'lineWidth:2'
    350                 );
    351         }
    352         // Hauteur normale
    353         if(is_numeric($oSection->rHautNormale)) {
    354                 $oGraph->AddSerie(
    355                         'h_normale',
    356                         $trX,
    357                         $oSection->rHautNormale,  // La cote du fond sera calculée à partir de la pente fournie dans GetGraph
    358                         '#a4c537',
    359                         'lineWidth:2'
    360                 );
    361         }
    362 
    363         // Décalage des données par rapport au fond
    364         $oGraph->Decal(0, $c_bief_rIf, $c_bief_rLong);
    365 
    366         // Récupération du graphique
    367         $echo .= $oGraph->GetGraph('graphique',400,600);
    368 
    369 
    370         $echo .= $sLog;
    371 
    372         /***************************************************************************
    373         *                   Affichage du tableau de données
    374         ****************************************************************************/
    375         $echo.='<table class="spip">
    376                 <thead>
    377                         <tr class="row_first">
    378                                 <th scope="col" colspan="1" rowspan="2">'._T('hydraulic:abscisse').' (m)</th>
    379                                 <th scope="col" colspan="2" rowspan="1">'._T('hydraulic:ligne_eau_fluviale').'</th>
    380                                 <th scope="col" colspan="2" rowspan="1">'._T('hydraulic:ligne_eau_torrentielle').'</th>
    381                         </tr>
    382                         <tr class="row_first">
    383                                 <th scope="col">'._T('hydraulic:tirant_eau').'</th>
    384                                 <th scope="col">Froude</th>
    385                                 <th scope="col">'._T('hydraulic:tirant_eau').'</th>
    386                                 <th scope="col">Froude</th>
    387                         </tr>
    388                 </thead>
    389                 <tbody>';
    390                         $i=0;
    391                         foreach($trX as $rX) {
    392                                 $i+=1;
    393                                 $echo.='<tr class="align_right ';
    394                                         $echo.=($i%2==0)?'row_even':'row_odd';
    395                                         $echo.='"><td>'.format_nombre($rX,$oParam->iPrec).'</td>';
    396                                         if(isset($aC['Flu'][$rX])) {
    397                                                 // On formalise les résultats, avec le nombre de chiffres aprés la virgule adéquat
    398                                                 $echo .= '<td>'.format_nombre($aC['Flu'][$rX],$oParam->iPrec).'</td>';
    399                                                 $echo .= '<td>'.format_nombre($oSection->Calc('Fr', $aC['Flu'][$rX]),$oParam->iPrec).'</td>';
    400                                         }
    401                                         else {
    402                                                 $echo .= '<td></td><td></td>';
    403                                         }
    404                                         if(isset($aC['Tor'][$rX])) {
    405                                                 $echo .= '<td>'.format_nombre($aC['Tor'][$rX],$oParam->iPrec).'</td>';
    406                                                 $echo .= '<td>'.format_nombre($oSection->Calc('Fr', $aC['Tor'][$rX]),$oParam->iPrec).'</td>';
    407                                         }
    408                                         else {
    409                                                 $echo .= '<td></td><td></td>';
    410                                         }
    411                                 $echo .= '</tr>';
    412                         }
    413                 $echo.='</tbody>
    414         </table>';
    415 
    416         $res['message_ok'] = $echo;
    417 
    418         return $res;
     42function formulaires_courbe_remous_traiter_dist(){
     43        global $FCR;
     44        return $FCR->traiter();
    41945}
    42046?>
  • _plugins_/hydraulic/trunk/formulaires/lechapt_calmon.html

    r103348 r103586  
    1 [<div class='hyd_formulaire_erreur '><span>(#ENV*{message_erreur})</span></div>]
    2 <script language="javascript" type="text/javascript" src="#CHEMIN{js/hyd_fonctions.js}"></script>
    3 
    4 <form method="post" action="#ENV{action}#VAL{#hyd_resultat}" id="form_lechapt_calmon">
    5         #ACTION_FORMULAIRE{#ENV{action}}
    6         <table class="hyd_formulaire">
    7                 <tbody>
    8 
    9                         <!-- On génère les champs du formulaire en suivant le tableau saisies -->
    10                         <INCLURE{fond=hyd_inc/formulaire_champs,env}>
    11 
    12                         <tr>
    13                                 <td colspan="5" class="hyd_bouton_submit">
    14                                         <input type="submit" value="<:hydraulic:calculer_lechapt_calmon:>">
    15                                 </td>
    16                         </tr>
    17 
    18                 </tbody>
    19         </table>
    20 </form>
    21 
    22 [<div id="hyd_resultat">(#ENV*{message_ok})</div>]
     1<INCLURE{fond=formulaires/hydraulic,env}>
  • _plugins_/hydraulic/trunk/hyd_inc/form_calcul_section.class.php

    r103504 r103586  
    44class form_calcul_section extends form_section {
    55
    6         // Définition de la variable à calculer par défaut
    7         protected $sVarCal = '';
    8 
    96        // Définition du nombre de colonnes du formulaire
    107        protected $nb_col = 4;
    11 
    12         // Définition des variables calculables et de leur code de langue
    13         public $champs_select_calc = array(
    14                 'Hs'   => 'charge_spe',
    15                 'Hsc'  => 'charge_critique',
    16                 'B'    => 'larg_miroir',
    17                 'P'    => 'perim_mouille',
    18                 'S'    => 'surf_mouille',
    19                 'R'    => 'rayon_hyd',
    20                 'V'    => 'vit_moy',
    21                 'Fr'   => 'froud',
    22                 'Yc'   => 'tirant_eau_crit',
    23                 'Yn'   => 'tirant_eau_norm',
    24                 'Yf'   => 'tirant_eau_fluv',
    25                 'Yt'   => 'tirant_eau_torr',
    26                 'Yco'  => 'tirant_eau_conj',
    27                 'J'    => 'perte_charge',
    28                 'I-J'  => 'var_lin',
    29                 'Imp'  => 'impulsion',
    30                 'Tau0' => 'force_tract'
    31         );
    328
    339        function __construct() {
     
    5733        }
    5834
    59 
    60         public function charger() {
    61                 $valeurs = parent::charger();
     35        /***************************************************************************
     36         * Méthode à appeler par la procédure charger du formulaire CVT
     37         * @param bFix true = Formulaire sans choix fvc
     38         ***************************************************************************/
     39        public function charger($bFix = false) {
     40                $valeurs = parent::charger($bFix);
    6241                $valeurs = array_merge($valeurs,
    6342                        array(
     
    8968                }
    9069                else {
    91                         //~ switch($choix_section) {
    92                                 //~ case 'FR':
    93                                 $tVarCal = array('Hs', 'Hsc', 'B', 'P', 'S', 'R', 'V', 'Fr', 'Yc', 'Yn', 'Yf', 'Yt', 'Yco', 'J', 'I-J', 'Imp', 'Tau0');
    94                                 //~ break;
    95                                 //~ default:
    96                                 //~ // Le calcul de la hauteur conjuguée n'est pas OK pour les sections autres que rectangulaire
    97                                 //~ $tVarCal = array('Hs', 'Hsc', 'B', 'P', 'S', 'R', 'V', 'Fr', 'Yc', 'Yn', 'Yf', 'Yt', 'J', 'I-J', 'Imp', 'Tau0');
    98                         //~ }
     70                        $tVarCal = array('Hs', 'Hsc', 'B', 'P', 'S', 'R', 'V', 'Fr', 'Yc', 'Yn', 'Yf', 'Yt', 'Yco', 'J', 'I-J', 'Imp', 'Tau0');
    9971                }
    10072
    10173                $tRes = array(); // Tableau des résultats (ordonnées)
    10274                $tAbs = array(); // Tableau des abscisses
    103                 if(self::DBG) spip_log($this->oSn,'hydraulic',_LOG_DEBUG);
    10475                if(self::DBG) spip_log($tVarCal,'hydraulic',_LOG_DEBUG);
    10576                if(self::DBG) spip_log("min=$min max=$max pas=$pas",'hydraulic',_LOG_DEBUG);
  • _plugins_/hydraulic/trunk/hyd_inc/form_calcul_section_valacal.html

    r96562 r103586  
    11[(#REM) Liste déroulante de choix de la variable à calculer pour le formulaire de calcul sur les sections paramétrées]
    2 
    32<td colspan="3">
    43        <select name="val_a_cal" id="val_a_cal">
  • _plugins_/hydraulic/trunk/hyd_inc/form_section.abstract.class.php

    r96562 r103586  
    2929        protected $oP; ///< Objet paramètres de section
    3030
     31        /**
     32         * Définition des variables calculables et de leur code de langue
     33         */
     34        public $champs_select_calc = array(
     35                'Hs'   => 'charge_spe',
     36                'Hsc'  => 'charge_critique',
     37                'B'    => 'larg_miroir',
     38                'P'    => 'perim_mouille',
     39                'S'    => 'surf_mouille',
     40                'R'    => 'rayon_hyd',
     41                'V'    => 'vit_moy',
     42                'Fr'   => 'froud',
     43                'Yc'   => 'tirant_eau_crit',
     44                'Yn'   => 'tirant_eau_norm',
     45                'Yf'   => 'tirant_eau_fluv',
     46                'Yt'   => 'tirant_eau_torr',
     47                'Yco'  => 'tirant_eau_conj',
     48                'J'    => 'perte_charge',
     49                'I-J'  => 'var_lin',
     50                'Imp'  => 'impulsion',
     51                'Tau0' => 'force_tract'
     52        );
     53
     54
    3155        /*
    3256        * Caractéristiques communes aux calculs sur les sections :
     
    184208                        $this->oSn=new cSnTrapez($this->oLog,$this->oP,$rLargeurFond,$rFruit);
    185209                }
    186                 $this->oSn->rY = $rY;
     210                if(isset($rY)) {
     211                        $this->oSn->rY = $rY;
     212                }
     213                spip_log($this->oSn,'hydraulic',_LOG_DEBUG);
     214                if(self::DBG) spip_log($this->oP,'hydraulic',_LOG_DEBUG);
    187215        }
    188216}
  • _plugins_/hydraulic/trunk/hyd_inc/formulaire.abstract.class.php

    r103504 r103586  
    88abstract class formulaire {
    99
    10         const DBG = true; /// Debuggage de la classe et des classes filles
     10        const DBG = false; /// Debuggage de la classe et des classes filles
     11        const DBG_CHARGER = false; /// Debuggage de la methode charger
    1112
    1213        /***************************************************************************
     
    4546        /// Nombre de pas de variation par défaut
    4647        protected $nbPas = 15;
     48        protected $bFVC = true; ///< Formulaire FVC (boutons fixe, varie, calcul)
    4749
    4850        /***************************************************************************
     
    138140         * pour ajouter des variables supplémentaires dans l'environnement du
    139141         * formulaire.
     142         * @param bFix true = Formulaire sans choix fvc
    140143         ***************************************************************************/
    141144        public function charger() {
     
    148151                foreach($this->saisies as $fs) {
    149152                        foreach($fs[1] as $cle=>$val) {
    150                                 $valeurs[$cle] = $val[1];
     153                                $request = _request($cle);
     154                                if(self::DBG_CHARGER) spip_log("cle=$cle request=$request",'hydraulic',_LOG_DEBUG);
     155                                if($request != '') {
     156                                        // La valeur du champ est dans l'adresse de la page
     157                                        $valeurs[$cle] = $request;
     158                                } else {
     159                                        // Valeur par défaut
     160                                        $valeurs[$cle] = $val[1];
     161                                }
    151162                        }
    152163                }
    153164
    154165                // On parcourt tous le tableau des indices, et on initialise les valeurs des boutons radios, et des champs de variation
    155                 $sVarCal = $this->sVarCal;
    156                 foreach($this->champs_fvc as $cle){
    157                         $valeurs['choix_champs_'.$cle] = 'fix';
    158                         $valeurs['val_min_'.$cle] = $valeurs[$cle]/2;
    159                         $valeurs['val_max_'.$cle] = $valeurs[$cle]*2;
    160                         $valeurs['pas_var_'.$cle] = 1.5*$valeurs[$cle]/$this->nbPas;
    161                         if(_request('choix_champs_'.$cle)=='cal') {
    162                                 $sVarCal = $cle;
    163                         }
    164                 }
    165                 $valeurs['choix_champs_'.$sVarCal] = 'cal';
     166                if($this->bFVC) {
     167                        $sVarCal = $this->sVarCal;
     168                        foreach($this->champs_fvc as $cle){
     169                                $valeurs['choix_champs_'.$cle] = 'fix';
     170                                $valeurs['val_min_'.$cle] = $valeurs[$cle]/2;
     171                                $valeurs['val_max_'.$cle] = $valeurs[$cle]*2;
     172                                $valeurs['pas_var_'.$cle] = 1.5*$valeurs[$cle]/$this->nbPas;
     173                                if(_request('choix_champs_'.$cle)=='cal') {
     174                                        $sVarCal = $cle;
     175                                }
     176                        }
     177                        $valeurs['choix_champs_'.$sVarCal] = 'cal';
     178                }
    166179
    167180                return $valeurs;
     
    285298                        $erreurs['message_erreur'] = _T('hydraulic:saisie_erreur');
    286299                }
    287 
     300                if(self::DBG) spip_log($erreurs,'hydraulic',_LOG_DEBUG);
    288301                return $erreurs;
    289302        }
     
    294307         ***************************************************************************/
    295308        public function traiter() {
     309                spip_log('toto','hydraulic',_LOG_DEBUG);
    296310                include_spip('hyd_inc/cache');
    297 
     311                if(self::DBG) spip_log('toto','hydraulic',_LOG_DEBUG);
    298312                // Calcul des résultats
    299313                $CacheFileName = md5(serialize($this->data)); // Nom du fichier en cache pour calcul déjà fait
     
    388402
    389403                        // Affichage du graphique
    390                         include_spip('hyd_inc/graph.class');
    391                         $oGraph = new cGraph('',$tLib[$data['ValVar']],'');
    392                         if(isset($tRes)) {
    393                                 $oGraph->AddSerie(
    394                                         _T('hydraulic:param_'.$data['ValCal']),
    395                                         $tAbs,
    396                                         $tRes,
    397                                         '#00a3cd',
    398                                         'lineWidth:3, showMarker:true, markerOptions:{style:\'filledCircle\', size:8}');
    399                         }
    400                         // Récupération du graphique
    401                         $graph = $oGraph->GetGraph('graphique',400,600);
    402                         $echo .= $graph."\n";
     404
     405                        $echo .= $this->getGraph($tLib[$data['ValVar']], $tLib[$data['ValCal']], $tAbs, $tRes);
    403406                }
    404407                $echo .= '<div class="hyd_table">'.$tableau_fixe.'</div>';
     
    407410                }
    408411                return $echo;
     412        }
     413
     414
     415        /**
     416         * Affichage du graphique de la variable calculée
     417         * @param $sLibVar Libellé de la variable variée
     418         * @param $sLibCal Libellé de la variable calculée
     419         * @param $tAbs Vecteur des abscisses
     420         * @param $tRes Vecteur des valeurs calculées
     421         */
     422        protected function getGraph($sLibVar, $LibCal, $tAbs, $tRes) {
     423                include_spip('hyd_inc/graph.class');
     424                $oGraph = new cGraph('',$sLibVar,'');
     425                if(isset($tRes)) {
     426                        $oGraph->AddSerie(
     427                                $LibCal,
     428                                $tAbs,
     429                                $tRes,
     430                                '#00a3cd',
     431                                'lineWidth:3, showMarker:true, markerOptions:{style:\'filledCircle\', size:8}');
     432                }
     433                // Récupération du graphique
     434                return $oGraph->GetGraph('graphique',400,600)."\n";
    409435        }
    410436
  • _plugins_/hydraulic/trunk/hyd_inc/graph.class.php

    r103274 r103586  
    148148         * @param $iHeight Hauteur du graphique en pixels
    149149         * @param $iWidth Largeur du graphique en pixels
    150          * @param $rDecal Offset pour décaler l'affichage des ordonnées
    151          * @param $rPente Pente pour décaler l'affichage des ordonnées
    152          * @param $rXFin Si différent de zéro, abscisse à partir de laquelle calculer la pente
    153150         */
    154151        function GetGraph($sId, $iHeight, $iWidth) {
     152                spip_log($this->tSeries,'hydraulic',_LOG_DEBUG);
    155153                $sId = 'jqplot_'.$sId;
    156154                $this->echo = sprintf('
  • _plugins_/hydraulic/trunk/hydraulic.css.html

    r96562 r103586  
    5555.hyd_formulaire input {
    5656        width: 10em;
     57        text-align: right;
    5758}
    5859
     
    9495}
    9596
    96 #jqplot_graphique {
     97#jqplot_graphique, #jqplot_courbe_remous {
    9798        margin: 2em auto;
    9899}
  • _plugins_/hydraulic/trunk/lang/hydraulic_en.php

    r103452 r103586  
    77        'amont'                         => "upstream",
    88        'arret_calcul'      => "Calculation stopped: Critical elevation reached at abscissa",
     9        'aucune'                        => "None",
    910        'aval'                          => "downstream",
    1011        // B
  • _plugins_/hydraulic/trunk/lang/hydraulic_fr.php

    r103452 r103586  
    77        'amont'                         => "amont",
    88        'arret_calcul'      => "Arrêt du calcul : Hauteur critique atteinte à l'abscisse",
     9        'aucune'                        => "Aucune",
    910        'aval'                          => "aval",
    1011        // B
  • _plugins_/hydraulic/trunk/plugin.xml

    r103504 r103586  
    88        <auteur>David Dorchies, Médéric Dulondel</auteur>
    99        <licence>GNU/GLP</licence>
    10         <version>0.10.2</version>
     10        <version>0.11.0</version>
    1111        <necessite id="lib:dist" src="http://www.jqplot.com/download/jquery.jqplot.1.0.8r1250.zip" />
    1212        <slogan>
     
    4242        <icon>logo32.png</icon>
    4343        <categorie>divers</categorie>
    44         <lien>http://sic.g-eau.net/spip.php?rubrique80</lien>
     44        <lien>http://hydraulique.g-eau.net/Le-plugin-SPIP-Calculette-hydraulique</lien>
    4545        <necessite id="SPIP" version="[2.1.0;3.1.99]" />
    4646        <necessite id="spip_bonux" version="[2.2.22;]" />
Note: See TracChangeset for help on using the changeset viewer.