CALCULS3.PAS 8.45 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
Unit CALCULS3;

interface
 uses Utilit,Declara,Calculs2;

 procedure CalculChroniquesVolume;

IMPLEMENTATION

procedure CalculChroniquesVolume;
 begin

   if not YSaisie then
    begin
     writeln;
     writeln('Rang du calcul : ',YCompteur,' ;  ',YResume);
    end;

   for YRanglac:=1 to YNbLacs do

    begin

     {--message cran--}
     if YSaisie then
      write(YnomLac[YRangLac]);

     {==CALCUL A REBOURS --> VOLUME EXTREME COMPATIBLE AVEC OBJECTIF FUTUR==}

     {--calcul de la date entire du dbit stock initial dans le lac --}
     {--(dcal du temps de propagation par rapport  la date initiale--}
     {--du calcul considre  midi  la station aval du systme      --}
     YDateFinLac[YrangLac]:=trunc(YDateFin+0.5-YD[YRangLac]);

     {--initialisation du volume de rservoir (plein pour objectif Qmax et  --}
     {--vide pour un objectif Qmin) et calcul du jour et du mois de dbut de--}
     {--calcul  rebours                                                    --}
     YJJ_MM_AAAA:=ADate(YDateFinLac[YRangLac]);
     val(copy(YJJ_MM_AAAA,4,2),YMoisFinLac,YCode);
     val(copy(YJJ_MM_AAAA,1,2),YJourFinLac,YCode);
     YNIter:=0;
     YConverge:=false;
     if YTypeObjectif=0 then
      YVFin:=0
     else
      YVFin:=YVtot[YRangLac];

     {--ENCADREMENTS SUCCESSIFS POUR DETERMINER LE BON VOLUME INITIAL--}
     repeat

      YNIter:=YNIter+1;
      YNbAn:=0;
      YVolume:=YVFin;
      reset(YFicQST[YrangLac]);

      {--boucle sur le temps en chrono inverse--}
      for Yi:=YDateFinLac[YRanglac] downto (YDateFinLac[YRangLac]-(YDateFin-YDateDebut)) do

       begin

        YJJ_MM_AAAA:=ADate(Yi);
        val(copy(YJJ_MM_AAAA,4,2),YMois,YCode);
        val(copy(YJJ_MM_AAAA,1,2),YJour,YCode);

        {--si quantime = quantime initial, stockage du volume--}
        if (YMois=YMoisFinLac) and (YJour=YJourFinLac) then
         begin
          YNbAn:=YNbAn+1;
          YValBonnedate[YNbAn]:=YVolume;
         end;

        {--lecture de dbit stock idal sur fichier typ en chrono --}
        {--inverse, et calcul de nouveau volume                     --}
        read(YFicQST[YRangLac],YQST[YRanglac]);
        YVolume:=Amindouble(YVtot[YRangLac],Amaxdouble(0,YVolume-YQST[YrangLac]*86400));

       end; {fin de boucle sur le temps en chrono inverse}

      {--tri par valeurs croissantes des volumes obtenus pour le --}
      {--quantime initial                                       --}
      Tri(YValBonneDate,YNbAn);

      {--calcul du volume mdian obtenu pour le quantime initial--}
      YVmedian:=Quantile(YValBonneDate,YNbAn,0.5);

      {--si volume mdian est proche du volume initial, la convergence--}
      {--est obtenue, sinon on calcule un nouveau volume initial      --}
      if abs(YVMedian-YVFin)<(YVtot[YRanglac]*YSeuilRConv) then
       YConverge:=true
      else
       YVFin:=Amindouble(YVtot[YRanglac],Amaxdouble(0,(YNbAn*YVMedian-YVFin)/(YNbAn-1)));

     until YConverge or (YNIter=YNbmaxIter);  {fin des encadrements successifs}

     {--message cran : nombre d'itrations --}
     if YSaisie then
      write('(',YNiter);

     {--REMPLISSAGE FICHIERS TYPES DE VOLUME ET MANQUE CAPACITE PAR LACUNES--}
     rewrite(YFicVobj[YRangLac]);
     rewrite(YFicVobj0[YRangLac]);
     rewrite(YFicVdef[YRangLac]);
     YVolume:=Ylacune;
     for Yi:=YDateDebut to YDateFin do
      begin
       write(YFicVobj[YRangLac],YVolume);
       write(YFicVobj0[YRangLac],YVolume);
       write(YFicVdef[YRangLac],YVolume);
      end;

     {==CALCUL DEFINITIF DE LA CHRONIQUE DE VOLUME EN CHRONO INVERSE, AVEC==}
     {==la bonne valeur initiale, et criture sur fichiers typs de ces   ==}
     {==volumes (dcals de + 12h par rapport aux dbits stocks nets du  ==}
     {==lac), ainsi que des manques de capacit de rservoir, dans le sens==}
     {==chronologique. Dans le cas d'un objectif de laminage, les volumes ==}
     {==sont les max  ne pas dpasser pour viter les checs dus  un lac==}
     {==plein                                                             ==}

     {--initialisation du volume en fin de priode et ouverture du fichier--}
     {--des dbits stocks en chrono inverse                              --}
     YVobj:=YVFin;
     YVobj0:=YVFin;
     YVdef:=0;
     YVdefmax[YRangLac]:=0;
     reset(YFicQST[YrangLac]);

     {--boucle sur le temps en chrono inverse--}
     for Yi:=YDateFinLac[YRanglac] downto (YDateFinLac[YRangLac]-(YDateFin-YDateDebut)) do

      begin

       read(YFicQST[YRangLac],YQST[YRanglac]);
       seek(YFicVobj[YRangLac],filepos(YFicVobj[YRangLac])-1);
       write(YFicVobj[YRangLac],YVobj);
       seek(YFicVobj[YRangLac],filepos(YFicVobj[YRangLac])-1);
       seek(YFicVobj0[YRangLac],filepos(YFicVobj0[YRangLac])-1);
       write(YFicVobj0[YRangLac],YVobj0);
       seek(YFicVobj0[YRangLac],filepos(YFicVobj0[YRangLac])-1);
       seek(YFicVdef[YRangLac],filepos(YFicVdef[YRangLac])-1);
       write(YFicVdef[YRangLac],YVdef);
       seek(YFicVdef[YRangLac],filepos(YFicVdef[YRangLac])-1);
       YVobj:=Amindouble(YVtot[YRangLac],Amaxdouble(0,YVobj-YQST[YrangLac]*86400));

       {--cas d'un objectif de dbit maximal : laminage de crue--}
       if YTypeObjectif=1 then
        begin
         YVobj0:=Amindouble(YVtot[YRangLac],YVobj0-YQST[YrangLac]*86400);
         YVdef:=Amax(0,-YVobj0);
        end

       {--cas d'un objectif de dbit minimal : soutien d'tiage--}
       else
        begin
         YVobj0:=Amaxdouble(0,YVobj0-YQST[YrangLac]*86400);
         YVdef:=AMax(0,YVobj0-YVtot[YRangLac])
        end;

       YVdefmax[YRangLac]:=amax(YVdefmax[YRanglac],YVdef);

      end; {fin de boucle sur le temps en chrono inverse}

     close(YFicVdef[YRangLac]);
     close(YFicVobj[YRangLac]);
     close(YFicVobj0[YRangLac]);

     {==CALCUL EN SENS CHRONO -> VOLUME OPTIMAL POUR OBJECTif IMMEDIAT     ==}
     {--On effectue ci-dessous un calcul en sens chronologique sens       --}
     {--reproduire de faon raliste une gestion consistant  stocker (en +--}
     {--ou en -) dans le rservoir pour atteindre de suite l'objectif aval.--}
     {--Ceci correspond  la meilleure gestion qu'on puisse raliser. Le   --}
     {--dbit stock ainsi obtenu est alors compar au dbit stock idal  --}
     {--pour valuer une dfaillance qui, somme pour tous les rservoirs  --}
     {--et ajoute aux dfaillances invitables, donne les dfaillances    --}
     {--minimales dues aux diffrentes causes (rpartition des apports     --}
     {--naturels, contraintes et consignes aux prises et restitutions et   --}
     {--manque de capacit des rservoirs                                  --}

     {--INITIALISATION DU VOLUME POUR CALCUL EN SENS CHRONO (comme pour le  --}
     {--calcul en chrono inverse, on cherche par encadrements successifs une--}
     {--valeur concidant avec la mediane obtenue pour le quantieme initial)--}
     InitVolumeSimulEnSensChrono;

     {--CALCUL DEFINITIF EN SENS CHRONO--}
     YVolume:=YVDebut;
     seek(YFicQST[YRanglac],filesize(YFicQST[YRangLac])-1);
     rewrite(YFicVges[YRanglac]);
     reset(YFicQdef[1]);
     for Yi:=YdateDebut to YdateFin do
      begin
       read(YFicQST[YRangLac],YQST[YRangLac]);
       seek(YFicQST[YRangLac],abs(filepos(YFicQST[YRanglac])-2));
       YVges:=Amindouble(YVtot[YRangLac],Amax(0,YVolume+YQST[YrangLac]*86400));
       write(YFicVges[YRangLac],YVges);
       YQSTeffectif:=(YVges-YVolume)/86400;
       if YTypeObjectif=0 then {cas de soutien d'tiage}
        YQVdef:=Amax(0,YQSTeffectif-YQST[YRangLac])
       else {cas de laminage de crue}
        YQVdef:=Amax(0,YQST[YRangLac]-YQSTEffectif);
       read(YFicQdef[1],YQdef1);
       seek(YFicQdef[1],filepos(YFicQdef[1])-1);
       YQdef1:=YQdef1+YQVdef;
       write(YFicQdef[1],YQdef1);
       YVolume:=YVges;
      end;
     if YSaisie then
      write(',',YNIter,') ');

     {--FERMETURE DES FICHIERS TYPES DE QST ET QDEF[1]--}
     close(YFicQST[YrangLac]);
     close(YFicQdef[1]);


     {--CALCUL DU VOLUME OPERATIONNEL Vop--}
     rewrite(YFicVop[YRangLac]);
     reset(YFicVobj[YRangLac]);
     reset(YFicVges[YRangLac]);
     while not eof(YFicVobj[YRangLac]) do
      begin
       read(YFicVobj[YRangLac],YVobj);
       read(YFicVges[YRangLac],YVges);
       if YTypeObjectif=0 then {cas du soutien d'tiage}
        YVop:=amin(YVobj,YVges)
       else {cas du laminage de crue}
        YVop:=amax(YVobj,YVges);
       write(YFicVop[YRangLac],YVop);
      end;
     close(YFicVobj[YRangLac]);
     close(YFicVges[YRangLac]);
     close(YFicVop [YRangLac]);

    end;  {fin de boucle sur les rservoirs pour calcul des volumes limites}
 end;

BEGIN
END.