DECLARA.PAS

UNIT DECLARA;

INTERFACE

CONST  {valeurs}

 YCritRelDuree = 0.025;     {critŠre relatif de convergence pour l'‚galisation des temps de remplissage}
 YCritAbsDuree = 0.25;      {critŠre absolu de convergence pour l'‚galisation des temps de remplissage}
 YEcartMax     : double=0; {max d'‚cart absolu obtenu entre d‚bit aval et d‚bit aval objectif atteignable}
 YDelaiMax     = 4;        {indice sup‚rieur du tableau des d‚bits lus}
 YDelaiMin     = -8;       {indice inf‚reur du tableau des d‚bits lus}
 YdT           = 86400;
 YInterpolPermi= true;     {pour autoriser reconst des lacunes isol‚es de d‚bits stations}
 YLacune       = -99;      {code lacune de d‚bit}
 YNbfreq       = 8;
 YNbmaxAn      = 250;      {nombre maximal d'ann‚es pouvant ˆtre trait‚es dans le calcul … rebours}
 YNbmaxIter    = 400;      {nombre max d'it‚rations pour obtenir la norme de d‚bit stock‚ … r‚partir}
 YNbmaxIterVol = 100;      {nombre max d'it‚rations pour obtention des bons volumes conditionnant la r‚partition}
 YNbmaxIterVolInit = 50;   {Nombre max d'it‚rations pour obtenir le bon jeu de volumes initiaux}
 YNbIterTpsMax = 150;       {nombre max d'it‚rations pour ‚galisation des temps de remplissage}
 YNmaxLacs     = 4;        {nombre maximal de lacs autoris‚}
 YNbmaxPivot   = 10;       {nombre maximal de dates pivot autoris‚}
 YNbmaxSeuil   = 5;        {nombre max de seuil dans formule}
 YNmaxBareme   = 10;       {taille maximale de barŠme de QEmin, QEmax, Qsmi et Qsmax en fonction du volume}
 YNmaxStat     = 30;
 YNbmaxTpsRet  = 12;
 YNbmaxVersion = 25;       {nombre max de versions de paramŠtres barrages et r‚seaux}
 YRelax        = 0.9;      {r‚glage entre 0 et 1 pour la convergence d'‚galisation des temps de remplissage}
 YSeuilConv    = 1e-10;    {seuil de convergence}
 YSeuilRconv   = 1e-12;    {seuil relatif de convergence dans le calcul … rebours, sur volume lac}
 YTouComNul    : double = 1e-10;
 YTpotMaxiAdmis= 3653;     {limite max de dur‚e Tpot de reconstitution de volume utilisable maximal}

CONST {chaines de caractŠres}

 YExIsofreq    = '.dat';
 YNomFicCalcTri= 'OUITRI.txt';  {nom du fichier dont l'existence d‚clenche le calcul de tri de QXdef}
 YNomFicChoix  = 'CHOIX.txt';   {nom du fichier des options de calcul}
 YNomFicDeb    = 'Debit';
 YNomFicDebTemp= 'DebitTmp';
 YNomFicFin    = 'FIN.txt';     {nom du fichhier d‚truit au d‚but du programme puis cr‚‚ et ferm‚ … la fin}
 YNomFicFNonDep= 'FreqNDep.txt'; {nom du fichier contenant la fr‚quence au non d‚passement souhait‚e pour l'utilisation des QMN dans la m‚thode 5}
 YNomFicMode   = 'MODE.txt';    {nom du fichier du code 0 ou 1 d‚terminant les entr‚es par saisie clavier ou lecture fichier}
 YNomFicPuiss  = 'PUISS.txt';   {nom du fichier contenant la puissance … appliquer … QXdef}
 YNomFicQuant  = 'QMNquant';    {nom du fichier d'‚dition des 365 valeurs de d‚bit de cours d'eaub … la prise pour un quantile donn‚}
 YNomFicQST    = 'Qst-';        {base du nom des fichiers typ‚s de d‚bit stock‚}
 YNomFicRangCal= 'compteur';
 YnomFicReglage= 'REGLAGE.txt'; {nom du fichier des r‚glages pour r‚partition des taches'}
 YNomFicResChr1= 'Chrono.txt';  {nom de fichier des r‚sultats d‚taill‚s obtenus en sens chronologique --> calcul de Vges}
 YNomFicResChr2= 'PaChrono.txt';{nom de fichier des r‚sultats d‚taill‚s obtenus en sens chronologique inverse --> calcul de Vobj}
 YNomFicResDef = 'QXdef';
 YNomFicResult1= 'Qobs-P-R.txt';{nom de fichiers de r‚sultats : chronique des d‚bits observ‚s}
 YNomFicResult2= 'QSynchro.txt';{nom fichier de d‚bits synchronis‚s (prise en compte des d‚lais de propagation)}
 YNomFicResult4= 'Volumes.txt';
 YNomFicResult6= 'Bilan';
 YNomFicResultVobj= 'VOBJ';
 YNomFicResultVop = 'VOP';
 YNomFicResultM= 'Vdef';
 YNomFicSortie = 'CondStat';    {nom du fichier r‚sumant les conditions du calcul et des stats de r‚sultats}
 YNomFicTpsRet = 'RETOUR.txt';  {nom du fichier des temps de retour d‚sir‚s pour analyse statistique}
 YNomFicV      = 'Vobj-';       {base du nom des fichiers typ‚s de volume stock‚ ‚valu‚s en chrono inverse}
 YNomFicVdef   = 'Vdef-';       {base du nom des fichiers typ‚s de manque de capacit‚}
 YNomFicVges   = 'Vges-';       {base du nom des fichiers typ‚s de volume stock‚ ‚valu‚s en sens chronologique}
 YNomFicVop    = 'Vop-';        {base du nom des fichiers typ‚s de volume op‚rationnel}
 YRepB         ='BARRAGES\';
 YRepD         ='DONNEES\';
 YRepO         ='OBJECTIF\';
 YRepP         ='PARAMETR\';
 YRepR         ='RESULTAT\';
 YRepS         ='RESEAUX\';
 YRepStations  ='STATIONS\';
 YRepT         ='TEMPORAI.RE\';
 YNomFicQXdef   : array[1..2] of string = ('QXdefA-','QXdefB-'); {base du nom des fichiers typ‚s de d‚faillance de d‚bit, pour sens pas chrono et sens chrono}
 YNomFicQXdefT  : array[1..2] of string = ('QXdefTA-','QXdefTB-'); {base du nom des fichiers typ‚s de d‚faillance de d‚bit (valeurs tri‚es), pour sens pas chrono et sens chrono}
 YNomFicResult5: array[1..2] of string = ('EchecQ-A.txt','EchecQ-B.txt');{noms de fichiers r‚sultats concernant les d‚faillances de d‚bit, pour sens pas chrono et sens chrono}


TYPE

 YChai2        = string[2];
 YChai8        = string[8];
 YChai10       = string[10];
 YTab1         = array[1..YNmaxLacs] of double;
 Ytab2         = array[1..YNbmaxAn] of double;
 YTab3         = array[0..2] of double;
 YTabInt1      = array[1..YNmaxLacs] of integer;
 YTypFOD       = file of double;
 YTypFreq      = array[1..YNbFreq] of double;
 YTypTpsRet    = array[1..YNbmaxTpsRet] of double;

 YTypDeb2      = record
                  YQXsous : double; {objectif de d‚bit stock‚ … la station aval}
                  YDateEnjour : array[0..YNMaxlacs] of longint; {date compt‚e en jours depuis le 31/12/1899}
                  YQMnat : YTab1;  {d‚bit naturel … la prise, d‚cal‚ de -D par rapport … station aval systŠme (D = tps propag)}
                  YQVnat : YTab1;  {d‚bit naturel … la restitution, d‚cal‚ de -D par rapport … station aval systŠme (D = tps propag)}
                 end;
 YBareme       = record
                  YEffectif : integer;
                  YVolume   : array[1..YNmaxBareme] of double;
                  YDebit    : array[1..YNmaxBareme] of double;
                 end;

CONST {tableaux}

 YNomDebit     : array[1..4] of string = ('QMres','QVres','QMref','QVref');
 YNomParamLac  : array[1..13] of string[20] =
                  ('nom de station aval','nombre de stations',
                   'QEmin','QEmax','Qsmin','Qsmax','Volume','Delai de propagation',
                   'type de formule ou nombre de dates','borne de gradient',
                   'quantiemes','rangs de formules','formule');
 YNomParamReso : array[1..16] of string[42] =
                  ('nombre de stations amont ou intermediaires', 'identifiant aval',
                   'identifiant amont','identifiant intermediaire','PKV','PKM',
                   'PKamont','TV','TM','Tamont','Tintermediaire','Saval','Sv',
                   'Sm','Samont','Sintermediaire');
 YSeparateur   : set of byte = [0..39,42,44,58,59,123..255];
 YSuffixe      : array[1..2] of YChai2 =('.1','.2');
 YTpsFreq      : YTypFreq=(1000.0,500.0,200.0,100.0,50.0,20.0,10.0,5.0);
 YTpsRetParDefo: YTypTpsRet =(2,3,4,5,10,15,20,25,50,100,150,200);
 YExt : array[0..2] of char = ('0','1','2');

VAR {fichiers}

 YFiText       : text;  {fichier texte}
 YFicSortie    : text;  {fichier texte pour sortie de r‚sultats}
 YFicResult1   : text;  {fichiers texte pour sortie de r‚sultats}
 YFicResult2   : text;  {fichiers texte pour sortie de r‚sultats}
 YFicResult3   : text;  {fichier texte pour sortie de r‚sultats}
 YFicResult4   : text;
 YFicTest      : text;

 YFicQXdef      : array[0..3,1..2] of YTypFOD;{pour QXdef0 … QXdef?, et pour sens pas chrono et sens chrono}
 YFicQXdefT     : array[1..2,1..2] of YTypFOD;{pour QXdef1 … QXdef2 tri‚s, et pour sens pas chrono et sens chrono}

 YFicVdef      : array[1..YNmaxLacs] of YTypFOD;
 YFicVobj      : array[1..YNmaxLacs] of YTypFOD;
 YFicVop       : array[1..YNmaxLacs] of YTypFOD;
 YFicVges      : array[1..YNmaxLacs] of YTypFOD;

 YFicDeb       : file of YTypDeb2;
 YFicDebTemp   : file of YTypDeb2;

VAR {chaines de caractŠres}

 YChaine        : string;
 YChaine93      : string[93];
 YChaine228     : string[228];
 YNomFicDebit   : string; {nom du fichier des d‚bits naturels}
 YNomFicLacs    : string; {nom du fichier des paramŠtres des lacs}
 YNomFicObjectif: string; {nom du fichier des d‚bits objectifs}
 YNomRepBarrage : string; {nom du r‚pertoire (chemin complet) des fichiers de rŠgles barrage}
 YNomRepReseau  : string; {nom du r‚pertoire (chemin complet) des fichiers de r‚seaux associ‚s aux barrages}
 YResume        : string;

 YExtension     : string[2];
 YNum           : string[2];
 YDat1          : YChai10;
 YDat2          : YChai10;
 YNomStatAval   : Ychai8; {code d'identification de station aval du systŠme}

VAR {boolean}
 YCodeTpot     : boolean; {si true : Tpot = Tpot1, dur‚e potentielle minimale de reconstitution de volume utilisable maximal aprŠs fin de pas de temps}
                          {si false : Tpot = Tpot2, dur‚e potentielle d'‚puisement de volume utilisable aprŠs fin de pas de temps}
 YSaisie       : boolean; {true pour saisie des choix de calcul au clavier, false pour lecture sur fichier}
 YChoixFreq    : boolean; {true si param‚trage de formule de fr‚quence}
 YConvergeTout : boolean;
 YDernierLuGlop: boolean;
 YOuvertEtLu   : boolean;
 YCalculPossibl: boolean; {true si paramŠtres lus sans problŠme dans fichiers en entr‚e}
 YGlopGlopDebit: boolean; {true si nombre suffisant de lignes lues dans fichier de d‚bit de base}
 YlacuneDebit  : boolean; {true si d‚bits stations existent pour calcul de QXnat prise ou restit.}
 YStandard     : boolean; {true si r‚partition des tƒches selon volume exploitable r‚el des lacs}
 YTestCalcTri  : boolean; {si true, alors calculs de tri de QXdef et stockage des r‚sultats}
 YYaBonResult  : boolean;

VAR {entiers}

 YAbsRel       : integer; {code d'‚dition des volumes : 1 pour valeurs absolues, 2 pour valeurs relatives}
 Yan           : integer; {ann‚e}
 YAnDebutV     : integer;
 YAnDernier    : integer;
 YAnFinV       : integer;
 YAnPremier    : integer;
 YChoix        : integer; {0 pour saisie clavier et autre pour lecture sur fichier (options de calcul)}
 YCode         : integer; {code de bonne traduction de chaŒne en num‚rique}
 YComplet      : integer; {1 si d‚bit aval et d‚bits d‚cal‚s aux prises et restit. existent, 0 sinon}
 YCompteur     : integer; {rang du calcul}
 YjTpsRet      : integer;
 YNbLacs       : integer; {nombre de r‚servoirs}
 YNbPbReglage  : integer; {nombre de problŠmes de lecture des r‚glages de volume de r‚servoir}
 YNbQXobj      : integer; {nombre de triplets jour/date d‚bit objectif lus et corrects}
 YNbTpsRet     : integer; {nombre de temps de retour utilis‚s pour analyse statistique}
 YNIter        : integer; {nombre d'it‚rations dans calcul de r‚partition}
 YNItermax     : integer;
 YNItermaxTps  : integer;
 YNIterTps     : integer; {nombre d'it‚rations pour ‚galisation des temps potentiels de remplissage}
 YNIterVolInit : integer;
 YNIterVolume  : integer; {nombre d'it‚rations pour obtenir les bons volumes … un pas de temps donn‚}
 YNMalLu       : integer; {nombre de problŠmes de lecture des paramŠtres}
 YNProbleme    : integer; {Nombre de problŠmes d‚tect‚s sur les paramŠtres}
 YOptionRepart : integer; {1 pour r‚partition fig‚e, 2 pour r‚partition variable}
 YQuant        : integer;
 YRangDelai    : integer; {rang de d‚bit dans tableau YQ}
 YRangLac      : integer; {rang du lac}
 YRangPBarrage : integer; {rang et nom du sous-r‚pertoire contenant une version de paramŠtres r‚servoirs}
 YRangPReseau  : integer; {rang et nom du sous-r‚pertoire contenant une version de paramŠtres r‚seau}
 YrangStatAval : integer; {rang de station aval syst. dans fichier des d‚bits de base}
 YSuccesRepart : integer; {code objectif r‚partition : -1= non atteint, 0=non converg‚, 1=atteint, 2=d‚pass‚}
 YTest         : integer; {1 si croissance de pr‚lŠvement total en fonction de QS0, 0 sinon}
 YTypeDebit    : integer; {1=QRM, 2=QRV, 2=QFM, 4=QFV}
 YTypeObjectif : integer; {0:minimal, 1:maximal}


 YDateDebut    : longint; {d‚but de p‚riode souhait‚e pour le calcul (ref station aval systŠme)}
 YDateDebutV   : longint;
 YDateFin      : longint; {fin de p‚riode souhait‚e pour le calcul (ref station aval systŠme)}
 YDateFinV     : longint;
 YDateInitiale : longint; {date de d‚but des donn‚es (ref stat aval systŠme)}
 Yi            : longint;
 Yj            : longint;
 Yk            : longint;
 YMeilleurDebut: longint; {d‚but de plus longue p‚riode de donn‚es sans lacune}
 YMeilleurFin  : longint; {fin de plus longue p‚riode de donn‚es sans lacune}
 YNbEcrit      : longint; {nombre de lignes de r‚sultats ‚crites sur fichier}
 YNbPbBornes   : longint; {effectif des pb d'initialisation de fourchette de QS0}
 YNTestNul     : longint;
 YPlusLongDuree: longint; {dur‚e de la plus longue p‚riode sans lacune}
 YQuantieme    : longint;
 YRangLu       : longint; {index de lecture dans fichiuer des d‚bits avalsyst., prises et restit.}

VAR {r‚els}

 YA            : double; {paramŠtre de fr‚quence = (j-A)/(N+B), entre 0 et 0.5}
 YB            : double; {paramŠtre de fr‚quence = (j-A)/(N+B), entre 0 et 1}
 YdelMaxKiFodra: double; {dimension max souhaitable de tableau de d‚bit}
 YdelMinKiFodra: double; {dimension min souhaitable de tableau de d‚bit}
 YEcartRVol    : double; {Ecart relatif entre volume de fin de pas de temps et celui qu'il faudrait}
 YEcartRmaxV   : double; {max sur r‚servoirs d'‚cart relatif entre V initial et Vm‚dian du mˆme quantiŠme}
 YFreq         : double; {fr‚quence de non d‚passement}
 YFreqNonDep   : double; {fr‚quence des valeurs de d‚bit QMN des cours d'eau aux prises utilis‚es pour ‚quilibrage desdur‚es de remlplissage}
 YPuiss        : double; {puissance de QXdef pour calcul de d‚faillance moyenne de d‚bit … la station aval}
 YQAntmin      : double; {minimum des d‚bits nat restitutions associ‚s (tps propag) au Q avl systŠme}
 YQST0         : double; {* norme des d‚bits … soutirer en proportion des volumes de r‚servoirs}
 YQSTt0        : double; {d‚bit stock‚ global sans prise en compte des limites de capacit‚ de r‚servoirs}
 YQSTt1        : double; {d‚bit stock‚ global}
 YTps          : double; {temps de retour}
 YVdef0        : double; {manque de capacit‚ de r‚servoir pour pouvoir ‚viter tous les ‚checs (sauf in‚vitables absolus)}
 YVManque      : double; {volume manquant}
 YVolTot0      : double; {volume global pr‚sent sans limitation due aux capacit‚s de r‚servoirs}
 YVolTot1      : double; {volume global pr‚sent}
 YVopAnt       : double; {volume op‚rationnel (combinaison de Vobj et Vges)}
 YVopNouv      : double; {volume op‚rationnel (combinaison de Vobj et Vges)}
 YVRobj        : double; {objectif commun de taux de remplissage}
 YVRTotCumul   : double; {somme des volumes fictifs de r‚servoirs}
 YVTotCumul    : double; {somme des volumes r‚els de r‚servoirs}
 YVVobj        : double; {objectif commun de volume vide cumul‚}

VAR {tableaux de chaines de caractŠres}

 YChaiDate     : array[1..YNmaxLacs] of YChai10; {date en clair}

 YNomLac       : array[1..YNmaxLacs] of YChai8; {nom de lac dans fichier lacs}
 YNomReseau    : array[1..YNmaxLacs] of YChai8; {nom de lac dans 2emes fichiers de paramŠtres (r‚seaux)}
 YNomReservoir : array[1..YNmaxLacs] of YChai8; {nom de lac dans les 1ers fichiers de paramŠtres (contraintes et consignes)}
 YNomStatAv    : array[1..YNmaxLacs] of YChai8; {nom de station aval}
 YNomStatInt   : array[1..YNmaxlacs] of YChai8; {nom de station interm‚diaire}

 YDate         : array[YDelaimin..YDelaiMax] of YChai8; {date cod‚e aaaammjj}

 YJJ_MM_AAAA   : array[0..YNmaxLacs] of YChai10;

 YNomStatAm    : array[1..YNmaxLacs,1..2] of Ychai8; {nom de station amont}

VAR {tableaux d'entiers}

 YJour         : array[0..YNmaxLacs] of integer; {jour}
 YMois         : array[0..YNmaxLacs] of integer; {mois}
 YNbModif      : array[0..YNmaxLacs] of integer; {nombre de corrections de paramŠtres}

 YDateFinLac   : array[0..YNmaxLacs] of longint; {date finale du calcul … rebours}

 YCodeAval     : YTabInt1; {code pour Qavalrestit : -2= sup … QVref, -1=QVref, 0=ajust‚, 1=QVres, 2= inf … QVres}
 YCodePrise    : YTabint1; {code pour Q prise : -4= inf … QEmin,-3=QEmin, -2=QM-QMref, -1=QM-QMres, 0= ajust‚, 1=QM, 2=QEmax, 3=QMsup … QEmax}
 YcodeRepart   : YTabInt1; {code pour d‚bit soutir‚ : -2= inf … minimal, -1= minimal<maximal, 0=ajust‚, 1=maximal=minimal, 2=maximal>minimal, 3= sup … maximal}
 YCodeRestit   : YTabint1; {code pour Q restit : -2=sup … QSmax, -1=Qsmax, 0=ajust‚, 1=Qsmin, 2=inf … QSmin}
 YCodeSigne    : YTabint1; {code pour Qstock‚ : 0 si de mˆme signe que QXsous, 1 sinon}
 YJourDebutLac : YTabInt1;
 YJourFinLac   : YTabInt1; {jour de fin de calcul … rebours}
 YMoisDebutLac : YTabInt1;
 YMoisFinLac   : YTabInt1; {mois de fin de calcul … rebours}
 YNam          : YTabInt1; {nombre de stations amont}
 YNbAn         : YTabInt1; {nbre d'ann‚es entiŠres du calcul … rebours}
 YNint         : YTabInt1; {nombre de stations interm‚diaires}
 YDecalDateV   : YTabInt1; {d‚calage entier de date pour calcul des Vobj}
 YRangStatAv   : YTabInt1; {rang de station aval dans fichier des d‚bits de base}
 YRangStatInt  : YTabInt1; {rang de station interm‚diaire dans fichier des d‚bits de base}

 YNbQXdefNul    : array[0..2,1..2] of longint; {nombre d'‚checs nuls,pour QXdef0, QXdef1 ou QXdef2, et pour sens inverse chrono ou sens chrono}
 YNCodeAval    : array[1..YNmaxLacs,-2..2] of longint;
 YNCodePrise   : array[1..YNmaxLacs,-4..3] of longint;
 YNcodeRepart  : array[1..YNmaxLacs,-2..3] of longint;
 YNCodeRestit  : array[1..YNmaxLacs,-2..2] of longint;
 YNCodeSigne   : array[1..YNmaxLacs,0..1] of longint;
 YNSucces      : array[-4..4] of longint;
 YNSuccesA     : array[-4..4] of longint;  {YNSucces pour sens chronologique}
 YNSuccesB     : array[-4..4] of longint;  {YNSucces pour sens chronologique inverse}

 YDateObj      : array[0..366] of integer; {dates objectifs lues sur fichier}

 YRangStatAm   : array[1..YNmaxLacs,1..2] of integer; {rang de station amont dans fichier des Q de base}

 YNbFormule    : array[1..YNmaxLacs,1..4] of integer; {nombre de formules pour rŠgles de d‚bit}
 YNbPivot      : array[1..YNmaxLacs,1..4] of integer; {nombre de dates pivot pour rŠgles de d‚bit}
 YTypeFormule  : array[1..YNmaxLacs,1..4] of integer; {code entre 0 et 2 prise en compte ou non de gradient}

 YNbSeuil      : array[1..YNmaxLacs,1..4,1..YNbmaxPivot] of integer; {nombre de seuil dans rŠgle de d‚bit}
 YQuantPivot   : array[1..YNmaxLacs,1..4,1..YNbmaxPivot] of integer; {date de d‚but pour rŠgle de d‚bit}
 YRangFormule  : array[1..YNmaxLacs,1..4,0..YNbmaxPivot] of integer; {rang de rŠgle de d‚bit}

VAR {tableaux de r‚els, fa‡on fa‡on}

 YD            : YTab1; {temps de propag entre restitution et station aval du systŠme}
 YdecalDateQ   : YTab1; {partie fractionnaire de la date (en jour) des d‚bits de r‚servoir}
 YDint         : YTab1; {temps de propag entre station interm‚diaire et station aval de r‚servoir}
 YDuree        : YTab1; {dur‚e th‚orique de remplissage}
 YPart         : YTab1; {part de travail assign‚e au r‚servoir en fonction de son volume r‚gl‚}
 YPartTheorique: YTab1; {part de travail assign‚e au r‚servoir en fonction de son volume}
 YQE           : YTab1; {d‚bit de la prise}
 YQEinf        : YTab1; {d‚bit minimal de la prise}
 YQEsup        : YTab1; {d‚bit maximal de la prise}
 YQEmax        : YTab1; {d‚bitance maximale de la prise}
 YQEmax0       : YTab1; {valeur de QEmax pour V=0}
 YQEmax1       : YTab1; {valeur de QEmax pour V=Vtot}
 YQEmin        : YTab1; {d‚bitance minimale de la prise}
 YQEmin0       : YTab1; {valeur de QEmin pour V=0}
 YQEmin1       : YTab1; {valeur de QEmin pour V=Vtot}
 YQMmoyen      : YTab1; {d‚bit moyen de cours d'eau … la prise}
 YQMfreqMoy    : YTab1; {d‚bit moyen de cours d'eau … la prise pour un hydrogramme annuel isofr‚quence donn‚}
 YQMref        : YTab1; {d‚bit de r‚f‚rence … l'aval de la prise}
 YQMres        : YTab1; {d‚bit r‚serv‚ … l'aval de la prise}
 YQS           : YTab1; {d‚bit de la restitution}
 YQSmax        : YTab1; {d‚bitance maximale de la restitution}
 YQSmax0       : YTab1; {valeur de QSmax pour V=0}
 YQSmax1       : YTab1; {valeur de QSmax pour V=Vtot}
 YQSmin        : YTab1; {d‚bitance minimale de la restitution}
 YQSmin0       : YTab1; {valeur de QSmin pour V=0}
 YQSmin1       : YTab1; {valeur de QSmin pour V=Vtot}
 YQST          : YTab1; {d‚bit soutir‚ net local}
 YQSTeffectif  : YTab1; {d‚bit stock‚}
 YQSTmax       : YTab1; {d‚bit soutir‚ net local maximal}
 YQSTmax1      : YTab1; {valeur maximale de d‚bit stock‚ impos‚e par les contraintes physiques et consignes locales}
 YQSTmax2      : YTab1; {valeur maximale de d‚bit stock‚ impos‚e par le volume pr‚sent dans le r‚servoir}
 YQSTmin       : YTab1; {d‚bit soutir‚ net local minimal}
 YQSTmin1      : YTab1; {valeur minimale de d‚bit stock‚ impos‚e par les contraintes physiques et consignes locale}
 YQSTmin2      : YTab1; {valeur minimale de d‚bit stock‚ impos‚e par le volume pr‚sent dans le r‚servoir}
 YQSTpot       : YTab1; {d‚bit stock‚ th‚orique dans le r‚servoir, pour ‚quilibrage des taux de remplissage ou des dur‚es de remplissage}
 YQV           : YTab1; {d‚bit du cours d'eau influenc‚ par le r‚servoir, juste … l'aval de la restitution}
 YQVdef        : YTab1; {d‚faillance de d‚bit … l'aval de la restitution, caus‚e par manque de capacit‚}
 YQVref        : YTab1; {d‚bit de r‚ference … l'aval de la restitution}
 YQVres        : YTab1; {d‚bit r‚serv‚ … l'aval de la restitution}
 YQVVeille     : YTab1; {d‚bit de la veille au point de restitution}
 YReglage      : YTab1; {ajustement demand‚ du volume (fraction du volume cumul‚ de tous les r‚servoirs)}
 YSav          : YTab1; {superficie de BV … station aval de r‚servoir}
 YSint         : YTab1; {superficie de BV … station interm‚diaire de r‚servoir}
 YTPot         : YTab1; {temps minimal de remplissage du volume vide}
 YVDebut       : YTab1; {volume du reservoir au d‚but de simulation en sens chrono}
 YVFin         : YTab1; {volume de r‚servoir au d‚but du calcul … rebours}
 YVges         : YTab1; {volume de r‚servoir au cours du calcul en sens chrono}
 YVmedian      : YTab1; {volume median de r‚servoir … la date JJMM (d‚but calcul … rebours)}
 YVobj         : YTab1; {volume limite … respecter pour satisfaire au mieux l'objectif aval (calcul‚ … rebours)}
 YVobjAnt      : YTab1;
 YVobjNouv     : YTab1;
 YVolume       : YTab1; {volume d'eau dans le r‚servoir}
 YVolumePeutEtr: YTab1; {valeur temporaire de YVolume, adopt‚e si convergence}
 YVop          : YTab1; {volume op‚rationnel (combinaison de Vobj et Vges)}
 YVRtot        : YTab1; {pareil que Vtot, mais r‚gl‚ pour r‚partition des taches}
 YVpot         : YTab1; {volume objectif th‚orique en fin de pas de temps, ‚quilibrant les dur‚es potentielles minimales de reconstitution de volume utilisable max}
 YVtot         : YTab1; {volume maximal stockable dans le r‚servoir}

 YTpsRet       : YTab2; {temps de retour utilis‚s dans l'analyse statistique}

 YQXdef         : YTab3; {d‚faillance de d‚bit … station aval due … :
                         0: contraintes physiques et consignes locales
                         1: contraintes physiques et consignes locales, ainsi que volumes pr‚sents et capacit‚ des r‚servoirs
                         2: volumes pr‚sents et capacit‚ des r‚servoirs}

 YNorme        : array[0..YNmaxlacs] of double; {norme d'‚dition des volumes (1 pour valeur absolue, Vtot pour valeur relative)}
 YVdefmax      : array[0..YNmaxlacs] of double; {valeur maximale de capacit‚ manquante Vdef}

 YVManqueMax   : array[1..2] of double; {manque max de volume global exploitable pour minimiser les d‚faillances, sens chrono et pas chrono}

 YSollicitation: array[1..3] of YTab1; {taux quadratique de sollicitation de r‚servoir, en sens pas chrono, sens chrono et moyenne des deux}

 YVobjMoyrel   : array[1..2] of YTab1; {valeur moyenne de Vobj divis‚e par YVtot, en sens pas chrono et sens chrono}

 YQXdefmax      : array[1..2,1..2] of double; {QXdef1 ou QQXdef2 ; sens pas chrono et sens chrono}
 YQXdefmed      : array[1..2,1..2] of double; {QXdef1 ou QQXdef2 ; sens pas chrono et sens chrono}
 YQXdefmin      : array[1..2,1..2] of double; {QXdef1 ou QQXdef2 ; sens pas chrono et sens chrono}
 YQXdefmoy      : array[1..2,1..2] of double; {QXdef1 ou QQXdef2 ; sens pas chrono et sens chrono}
 YQXdefmoyGlop  : array[0..2,1..3] of double; {QXdef0,QXdef1 ou QXdef2;chrono inverse ou chrono}

 YBorneGradient: array[1..YNmaxLacs,1..4] of double; {gradient max permis … la restitution}
 {YBorneDebit   : array[1..YNmaxLacs,1..4] of double;} {max de d‚bit r‚serv‚ ou de r‚f‚rence en situation normale}
 YDam          : array[1..YNmaxLacs,1..2] of double; {temps de propagation entre station amont et station aval de r‚servoir}
 YDm           : array[1..YNmaxLacs,1..2] of double; {d‚lai de propag. entre point de prise et station aval de r‚servoir}
 YDv           : array[1..YNmaxLacs,1..2] of double; {d‚lai de propag. entre point de restit. et station aval de r‚servoir}
 YSam          : array[1..YNmaxLacs,1..2] of double; {superficie de BV … station amont de r‚servoir}
 YSm           : array[1..YNmaxLacs,1..2] of double; {superficie de BV au point de prise de r‚servoir}
 YSv           : array[1..YNmaxLacs,1..2] of double; {superficie de BV au point de restitution de r‚servoir}

 YValBonneDate : array[1..YNmaxlacs] of YTab2; {valeurs d'une variable correspondant … une date JJMM … l'int‚rieur d'une chronique}

 YQ            : array[0..YNmaxStat,YDelaiMin..YDelaiMax] of double; {d‚bit stations ou aval syst., prises et restitutions}

 YDebit        : array[1..YNmaxLacs,1..4,1..YNbmaxPivot,1..YNbmaxSeuil] of double; {Q pour rŠgle de d‚bit r‚s. ou ref.}
 YSeuil        : array[1..YNmaxLacs,1..4,1..YNbmaxPivot,1..YNbmaxSeuil] of double; {seuil Q amont pour rŠgle Q r‚s. ou ref.}

 YDebitObj     : array[0..366] of double; {d‚bits objectifs lus sur fichier}
 YQXobj        : array[0..366] of double; {d‚bits objectifs calcul‚s pour chaque jour de l'ann‚e}

 YQMNfreq      : array[0..YNmaxLacs,1..365] of double; {valeurs de YQXsous et YQMnat en fonction du quantiŠme, pour une fr‚quence de non d‚passement donn‚e}

 YQXdefFrequent : array[1..2,1..2] of YTypFreq; {pour QXdef1 ou QXdef2 et sens pas chrono et sens chrono}
 YQXdefRare     : array[1..2,1..2] of YTypFreq; {pour QXdef1 ou QXdef2 et sens pas chrono et sens chrono}

VAR {enregistrements}

 YDeb2         : YTypDeb2;
 YQVemax        : array[1..YNmaxLacs] of YBareme; {bareme de d‚bitance max de prise}
 YQVemin        : array[1..YNmaxLacs] of YBareme; {bareme de d‚bitance min de prise}
 YQVsmax        : array[1..YNmaxLacs] of YBareme; {bareme de d‚bitance max de restitution}
 YQVsmin        : array[1..YNmaxLacs] of YBareme; {bareme de d‚bitance min de restitution}

IMPLEMENTATION

BEGIN

END.