source: LMDZ6/branches/Amaury_dev/libf/phylmd/dyn1d/lmdz_old_1dconv.f90 @ 5144

Last change on this file since 5144 was 5144, checked in by abarral, 7 weeks ago

Put YOMCST.h into modules

  • Property svn:executable set to *
  • Property svn:keywords set to Id
File size: 30.9 KB
Line 
1MODULE lmdz_old_1dconv
2  PRIVATE  ! -- We'd love to put IMPLICIT NONE;  here...
3  PUBLIC get_uvd, copie, get_uvd2, rdgrads, spaces
4CONTAINS
5
6  subroutine get_uvd(itap, dtime, file_forctl, file_fordat, &
7          &       ht, hq, hw, hu, hv, hthturb, hqturb, &
8          &       Ts, imp_fcg, ts_fcg, Tp_fcg, Turb_fcg)
9
10    USE lmdz_yomcst
11
12    IMPLICIT NONE
13
14    !ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc
15    ! cette routine permet d obtenir u_convg,v_convg,ht,hq et ainsi de
16    ! pouvoir calculer la convergence et le cisaillement dans la physiq
17    !cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc
18
19    INTEGER klev
20    REAL play(100)  !pression en Pa au milieu de chaque couche GCM
21    INTEGER JM(100) !pression en Pa au milieu de chaque couche GCM
22    REAL coef1(100) !coefficient d interpolation
23    REAL coef2(100) !coefficient d interpolation
24
25    INTEGER nblvlm !nombre de niveau de pression du mesoNH
26    REAL playm(100)  !pression en Pa au milieu de chaque couche Meso-NH
27    REAL hplaym(100) !pression en hPa milieux des couches Meso-NH
28
29    INTEGER i, j, k, ll, in
30
31    CHARACTER*80 file_forctl, file_fordat
32
33    COMMON/com1_phys_gcss/play, coef1, coef2, JM, klev
34    COMMON/com2_phys_gcss/playm, hplaym, nblvlm
35
36    !======================================================================
37    ! methode: on va chercher les donnees du mesoNH de meteo france, on y
38    !          a acces a tout pas detemps grace a la routine rdgrads qui
39    !          est une boucle lisant dans ces fichiers.
40    !          Puis on interpole ces donnes sur les 11 niveaux du gcm et
41    !          et sur les pas de temps de ce meme gcm
42    !----------------------------------------------------------------------
43    ! input:
44    !       pasmax     :nombre de pas de temps maximum du mesoNH
45    !       dt         :pas de temps du meso_NH (en secondes)
46    !----------------------------------------------------------------------
47    INTEGER pasmax, dt
48    save pasmax, dt
49    !----------------------------------------------------------------------
50    ! arguments:
51    !           itap   :compteur de la physique(le nombre de ces pas est
52    !                   fixe dans la subroutine calcul_ini_gcm de interpo
53    !                   -lation
54    !           dtime  :pas detemps du gcm (en secondes)
55    !           ht     :convergence horizontale de temperature(K/s)
56    !           hq     :    "         "       d humidite (kg/kg/s)
57    !           hw     :vitesse verticale moyenne (m/s**2)
58    !           hu     :convergence horizontale d impulsion le long de x
59    !                  (kg/(m^2 s^2)
60    !           hv     : idem le long de y.
61    !           Ts     : Temperature de surface (K)
62    !           imp_fcg: var. LOGICAL .EQ. T si forcage en impulsion
63    !           ts_fcg: var. LOGICAL .EQ. T si forcage en Ts present dans fichier
64    !           Tp_fcg: var. LOGICAL .EQ. T si forcage donne en Temp potentielle
65    !           Turb_fcg: var. LOGICAL .EQ. T si forcage turbulent present dans fichier
66    !----------------------------------------------------------------------
67    INTEGER itap
68    REAL dtime
69    REAL ht(:)
70    REAL hq(:)
71    REAL hu(:)
72    REAL hv(:)
73    REAL hw(:)
74    REAL hthturb(:)
75    REAL hqturb(:)
76    REAL Ts, Ts_subr
77    LOGICAL imp_fcg
78    LOGICAL ts_fcg
79    LOGICAL Tp_fcg
80    LOGICAL Turb_fcg
81    !----------------------------------------------------------------------
82    ! Variables internes de get_uvd (note : l interpolation temporelle
83    ! est faite entre les pas de temps before et after, sur les variables
84    ! definies sur la grille du SCM; on atteint exactement les valeurs Meso
85    ! aux milieux des pas de temps Meso)
86    !     time0     :date initiale en secondes
87    !     time      :temps associe a chaque pas du SCM
88    !     pas       :numero du pas du meso_NH (on lit en pas : le premier pas
89    !                 des donnees est duplique)
90    !     pasprev   :numero du pas de lecture precedent
91    !     htaft     :advection horizontale de temp. au pas de temps after
92    !     hqaft     :    "         "      d humidite        "
93    !     hwaft     :vitesse verticalle moyenne  au pas de temps after
94    !     huaft,hvaft :advection horizontale d impulsion au pas de temps after
95    !     tsaft     : surface temperature 'after time step'
96    !     htbef     :idem htaft, mais pour le pas de temps before
97    !     hqbef     :voir hqaft
98    !     hwbef     :voir hwaft
99    !     hubef,hvbef : idem huaft,hvaft, mais pour before
100    !     tsbef     : surface temperature 'before time step'
101    !----------------------------------------------------------------------
102    INTEGER time0, pas, pasprev
103    save time0, pas, pasprev
104    REAL time
105    REAL htaft(100), hqaft(100), hwaft(100), huaft(100), hvaft(100)
106    REAL hthturbaft(100), hqturbaft(100)
107    REAL Tsaft
108    save htaft, hqaft, hwaft, huaft, hvaft, hthturbaft, hqturbaft
109    REAL htbef(100), hqbef(100), hwbef(100), hubef(100), hvbef(100)
110    REAL hthturbbef(100), hqturbbef(100)
111    REAL Tsbef
112    save htbef, hqbef, hwbef, hubef, hvbef, hthturbbef, hqturbbef
113
114    REAL timeaft, timebef
115    save timeaft, timebef
116    INTEGER temps
117    CHARACTER*4 string
118    !----------------------------------------------------------------------
119    ! variables arguments de la subroutine rdgrads
120    !---------------------------------------------------------------------
121    INTEGER icompt, icomp1 !compteurs de rdgrads
122    REAL z(100)         ! altitude (grille Meso)
123    REAL ht_mes(100)    !convergence horizontale de temperature
124    !-(grille Meso)
125    REAL hq_mes(100)    !convergence horizontale d humidite
126    !(grille Meso)
127    REAL hw_mes(100)    !vitesse verticale moyenne
128    !(grille Meso)
129    REAL hu_mes(100), hv_mes(100)    !convergence horizontale d impulsion
130    !(grille Meso)
131    REAL hthturb_mes(100) !tendance horizontale de T_pot, due aux
132    !flux turbulents
133    REAL hqturb_mes(100) !tendance horizontale d humidite, due aux
134    !flux turbulents
135
136    !---------------------------------------------------------------------
137    ! variable argument de la subroutine copie
138    !---------------------------------------------------------------------
139    ! SB        real pplay(100)    !pression en milieu de couche du gcm
140    ! SB                            !argument de la physique
141    !---------------------------------------------------------------------
142    ! variables destinees a la lecture du pas de temps du fichier de donnees
143    !---------------------------------------------------------------------
144    CHARACTER*80 aaa, atemps, apasmax
145    INTEGER nch, imn, ipa
146    !---------------------------------------------------------------------
147    PRINT*, 'le pas itap est:', itap
148    !*** on determine le pas du meso_NH correspondant au nouvel itap ***
149    !*** pour aller chercher les champs dans rdgrads                 ***
150
151    time = time0 + itap * dtime
152    !c        temps=int(time/dt+1)
153    !c        pas=min(temps,pasmax)
154    temps = 1 + int((dt + 2 * time) / (2 * dt))
155    pas = min(temps, pasmax - 1)
156    PRINT*, 'le pas Meso est:', pas
157
158
159    !===================================================================
160
161    !*** on remplit les champs before avec les champs after du pas   ***
162    !*** precedent en format gcm                                     ***
163    IF(pas>pasprev)THEN
164      do i = 1, klev
165        htbef(i) = htaft(i)
166        hqbef(i) = hqaft(i)
167        hwbef(i) = hwaft(i)
168        hubef(i) = huaft(i)
169        hvbef(i) = hvaft(i)
170        hThTurbbef(i) = hThTurbaft(i)
171        hqTurbbef(i) = hqTurbaft(i)
172      enddo
173      tsbef = tsaft
174      timebef = pasprev * dt
175      timeaft = timebef + dt
176      icomp1 = nblvlm * 4
177      IF (ts_fcg) icomp1 = icomp1 + 1
178      IF (imp_fcg) icomp1 = icomp1 + nblvlm * 2
179      IF (Turb_fcg) icomp1 = icomp1 + nblvlm * 2
180      icompt = icomp1 * pas
181      print *, 'imp_fcg,ts_fcg,Turb_fcg,pas,nblvlm,icompt'
182      print *, imp_fcg, ts_fcg, Turb_fcg, pas, nblvlm, icompt
183      PRINT*, 'le pas pas est:', pas
184      !*** on va chercher les nouveaux champs after dans toga.dat     ***
185      !*** champs en format meso_NH                                   ***
186      open(99, FILE = file_fordat, FORM = 'UNFORMATTED', &
187              &             ACCESS = 'DIRECT', RECL = 8)
188      CALL rdgrads(99, icompt, nblvlm, z, ht_mes, hq_mes, hw_mes                &
189              &, hu_mes, hv_mes, hthturb_mes, hqturb_mes                 &
190              &, ts_fcg, ts_subr, imp_fcg, Turb_fcg)
191
192      IF(Tp_fcg) THEN
193        !     (le forcage est donne en temperature potentielle)
194        do i = 1, nblvlm
195          ht_mes(i) = ht_mes(i) * (hplaym(i) / 1000.)**rkappa
196        enddo
197      endif ! Tp_fcg
198      IF(Turb_fcg) THEN
199        do i = 1, nblvlm
200          hThTurb_mes(i) = hThTurb_mes(i) * (hplaym(i) / 1000.)**rkappa
201        enddo
202      endif  ! Turb_fcg
203
204      PRINT*, 'ht_mes ', (ht_mes(i), i = 1, nblvlm)
205      PRINT*, 'hq_mes ', (hq_mes(i), i = 1, nblvlm)
206      PRINT*, 'hw_mes ', (hw_mes(i), i = 1, nblvlm)
207      IF(imp_fcg) THEN
208        PRINT*, 'hu_mes ', (hu_mes(i), i = 1, nblvlm)
209        PRINT*, 'hv_mes ', (hv_mes(i), i = 1, nblvlm)
210      endif
211      IF(Turb_fcg) THEN
212        PRINT*, 'hThTurb_mes ', (hThTurb_mes(i), i = 1, nblvlm)
213        PRINT*, 'hqTurb_mes ', (hqTurb_mes(i), i = 1, nblvlm)
214      endif
215      IF (ts_fcg) PRINT*, 'ts_subr', ts_subr
216      !*** on interpole les champs meso_NH sur les niveaux de pression***
217      !*** gcm . on obtient le nouveau champ after                    ***
218      do k = 1, klev
219        IF (JM(k) == 0) THEN
220          htaft(k) = ht_mes(jm(k) + 1)
221          hqaft(k) = hq_mes(jm(k) + 1)
222          hwaft(k) = hw_mes(jm(k) + 1)
223          IF(imp_fcg) THEN
224            huaft(k) = hu_mes(jm(k) + 1)
225            hvaft(k) = hv_mes(jm(k) + 1)
226          endif ! imp_fcg
227          IF(Turb_fcg) THEN
228            hThTurbaft(k) = hThTurb_mes(jm(k) + 1)
229            hqTurbaft(k) = hqTurb_mes(jm(k) + 1)
230          endif ! Turb_fcg
231        else ! JM(k) .EQ. 0
232          htaft(k) = coef1(k) * ht_mes(jm(k)) + coef2(k) * ht_mes(jm(k) + 1)
233          hqaft(k) = coef1(k) * hq_mes(jm(k)) + coef2(k) * hq_mes(jm(k) + 1)
234          hwaft(k) = coef1(k) * hw_mes(jm(k)) + coef2(k) * hw_mes(jm(k) + 1)
235          IF(imp_fcg) THEN
236            huaft(k) = coef1(k) * hu_mes(jm(k)) + coef2(k) * hu_mes(jm(k) + 1)
237            hvaft(k) = coef1(k) * hv_mes(jm(k)) + coef2(k) * hv_mes(jm(k) + 1)
238          endif ! imp_fcg
239          IF(Turb_fcg) THEN
240            hThTurbaft(k) = coef1(k) * hThTurb_mes(jm(k))                            &
241                    & + coef2(k) * hThTurb_mes(jm(k) + 1)
242            hqTurbaft(k) = coef1(k) * hqTurb_mes(jm(k))                             &
243                    & + coef2(k) * hqTurb_mes(jm(k) + 1)
244          endif ! Turb_fcg
245        endif ! JM(k) .EQ. 0
246      enddo
247      tsaft = ts_subr
248      pasprev = pas
249    else ! pas.gt.pasprev
250      PRINT*, 'timebef est:', timebef
251    endif ! pas.gt.pasprev    fin du bloc relatif au passage au pas
252    !de temps (meso) suivant
253    !*** si on atteint le pas max des donnees experimentales ,on     ***
254    !*** on conserve les derniers champs calcules                    ***
255    IF(temps>=pasmax)THEN
256      do ll = 1, klev
257        ht(ll) = htaft(ll)
258        hq(ll) = hqaft(ll)
259        hw(ll) = hwaft(ll)
260        hu(ll) = huaft(ll)
261        hv(ll) = hvaft(ll)
262        hThTurb(ll) = hThTurbaft(ll)
263        hqTurb(ll) = hqTurbaft(ll)
264      enddo
265      ts_subr = tsaft
266    else ! temps.ge.pasmax
267      !*** on interpole sur les pas de temps de 10mn du gcm a partir   ***
268      !** des pas de temps de 1h du meso_NH                            ***
269      do j = 1, klev
270        ht(j) = ((timeaft - time) * htbef(j) + (time - timebef) * htaft(j)) / dt
271        hq(j) = ((timeaft - time) * hqbef(j) + (time - timebef) * hqaft(j)) / dt
272        hw(j) = ((timeaft - time) * hwbef(j) + (time - timebef) * hwaft(j)) / dt
273        IF(imp_fcg) THEN
274          hu(j) = ((timeaft - time) * hubef(j) + (time - timebef) * huaft(j)) / dt
275          hv(j) = ((timeaft - time) * hvbef(j) + (time - timebef) * hvaft(j)) / dt
276        endif ! imp_fcg
277        IF(Turb_fcg) THEN
278          hThTurb(j) = ((timeaft - time) * hThTurbbef(j)                           &
279                  & + (time - timebef) * hThTurbaft(j)) / dt
280          hqTurb(j) = ((timeaft - time) * hqTurbbef(j)                            &
281                  & + (time - timebef) * hqTurbaft(j)) / dt
282        endif ! Turb_fcg
283      enddo
284      ts_subr = ((timeaft - time) * tsbef + (time - timebef) * tsaft) / dt
285    endif ! temps.ge.pasmax
286
287    print *, ' time,timebef,timeaft', time, timebef, timeaft
288    print *, ' ht,htbef,htaft,hthturb,hthturbbef,hthturbaft'
289    do j = 1, klev
290      print *, j, ht(j), htbef(j), htaft(j), &
291              &             hthturb(j), hthturbbef(j), hthturbaft(j)
292    enddo
293    print *, ' hq,hqbef,hqaft,hqturb,hqturbbef,hqturbaft'
294    do j = 1, klev
295      print *, j, hq(j), hqbef(j), hqaft(j), &
296              &             hqturb(j), hqturbbef(j), hqturbaft(j)
297    enddo
298
299    !-------------------------------------------------------------------
300
301    IF (Ts_fcg) Ts = Ts_subr
302    return
303
304    !-----------------------------------------------------------------------
305    ! on sort les champs de "convergence" pour l instant initial 'in'
306    ! ceci se passe au pas temps itap=0 de la physique
307    !-----------------------------------------------------------------------
308    entry get_uvd2(itap, dtime, file_forctl, file_fordat, &
309            &           ht, hq, hw, hu, hv, hThTurb, hqTurb, ts, &
310            &           imp_fcg, ts_fcg, Tp_fcg, Turb_fcg)
311    PRINT*, 'le pas itap est:', itap
312
313    !===================================================================
314
315    WRITE(*, '(a)') 'OPEN ' // file_forctl
316    open(97, FILE = file_forctl, FORM = 'FORMATTED')
317
318    !------------------
319    do i = 1, 1000
320      read(97, 1000, end = 999) string
321      1000 format (a4)
322      IF (string == 'TDEF') go to 50
323    enddo
324    50   backspace(97)
325    !-------------------------------------------------------------------
326    !   *** on lit le pas de temps dans le fichier de donnees ***
327    !   *** "forcing.ctl" et pasmax                           ***
328    !-------------------------------------------------------------------
329    read(97, 2000) aaa
330    2000  format (a80)
331    PRINT*, 'aaa est', aaa
332    aaa = spaces(aaa, 1)
333    PRINT*, 'aaa', aaa
334    CALL getsch(aaa, ' ', ' ', 5, atemps, nch)
335    PRINT*, 'atemps est', atemps
336    atemps = atemps(1:nch - 2)
337    PRINT*, 'atemps', atemps
338    read(atemps, *) imn
339    dt = imn * 60
340    PRINT*, 'le pas de temps dt', dt
341    CALL getsch(aaa, ' ', ' ', 2, apasmax, nch)
342    apasmax = apasmax(1:nch)
343    read(apasmax, *) ipa
344    pasmax = ipa
345    PRINT*, 'pasmax est', pasmax
346    CLOSE(97)
347    !------------------------------------------------------------------
348    ! *** on lit le pas de temps initial de la simulation ***
349    !------------------------------------------------------------------
350    in = itap
351    !c                  pasprev=in
352    !c                  time0=dt*(pasprev-1)
353    pasprev = in - 1
354    time0 = dt * pasprev
355
356    close(98)
357
358    WRITE(*, '(a)') 'OPEN ' // file_fordat
359    open(99, FILE = file_fordat, FORM = 'UNFORMATTED', ACCESS = 'DIRECT', RECL = 8)
360    icomp1 = nblvlm * 4
361    IF (ts_fcg) icomp1 = icomp1 + 1
362    IF (imp_fcg) icomp1 = icomp1 + nblvlm * 2
363    IF (Turb_fcg) icomp1 = icomp1 + nblvlm * 2
364    icompt = icomp1 * (in - 1)
365    CALL rdgrads(99, icompt, nblvlm, z, ht_mes, hq_mes, hw_mes              &
366            &, hu_mes, hv_mes, hthturb_mes, hqturb_mes              &
367            &, ts_fcg, ts_subr, imp_fcg, Turb_fcg)
368    print *, 'get_uvd : rdgrads ->'
369    print *, tp_fcg
370
371    ! following commented out because we have temperature already in ARM case
372    !   (otherwise this is the potential temperature )
373    !------------------------------------------------------------------------
374    IF(Tp_fcg) THEN
375      do i = 1, nblvlm
376        ht_mes(i) = ht_mes(i) * (hplaym(i) / 1000.)**rkappa
377      enddo
378    endif ! Tp_fcg
379    PRINT*, 'ht_mes ', (ht_mes(i), i = 1, nblvlm)
380    PRINT*, 'hq_mes ', (hq_mes(i), i = 1, nblvlm)
381    PRINT*, 'hw_mes ', (hw_mes(i), i = 1, nblvlm)
382    IF(imp_fcg) THEN
383      PRINT*, 'hu_mes ', (hu_mes(i), i = 1, nblvlm)
384      PRINT*, 'hv_mes ', (hv_mes(i), i = 1, nblvlm)
385      PRINT*, 't', ts_subr
386    endif ! imp_fcg
387    IF(Turb_fcg) THEN
388      PRINT*, 'hThTurb_mes ', (hThTurb_mes(i), i = 1, nblvlm)
389      PRINT*, 'hqTurb ', (hqTurb_mes(i), i = 1, nblvlm)
390    endif ! Turb_fcg
391    !----------------------------------------------------------------------
392    ! on a obtenu des champs initiaux sur les niveaux du meso_NH
393    ! on interpole sur les niveaux du gcm(niveau pression bien sur!)
394    !-----------------------------------------------------------------------
395    do k = 1, klev
396      IF (JM(k) == 0) THEN
397        !FKC bug? ne faut il pas convertir tsol en tendance ????
398        !RT bug taken care of by removing the stuff
399        htaft(k) = ht_mes(jm(k) + 1)
400        hqaft(k) = hq_mes(jm(k) + 1)
401        hwaft(k) = hw_mes(jm(k) + 1)
402        IF(imp_fcg) THEN
403          huaft(k) = hu_mes(jm(k) + 1)
404          hvaft(k) = hv_mes(jm(k) + 1)
405        endif ! imp_fcg
406        IF(Turb_fcg) THEN
407          hThTurbaft(k) = hThTurb_mes(jm(k) + 1)
408          hqTurbaft(k) = hqTurb_mes(jm(k) + 1)
409        endif ! Turb_fcg
410      else ! JM(k) .EQ. 0
411        htaft(k) = coef1(k) * ht_mes(jm(k)) + coef2(k) * ht_mes(jm(k) + 1)
412        hqaft(k) = coef1(k) * hq_mes(jm(k)) + coef2(k) * hq_mes(jm(k) + 1)
413        hwaft(k) = coef1(k) * hw_mes(jm(k)) + coef2(k) * hw_mes(jm(k) + 1)
414        IF(imp_fcg) THEN
415          huaft(k) = coef1(k) * hu_mes(jm(k)) + coef2(k) * hu_mes(jm(k) + 1)
416          hvaft(k) = coef1(k) * hv_mes(jm(k)) + coef2(k) * hv_mes(jm(k) + 1)
417        endif ! imp_fcg
418        IF(Turb_fcg) THEN
419          hThTurbaft(k) = coef1(k) * hThTurb_mes(jm(k))                        &
420                  & + coef2(k) * hThTurb_mes(jm(k) + 1)
421          hqTurbaft(k) = coef1(k) * hqTurb_mes(jm(k))                         &
422                  & + coef2(k) * hqTurb_mes(jm(k) + 1)
423        endif ! Turb_fcg
424      endif ! JM(k) .EQ. 0
425    enddo
426    tsaft = ts_subr
427    ! valeurs initiales des champs de convergence
428    do k = 1, klev
429      ht(k) = htaft(k)
430      hq(k) = hqaft(k)
431      hw(k) = hwaft(k)
432      IF(imp_fcg) THEN
433        hu(k) = huaft(k)
434        hv(k) = hvaft(k)
435      endif ! imp_fcg
436      IF(Turb_fcg) THEN
437        hThTurb(k) = hThTurbaft(k)
438        hqTurb(k) = hqTurbaft(k)
439      endif ! Turb_fcg
440    enddo
441    ts_subr = tsaft
442    close(99)
443    close(98)
444
445    !-------------------------------------------------------------------
446
447    IF (Ts_fcg) Ts = Ts_subr
448    return
449
450    999     continue
451    stop 'erreur lecture, file forcing.ctl'
452  end
453
454  SUBROUTINE advect_tvl(dtime, zt, zq, vu_f, vv_f, t_f, q_f                   &
455          &, d_t_adv, d_q_adv)
456    USE dimphy
457    IMPLICIT NONE
458
459    INCLUDE "dimensions.h"
460    !cccc      INCLUDE "dimphy.h"
461
462    INTEGER k
463    REAL dtime, fact, du, dv, cx, cy, alx, aly
464    REAL zt(klev), zq(klev, 3)
465    REAL vu_f(klev), vv_f(klev), t_f(klev), q_f(klev, 3)
466
467    REAL d_t_adv(klev), d_q_adv(klev, 3)
468
469    ! Velocity of moving cell
470    data cx, cy /12., -2./
471
472    ! Dimensions of moving cell
473    data alx, aly /100000., 150000./
474
475    do k = 1, klev
476      du = abs(vu_f(k) - cx) / alx
477      dv = abs(vv_f(k) - cy) / aly
478      fact = dtime * (du + dv - du * dv * dtime)
479      d_t_adv(k) = fact * (t_f(k) - zt(k))
480      d_q_adv(k, 1) = fact * (q_f(k, 1) - zq(k, 1))
481      d_q_adv(k, 2) = fact * (q_f(k, 2) - zq(k, 2))
482      d_q_adv(k, 3) = fact * (q_f(k, 3) - zq(k, 3))
483    enddo
484
485    RETURN
486  end
487
488  SUBROUTINE copie(klevgcm, playgcm, psolgcm, file_forctl)
489    IMPLICIT NONE
490
491    !cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc
492    ! cette routine remplit les COMMON com1_phys_gcss et com2_phys_gcss.h
493    !ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc
494
495    INTEGER klev !nombre de niveau de pression du GCM
496    REAL play(100)  !pression en Pa au milieu de chaque couche GCM
497    INTEGER JM(100)
498    REAL coef1(100)   !coefficient d interpolation
499    REAL coef2(100)   !coefficient d interpolation
500
501    INTEGER nblvlm !nombre de niveau de pression du mesoNH
502    REAL playm(100) !pression en Pa au milieu de chaque couche Meso-NH
503    REAL hplaym(100)!pression en hecto-Pa des milieux de couche Meso-NH
504
505    COMMON/com1_phys_gcss/play, coef1, coef2, JM, klev
506    COMMON/com2_phys_gcss/playm, hplaym, nblvlm
507
508    INTEGER k, klevgcm
509    REAL playgcm(klevgcm) ! pression en milieu de couche du gcm
510    REAL psolgcm
511    CHARACTER*80 file_forctl
512
513    klev = klevgcm
514
515    !---------------------------------------------------------------------
516    ! pression au milieu des couches du gcm dans la physiq
517    ! (SB: remplace le CALL conv_lipress_gcm(playgcm) )
518    !---------------------------------------------------------------------
519
520    do k = 1, klev
521      play(k) = playgcm(k)
522      PRINT*, 'la pression gcm est:', play(k)
523    enddo
524
525    !----------------------------------------------------------------------
526    ! lecture du descripteur des donnees Meso-NH (forcing.ctl):
527    !  -> nb niveaux du meso.NH (nblvlm) + pressions meso.NH
528    ! (on remplit le COMMON com2_phys_gcss)
529    !----------------------------------------------------------------------
530
531    CALL mesolupbis(file_forctl)
532
533    PRINT*, 'la valeur de nblvlm est:', nblvlm
534
535    !----------------------------------------------------------------------
536    ! etude de la correspondance entre les niveaux meso.NH et GCM;
537    ! calcul des coefficients d interpolation coef1 et coef2
538    ! (on remplit le COMMON com1_phys_gcss)
539    !----------------------------------------------------------------------
540
541    CALL corresbis(psolgcm)
542
543    !---------------------------------------------------------
544    ! TEST sur le remplissage de com1_phys_gcss et com2_phys_gcss:
545    !---------------------------------------------------------
546
547    WRITE(*, *) ' '
548    WRITE(*, *) 'TESTS com1_phys_gcss et com2_phys_gcss dans copie.F'
549    WRITE(*, *) '--------------------------------------'
550    WRITE(*, *) 'GCM: nb niveaux:', klev, ' et pression, coeffs:'
551    do k = 1, klev
552      WRITE(*, *) play(k), coef1(k), coef2(k)
553    enddo
554    WRITE(*, *) 'MESO-NH: nb niveaux:', nblvlm, ' et pression:'
555    do k = 1, nblvlm
556      WRITE(*, *) playm(k), hplaym(k)
557    enddo
558    WRITE(*, *) ' '
559
560  END
561  SUBROUTINE mesolupbis(file_forctl)
562    !ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc
563
564    ! Lecture descripteur des donnees MESO-NH (forcing.ctl):
565    ! -------------------------------------------------------
566
567    !     Cette subroutine lit dans le fichier de controle "essai.ctl"
568    !     et affiche le nombre de niveaux du Meso-NH ainsi que les valeurs
569    !     des pressions en milieu de couche du Meso-NH (en Pa puis en hPa).
570    !ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc
571
572    INTEGER nblvlm !nombre de niveau de pression du mesoNH
573    REAL playm(100)  !pression en Pa milieu de chaque couche Meso-NH
574    REAL hplaym(100) !pression en hPa des milieux de couche Meso-NH
575    COMMON/com2_phys_gcss/playm, hplaym, nblvlm
576
577    INTEGER i, lu, mlz, mlzh
578
579    CHARACTER*80 file_forctl
580
581    CHARACTER*4 a
582    CHARACTER*80 aaa, anblvl
583    INTEGER nch
584
585    lu = 9
586    open(lu, file = file_forctl, form = 'formatted')
587
588    do i = 1, 1000
589      read(lu, 1000, end = 999) a
590      IF (a == 'ZDEF') go to 100
591    enddo
592
593    100  backspace(lu)
594    PRINT*, '  DESCRIPTION DES 2 MODELES : '
595    PRINT*, ' '
596
597    read(lu, 2000) aaa
598    2000  format (a80)
599    aaa = spaces(aaa, 1)
600    CALL getsch(aaa, ' ', ' ', 2, anblvl, nch)
601    read(anblvl, *) nblvlm
602
603    PRINT*, 'nbre de niveaux de pression Meso-NH :', nblvlm
604    PRINT*, ' '
605    PRINT*, 'pression en Pa de chaque couche du meso-NH :'
606
607    read(lu, *) (playm(mlz), mlz = 1, nblvlm)
608    !      Si la pression est en HPa, la multiplier par 100
609    IF (playm(1) < 10000.) THEN
610      do mlz = 1, nblvlm
611        playm(mlz) = playm(mlz) * 100.
612      enddo
613    endif
614    PRINT*, (playm(mlz), mlz = 1, nblvlm)
615
616    1000 format (a4)
617
618    PRINT*, ' '
619    do mlzh = 1, nblvlm
620      hplaym(mlzh) = playm(mlzh) / 100.
621    enddo
622
623    PRINT*, 'pression en hPa de chaque couche du meso-NH: '
624    PRINT*, (hplaym(mlzh), mlzh = 1, nblvlm)
625
626    close (lu)
627    return
628
629    999  stop 'erreur lecture des niveaux pression des donnees'
630  end
631
632  SUBROUTINE rdgrads(itape, icount, nl, z, ht, hq, hw, hu, hv, hthtur, hqtur, &
633          &  ts_fcg, ts, imp_fcg, Turb_fcg)
634    IMPLICIT NONE
635    INTEGER itape, icount, icomp, nl
636    REAL z(nl), ht(nl), hq(nl), hw(nl), hu(nl), hv(nl)
637    REAL hthtur(nl), hqtur(nl)
638    REAL ts
639
640    INTEGER k
641
642    LOGICAL imp_fcg, ts_fcg, Turb_fcg
643
644    icomp = icount
645
646    do k = 1, nl
647      icomp = icomp + 1
648      read(itape, rec = icomp)z(k)
649      print *, 'icomp,k,z(k) ', icomp, k, z(k)
650    enddo
651    do k = 1, nl
652      icomp = icomp + 1
653      read(itape, rec = icomp)hT(k)
654      PRINT*, hT(k), k
655    enddo
656    do k = 1, nl
657      icomp = icomp + 1
658      read(itape, rec = icomp)hQ(k)
659    enddo
660
661    IF(turb_fcg) THEN
662      do k = 1, nl
663        icomp = icomp + 1
664        read(itape, rec = icomp)hThTur(k)
665      enddo
666      do k = 1, nl
667        icomp = icomp + 1
668        read(itape, rec = icomp)hqTur(k)
669      enddo
670    endif
671    print *, ' apres lecture hthtur, hqtur'
672
673    IF(imp_fcg) THEN
674      do k = 1, nl
675        icomp = icomp + 1
676        read(itape, rec = icomp)hu(k)
677      enddo
678      do k = 1, nl
679        icomp = icomp + 1
680        read(itape, rec = icomp)hv(k)
681      enddo
682
683    endif
684
685    do k = 1, nl
686      icomp = icomp + 1
687      read(itape, rec = icomp)hw(k)
688    enddo
689
690    IF(ts_fcg) THEN
691      icomp = icomp + 1
692      read(itape, rec = icomp)ts
693    endif
694
695    print *, ' rdgrads ->'
696
697    RETURN
698  END
699
700  SUBROUTINE corresbis(psol)
701    IMPLICIT NONE
702
703    !cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc
704    ! Cette subroutine calcule et affiche les valeurs des coefficients
705    ! d interpolation qui serviront dans la formule d interpolation elle-
706    ! meme.
707    !ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc
708
709    INTEGER klev    !nombre de niveau de pression du GCM
710    REAL play(100)  !pression en Pa au milieu de chaque couche GCM
711    INTEGER JM(100)
712    REAL coef1(100) !coefficient d interpolation
713    REAL coef2(100) !coefficient d interpolation
714
715    INTEGER nblvlm !nombre de niveau de pression du mesoNH
716    REAL playm(100) !pression en Pa milieu de chaque couche Meso-NH
717    REAL hplaym(100)!pression en hPa des milieux de couche Meso-NH
718
719    COMMON/com1_phys_gcss/play, coef1, coef2, JM, klev
720    COMMON/com2_phys_gcss/playm, hplaym, nblvlm
721
722    REAL psol
723    REAL val
724    INTEGER k, mlz
725
726    do k = 1, klev
727      val = play(k)
728      IF (val > playm(1)) THEN
729        mlz = 0
730        JM(1) = mlz
731        coef1(1) = (playm(mlz + 1) - val) / (playm(mlz + 1) - psol)
732        coef2(1) = (val - psol) / (playm(mlz + 1) - psol)
733      ELSE IF (val > playm(nblvlm)) THEN
734        do mlz = 1, nblvlm
735          IF (val <= playm(mlz).AND. val > playm(mlz + 1))THEN
736            JM(k) = mlz
737            coef1(k) = (playm(mlz + 1) - val) / (playm(mlz + 1) - playm(mlz))
738            coef2(k) = (val - playm(mlz)) / (playm(mlz + 1) - playm(mlz))
739          endif
740        enddo
741      else
742        JM(k) = nblvlm - 1
743        coef1(k) = 0.
744        coef2(k) = 0.
745      endif
746    enddo
747
748    !c      if (play(klev) .le. playm(nblvlm)) THEN
749    !c         mlz=nblvlm-1
750    !c         JM(klev)=mlz
751    !c         coef1(klev)=(playm(mlz+1)-val)
752    !c     *            /(playm(mlz+1)-playm(mlz))
753    !c         coef2(klev)=(val-playm(mlz))
754    !c     *            /(playm(mlz+1)-playm(mlz))
755    !c      endif
756
757    PRINT*, ' '
758    PRINT*, '         INTERPOLATION  : '
759    PRINT*, ' '
760    PRINT*, 'correspondance de 9 niveaux du GCM sur les 53 du meso-NH:'
761    PRINT*, (JM(k), k = 1, klev)
762    PRINT*, 'correspondance de 9 niveaux du GCM sur les 53 du meso-NH:'
763    PRINT*, (JM(k), k = 1, klev)
764    PRINT*, ' '
765    PRINT*, 'vals du premier coef d"interpolation pour les 9 niveaux: '
766    PRINT*, (coef1(k), k = 1, klev)
767    PRINT*, ' '
768    PRINT*, 'valeurs du deuxieme coef d"interpolation pour les 9 niveaux:'
769    PRINT*, (coef2(k), k = 1, klev)
770
771    RETURN
772  END
773  SUBROUTINE GETSCH(STR, DEL, TRM, NTH, SST, NCH)
774    !***************************************************************
775    !*                                                             *
776    !*                                                             *
777    !* GETSCH                                                      *
778    !*                                                             *
779    !*                                                             *
780    !* modified by :                                               *
781    !***************************************************************
782    !*   Return in SST the character string found between the NTH-1 and NTH
783    !*   occurence of the delimiter 'DEL' but before the terminator 'TRM' in
784    !*   the input string 'STR'. If TRM=DEL then STR is considered unlimited.
785    !*   NCH=Length of the string returned in SST or =-1 if NTH is <1 or if
786    !*   NTH is greater than the number of delimiters in STR.
787    IMPLICIT INTEGER (A-Z)
788    CHARACTER STR*(*), DEL*1, TRM*1, SST*(*)
789    NCH = -1
790    SST = ' '
791    IF(NTH>0) THEN
792      IF(TRM==DEL) THEN
793        LENGTH = LEN(STR)
794      ELSE
795        LENGTH = INDEX(STR, TRM) - 1
796        IF(LENGTH<0) LENGTH = LEN(STR)
797      ENDIF
798      !*     Find beginning and end of the NTH DEL-limited substring in STR
799      END = -1
800      DO N = 1, NTH
801        IF(END==LENGTH) RETURN
802        BEG = END + 2
803        END = BEG + INDEX(STR(BEG:LENGTH), DEL) - 2
804        IF(END==BEG - 2) END = LENGTH
805        !*        PRINT *,'NTH,LENGTH,N,BEG,END=',NTH,LENGTH,N,BEG,END
806      end DO
807      NCH = END - BEG + 1
808      IF(NCH>0) SST = STR(BEG:END)
809    ENDIF
810  END
811  CHARACTER*(80) FUNCTION SPACES(STR, NSPACE)
812
813    ! CERN PROGLIB# M433    SPACES          .VERSION KERNFOR  4.14  860211
814    ! ORIG.  6/05/86 M.GOOSSENS/DD
815
816    !-    The function value SPACES returns the character string STR with
817    !-    leading blanks removed and each occurence of one or more blanks
818    !-    replaced by NSPACE blanks inside the string STR
819
820    CHARACTER*(80) STR
821    INTEGER nspace, IBLANK, ISPACE, INONBL, LENSPA
822
823    LENSPA = LEN(SPACES)
824    SPACES = ' '
825    IF (NSPACE<0) NSPACE = 0
826    IBLANK = 1
827    ISPACE = 1
828    100 INONBL = INDEXC(STR(IBLANK:), ' ')
829    IF (INONBL==0) THEN
830      SPACES(ISPACE:) = STR(IBLANK:)
831      RETURN
832    ENDIF
833    INONBL = INONBL + IBLANK - 1
834    IBLANK = INDEX(STR(INONBL:), ' ')
835    IF (IBLANK==0) THEN
836      SPACES(ISPACE:) = STR(INONBL:)
837      RETURN
838    ENDIF
839    IBLANK = IBLANK + INONBL - 1
840    SPACES(ISPACE:) = STR(INONBL:IBLANK - 1)
841    ISPACE = ISPACE + IBLANK - INONBL + NSPACE
842    IF (ISPACE<=LENSPA)                         GO TO 100
843  END
844  INTEGER FUNCTION INDEXC(STR, SSTR)
845
846    ! CERN PROGLIB# M433    INDEXC          .VERSION KERNFOR  4.14  860211
847    ! ORIG. 26/03/86 M.GOOSSENS/DD
848
849    !-    Find the leftmost position where substring SSTR does not match
850    !-    string STR scanning forward
851
852    CHARACTER*(*) STR, SSTR
853    INTEGER I, LENS, LENSS
854
855    LENS = LEN(STR)
856    LENSS = LEN(SSTR)
857
858    DO I = 1, LENS - LENSS + 1
859      IF (STR(I:I + LENSS - 1)/=SSTR) THEN
860        INDEXC = I
861        RETURN
862      ENDIF
863    END DO
864    INDEXC = 0
865  END
866END MODULE lmdz_old_1dconv
Note: See TracBrowser for help on using the repository browser.