source: palm/trunk/SOURCE/ocean_mod.f90 @ 3655

Last change on this file since 3655 was 3636, checked in by raasch, 3 years ago

nopointer option removed

  • Property svn:keywords set to Id
File size: 82.0 KB
Line 
1!> @file ocean_mod.f90
2!------------------------------------------------------------------------------!
3! This file is part of the PALM model system.
4!
5! PALM is free software: you can redistribute it and/or modify it under the
6! terms of the GNU General Public License as published by the Free Software
7! Foundation, either version 3 of the License, or (at your option) any later
8! version.
9!
10! PALM is distributed in the hope that it will be useful, but WITHOUT ANY
11! WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
12! A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
13!
14! You should have received a copy of the GNU General Public License along with
15! PALM. If not, see <http://www.gnu.org/licenses/>.
16!
17! Copyright 2017-2018 Leibniz Universitaet Hannover
18!--------------------------------------------------------------------------------!
19!
20! Current revisions:
21! -----------------
22!
23!
24! Former revisions:
25! -----------------
26! $Id: ocean_mod.f90 3636 2018-12-19 13:48:34Z knoop $
27! nopointer option removed
28!
29! 3614 2018-12-10 07:05:46Z raasch
30! unused variables removed
31!
32! 3568 2018-11-27 16:07:59Z raasch
33! bugifx: calculate equation of state for seawater even if salinity is switched
34!         off
35!
36! 3421 2018-10-24 18:39:32Z gronemeier
37! Renamed output variables
38!
39! 3381 2018-10-19 13:09:06Z raasch
40! spin-up cooling for ocean surface implemented, see new parameter
41! surface_cooling_spinup_time
42!
43! 3311 2018-10-05 12:34:56Z raasch
44! check if ocean mode is used for invalid combinations
45!
46! 3303 2018-10-03 12:04:15Z raasch
47! salinity allowed to be switched off
48!
49! 3302 2018-10-03 02:39:40Z raasch
50! Craik Leibovich force (Stokes drift) + wave breaking effect added
51!
52! 3294 2018-10-01 02:37:10Z raasch
53! initial revision
54!
55!
56! Authors:
57! --------
58! @author Siegfried Raasch
59!
60! Description:
61! ------------
62!> This module contains relevant code for PALM's ocean mode, e.g. the
63!> prognostic equation for salinity, the equation of state for seawater,
64!> the Craik Leibovich force (Stokes force), and wave breaking effects
65!------------------------------------------------------------------------------!
66 MODULE ocean_mod
67 
68
69    USE arrays_3d,                                                             &
70        ONLY:  prho, prho_1, rho_ocean, rho_1, sa, sa_init, sa_1, sa_2, sa_3,  &
71               sa_p, tsa_m
72
73    USE control_parameters,                                                    &
74        ONLY:  atmos_ocean_sign, bottom_salinityflux,                          &
75               constant_top_salinityflux, ocean_mode, top_salinityflux,        &
76               wall_salinityflux
77
78    USE kinds
79
80
81    IMPLICIT NONE
82
83    CHARACTER (LEN=20) ::  bc_sa_t = 'neumann'  !< namelist parameter
84
85    INTEGER(iwp) ::  ibc_sa_t   !< integer flag for bc_sa_t
86    INTEGER(iwp) ::  iran_ocean = -1234567  !< random number used for wave breaking effects
87
88    INTEGER(iwp) ::  sa_vertical_gradient_level_ind(10) = -9999  !< grid index values of sa_vertical_gradient_level(s)
89
90    LOGICAL ::  salinity = .TRUE.             !< switch for using salinity
91    LOGICAL ::  stokes_force = .FALSE.        !< switch to switch on the Stokes force
92    LOGICAL ::  wave_breaking = .FALSE.       !< switch to switch on wave breaking effects
93    LOGICAL ::  surface_cooling_switched_off = .FALSE.  !< variable to check if surface heat flux has been switched off
94
95    REAL(wp) ::  alpha_wave_breaking = 3.0_wp !< coefficient for wave breaking generated turbulence from Noh et al. (2004), JPO
96    REAL(wp) ::  prho_reference               !< reference state of potential density at ocean surface
97    REAL(wp) ::  sa_surface = 35.0_wp         !< surface salinity, namelist parameter
98    REAL(wp) ::  sa_vertical_gradient(10) = 0.0_wp               !< namelist parameter
99    REAL(wp) ::  sa_vertical_gradient_level(10) = -999999.9_wp   !< namelist parameter
100    REAL(wp) ::  stokes_waveheight = 0.0_wp  !< wave height assumed for Stokes drift velocity
101    REAL(wp) ::  stokes_wavelength = 0.0_wp  !< wavelength assumed for Stokes drift velocity
102    REAL(wp) ::  surface_cooling_spinup_time = 999999.9_wp  !< time after which surface heat flux is switched off
103    REAL(wp) ::  timescale_wave_breaking     !< time scale of random forcing
104    REAL(wp) ::  u_star_wave_breaking        !< to store the absolute value of friction velocity at the ocean surface
105
106    REAL(wp), DIMENSION(12), PARAMETER ::  nom =                               &
107                          (/ 9.9984085444849347D2,   7.3471625860981584D0,     &
108                            -5.3211231792841769D-2,  3.6492439109814549D-4,    &
109                             2.5880571023991390D0,  -6.7168282786692354D-3,    &
110                             1.9203202055760151D-3,  1.1798263740430364D-2,    &
111                             9.8920219266399117D-8,  4.6996642771754730D-6,    &
112                            -2.5862187075154352D-8, -3.2921414007960662D-12 /)
113                          !< constants used in equation of state for seawater
114
115    REAL(wp), DIMENSION(13), PARAMETER ::  den =                               &
116                          (/ 1.0D0,                  7.2815210113327091D-3,    &
117                            -4.4787265461983921D-5,  3.3851002965802430D-7,    &
118                             1.3651202389758572D-10, 1.7632126669040377D-3,    &
119                            -8.8066583251206474D-6, -1.8832689434804897D-10,   &
120                             5.7463776745432097D-6,  1.4716275472242334D-9,    &
121                             6.7103246285651894D-6, -2.4461698007024582D-17,   &
122                            -9.1534417604289062D-18 /)
123                          !< constants used in equation of state for seawater
124
125    SAVE
126
127    PUBLIC ::  bc_sa_t, ibc_sa_t, prho_reference, sa_surface,                  &
128               sa_vertical_gradient, sa_vertical_gradient_level,               &
129               sa_vertical_gradient_level_ind, stokes_force, wave_breaking
130
131
132    INTERFACE eqn_state_seawater
133       MODULE PROCEDURE eqn_state_seawater
134       MODULE PROCEDURE eqn_state_seawater_ij
135    END INTERFACE eqn_state_seawater
136
137    INTERFACE eqn_state_seawater_func
138       MODULE PROCEDURE eqn_state_seawater_func
139    END INTERFACE eqn_state_seawater_func
140
141    INTERFACE ocean_check_parameters
142       MODULE PROCEDURE ocean_check_parameters
143    END INTERFACE ocean_check_parameters
144
145    INTERFACE ocean_check_data_output
146       MODULE PROCEDURE ocean_check_data_output
147    END INTERFACE ocean_check_data_output
148
149    INTERFACE ocean_check_data_output_pr
150       MODULE PROCEDURE ocean_check_data_output_pr
151    END INTERFACE ocean_check_data_output_pr
152
153    INTERFACE ocean_define_netcdf_grid
154       MODULE PROCEDURE ocean_define_netcdf_grid
155    END INTERFACE ocean_define_netcdf_grid
156
157    INTERFACE ocean_data_output_2d
158       MODULE PROCEDURE ocean_data_output_2d
159    END INTERFACE ocean_data_output_2d
160
161    INTERFACE ocean_data_output_3d
162       MODULE PROCEDURE ocean_data_output_3d
163    END INTERFACE ocean_data_output_3d
164
165    INTERFACE ocean_header
166       MODULE PROCEDURE ocean_header
167    END INTERFACE ocean_header
168
169    INTERFACE ocean_init
170       MODULE PROCEDURE ocean_init
171    END INTERFACE ocean_init
172
173    INTERFACE ocean_init_arrays
174       MODULE PROCEDURE ocean_init_arrays
175    END INTERFACE ocean_init_arrays
176
177    INTERFACE ocean_parin
178       MODULE PROCEDURE ocean_parin
179    END INTERFACE ocean_parin
180
181    INTERFACE ocean_prognostic_equations
182       MODULE PROCEDURE ocean_prognostic_equations
183       MODULE PROCEDURE ocean_prognostic_equations_ij
184    END INTERFACE ocean_prognostic_equations
185
186    INTERFACE ocean_swap_timelevel
187       MODULE PROCEDURE ocean_swap_timelevel
188    END INTERFACE ocean_swap_timelevel
189
190    INTERFACE ocean_rrd_global
191       MODULE PROCEDURE ocean_rrd_global
192    END INTERFACE ocean_rrd_global
193
194    INTERFACE ocean_rrd_local
195       MODULE PROCEDURE ocean_rrd_local
196    END INTERFACE ocean_rrd_local
197
198    INTERFACE ocean_wrd_global
199       MODULE PROCEDURE ocean_wrd_global
200    END INTERFACE ocean_wrd_global
201
202    INTERFACE ocean_wrd_local
203       MODULE PROCEDURE ocean_wrd_local
204    END INTERFACE ocean_wrd_local
205
206    INTERFACE ocean_3d_data_averaging
207       MODULE PROCEDURE ocean_3d_data_averaging
208    END INTERFACE ocean_3d_data_averaging
209
210    INTERFACE stokes_drift_terms
211       MODULE PROCEDURE stokes_drift_terms
212       MODULE PROCEDURE stokes_drift_terms_ij
213    END INTERFACE stokes_drift_terms
214
215    INTERFACE wave_breaking_term
216       MODULE PROCEDURE wave_breaking_term
217       MODULE PROCEDURE wave_breaking_term_ij
218    END INTERFACE wave_breaking_term
219
220    PRIVATE
221!
222!-- Add INTERFACES that must be available to other modules (alphabetical order)
223    PUBLIC eqn_state_seawater, ocean_check_data_output,                        &
224           ocean_check_data_output_pr, ocean_check_parameters,                 &
225           ocean_data_output_2d, ocean_data_output_3d,                         &
226           ocean_define_netcdf_grid, ocean_header, ocean_init,                 &
227           ocean_init_arrays, ocean_parin, ocean_prognostic_equations,         &
228           ocean_swap_timelevel, ocean_rrd_global, ocean_rrd_local,            &
229           ocean_wrd_global, ocean_wrd_local, ocean_3d_data_averaging,         &
230           stokes_drift_terms, wave_breaking_term
231
232
233 CONTAINS
234
235!------------------------------------------------------------------------------!
236! Description:
237! ------------
238!> Equation of state for seawater as a function of potential temperature,
239!> salinity, and pressure.
240!> For coefficients see Jackett et al., 2006: J. Atm. Ocean Tech.
241!> eqn_state_seawater calculates the potential density referred at hyp(0).
242!> eqn_state_seawater_func calculates density.
243!> TODO: so far, routine is not adjusted to use topography
244!------------------------------------------------------------------------------!
245 SUBROUTINE eqn_state_seawater
246
247    USE arrays_3d,                                                             &
248        ONLY:  hyp, prho, pt_p, rho_ocean, sa_p
249    USE indices,                                                               &
250        ONLY:  nxl, nxr, nyn, nys, nzb, nzt
251
252    USE surface_mod,                                                           &
253        ONLY :  bc_h
254
255    IMPLICIT NONE
256
257    INTEGER(iwp) ::  i       !< running index x direction
258    INTEGER(iwp) ::  j       !< running index y direction
259    INTEGER(iwp) ::  k       !< running index z direction
260    INTEGER(iwp) ::  m       !< running index surface elements
261
262    REAL(wp) ::  pden   !< temporary scalar user for calculating density
263    REAL(wp) ::  pnom   !< temporary scalar user for calculating density
264    REAL(wp) ::  p1     !< temporary scalar user for calculating density
265    REAL(wp) ::  p2     !< temporary scalar user for calculating density
266    REAL(wp) ::  p3     !< temporary scalar user for calculating density
267    REAL(wp) ::  pt1    !< temporary scalar user for calculating density
268    REAL(wp) ::  pt2    !< temporary scalar user for calculating density
269    REAL(wp) ::  pt3    !< temporary scalar user for calculating density
270    REAL(wp) ::  pt4    !< temporary scalar user for calculating density
271    REAL(wp) ::  sa1    !< temporary scalar user for calculating density
272    REAL(wp) ::  sa15   !< temporary scalar user for calculating density
273    REAL(wp) ::  sa2    !< temporary scalar user for calculating density
274
275
276    DO  i = nxl, nxr
277       DO  j = nys, nyn
278          DO  k = nzb+1, nzt
279!
280!--          Pressure is needed in dbar
281             p1 = hyp(k) * 1E-4_wp
282             p2 = p1 * p1
283             p3 = p2 * p1
284
285!
286!--          Temperature needed in degree Celsius
287             pt1 = pt_p(k,j,i) - 273.15_wp
288             pt2 = pt1 * pt1
289             pt3 = pt1 * pt2
290             pt4 = pt2 * pt2
291
292             sa1  = sa_p(k,j,i)
293             sa15 = sa1 * SQRT( sa1 )
294             sa2  = sa1 * sa1
295
296             pnom = nom(1)           + nom(2)*pt1     + nom(3)*pt2     +       &
297                    nom(4)*pt3       + nom(5)*sa1     + nom(6)*sa1*pt1 +       &
298                    nom(7)*sa2
299
300             pden = den(1)           + den(2)*pt1     + den(3)*pt2     +       &
301                    den(4)*pt3       + den(5)*pt4     + den(6)*sa1     +       &
302                    den(7)*sa1*pt1   + den(8)*sa1*pt3 + den(9)*sa15    +       &
303                    den(10)*sa15*pt2
304!
305!--          Potential density (without pressure terms)
306             prho(k,j,i) = pnom / pden
307
308             pnom = pnom +             nom(8)*p1      + nom(9)*p1*pt2  +       &
309                    nom(10)*p1*sa1   + nom(11)*p2     + nom(12)*p2*pt2
310
311             pden = pden +             den(11)*p1     + den(12)*p2*pt3 +       &
312                    den(13)*p3*pt1
313
314!
315!--          In-situ density
316             rho_ocean(k,j,i) = pnom / pden
317
318          ENDDO
319
320!
321!--       Neumann conditions are assumed at top boundary and currently also at
322!--       bottom boundary (see comment lines below)
323          prho(nzt+1,j,i)      = prho(nzt,j,i)
324          rho_ocean(nzt+1,j,i) = rho_ocean(nzt,j,i)
325
326       ENDDO
327    ENDDO
328!
329!-- Neumann conditions at up/downward-facing surfaces
330    !$OMP PARALLEL DO PRIVATE( i, j, k )
331    DO  m = 1, bc_h(0)%ns
332       i = bc_h(0)%i(m)
333       j = bc_h(0)%j(m)
334       k = bc_h(0)%k(m)
335       prho(k-1,j,i)      = prho(k,j,i)
336       rho_ocean(k-1,j,i) = rho_ocean(k,j,i)
337    ENDDO
338!
339!-- Downward facing surfaces
340    !$OMP PARALLEL DO PRIVATE( i, j, k )
341    DO  m = 1, bc_h(1)%ns
342       i = bc_h(1)%i(m)
343       j = bc_h(1)%j(m)
344       k = bc_h(1)%k(m)
345       prho(k+1,j,i)      = prho(k,j,i)
346       rho_ocean(k+1,j,i) = rho_ocean(k,j,i)
347    ENDDO
348
349 END SUBROUTINE eqn_state_seawater
350
351
352!------------------------------------------------------------------------------!
353! Description:
354! ------------
355!> Same as above, but for grid point i,j
356!------------------------------------------------------------------------------!
357 SUBROUTINE eqn_state_seawater_ij( i, j )
358
359    USE arrays_3d,                                                             &
360        ONLY:  hyp, prho, pt_p, rho_ocean, sa_p
361
362    USE indices,                                                               &
363        ONLY:  nzb, nzt
364
365    USE surface_mod,                                                           &
366       ONLY :  bc_h
367
368    IMPLICIT NONE
369
370    INTEGER(iwp) ::  i       !< running index x direction
371    INTEGER(iwp) ::  j       !< running index y direction
372    INTEGER(iwp) ::  k       !< running index z direction
373    INTEGER(iwp) ::  m       !< running index surface elements
374    INTEGER(iwp) ::  surf_e  !< end index of surface elements at (j,i)-gridpoint
375    INTEGER(iwp) ::  surf_s  !< start index of surface elements at (j,i)-gridpoint
376
377    REAL(wp) ::  pden   !< temporary scalar user for calculating density
378    REAL(wp) ::  pnom   !< temporary scalar user for calculating density
379    REAL(wp) ::  p1     !< temporary scalar user for calculating density
380    REAL(wp) ::  p2     !< temporary scalar user for calculating density
381    REAL(wp) ::  p3     !< temporary scalar user for calculating density
382    REAL(wp) ::  pt1    !< temporary scalar user for calculating density
383    REAL(wp) ::  pt2    !< temporary scalar user for calculating density
384    REAL(wp) ::  pt3    !< temporary scalar user for calculating density
385    REAL(wp) ::  pt4    !< temporary scalar user for calculating density
386    REAL(wp) ::  sa1    !< temporary scalar user for calculating density
387    REAL(wp) ::  sa15   !< temporary scalar user for calculating density
388    REAL(wp) ::  sa2    !< temporary scalar user for calculating density
389
390    DO  k = nzb+1, nzt
391!
392!--    Pressure is needed in dbar
393       p1 = hyp(k) * 1E-4_wp
394       p2 = p1 * p1
395       p3 = p2 * p1
396!
397!--    Temperature needed in degree Celsius
398       pt1 = pt_p(k,j,i) - 273.15_wp
399       pt2 = pt1 * pt1
400       pt3 = pt1 * pt2
401       pt4 = pt2 * pt2
402
403       sa1  = sa_p(k,j,i)
404       sa15 = sa1 * SQRT( sa1 )
405       sa2  = sa1 * sa1
406
407       pnom = nom(1)           + nom(2)*pt1     + nom(3)*pt2     +             &
408              nom(4)*pt3       + nom(5)*sa1     + nom(6)*sa1*pt1 + nom(7)*sa2
409
410       pden = den(1)           + den(2)*pt1     + den(3)*pt2     +             &
411              den(4)*pt3       + den(5)*pt4     + den(6)*sa1     +             &
412              den(7)*sa1*pt1   + den(8)*sa1*pt3 + den(9)*sa15    +             &
413              den(10)*sa15*pt2
414!
415!--    Potential density (without pressure terms)
416       prho(k,j,i) = pnom / pden
417
418       pnom = pnom +             nom(8)*p1      + nom(9)*p1*pt2  +             &
419              nom(10)*p1*sa1   + nom(11)*p2     + nom(12)*p2*pt2
420       pden = pden +             den(11)*p1     + den(12)*p2*pt3 +             &
421              den(13)*p3*pt1
422
423!
424!--    In-situ density
425       rho_ocean(k,j,i) = pnom / pden
426
427    ENDDO
428!
429!-- Neumann conditions at up/downward-facing walls
430    surf_s = bc_h(0)%start_index(j,i)
431    surf_e = bc_h(0)%end_index(j,i)
432    DO  m = surf_s, surf_e
433       k = bc_h(0)%k(m)
434       prho(k-1,j,i)      = prho(k,j,i)
435       rho_ocean(k-1,j,i) = rho_ocean(k,j,i)
436    ENDDO
437!
438!-- Downward facing surfaces
439    surf_s = bc_h(1)%start_index(j,i)
440    surf_e = bc_h(1)%end_index(j,i)
441    DO  m = surf_s, surf_e
442       k = bc_h(1)%k(m)
443       prho(k+1,j,i)      = prho(k,j,i)
444       rho_ocean(k+1,j,i) = rho_ocean(k,j,i)
445    ENDDO
446!
447!-- Neumann condition are assumed at top boundary
448    prho(nzt+1,j,i)      = prho(nzt,j,i)
449    rho_ocean(nzt+1,j,i) = rho_ocean(nzt,j,i)
450
451 END SUBROUTINE eqn_state_seawater_ij
452
453
454!------------------------------------------------------------------------------!
455! Description:
456! ------------
457!> Equation of state for seawater as a function
458!------------------------------------------------------------------------------!
459 REAL(wp) FUNCTION eqn_state_seawater_func( p, pt, sa )
460
461    IMPLICIT NONE
462
463    REAL(wp) ::  p      !< temporary scalar user for calculating density
464    REAL(wp) ::  p1     !< temporary scalar user for calculating density
465    REAL(wp) ::  p2     !< temporary scalar user for calculating density
466    REAL(wp) ::  p3     !< temporary scalar user for calculating density
467    REAL(wp) ::  pt     !< temporary scalar user for calculating density
468    REAL(wp) ::  pt1    !< temporary scalar user for calculating density
469    REAL(wp) ::  pt2    !< temporary scalar user for calculating density
470    REAL(wp) ::  pt3    !< temporary scalar user for calculating density
471    REAL(wp) ::  pt4    !< temporary scalar user for calculating density
472    REAL(wp) ::  sa     !< temporary scalar user for calculating density
473    REAL(wp) ::  sa15   !< temporary scalar user for calculating density
474    REAL(wp) ::  sa2    !< temporary scalar user for calculating density
475
476!
477!-- Pressure is needed in dbar
478    p1 = p  * 1.0E-4_wp
479    p2 = p1 * p1
480    p3 = p2 * p1
481
482!
483!-- Temperature needed in degree Celsius
484    pt1 = pt - 273.15_wp
485    pt2 = pt1 * pt1
486    pt3 = pt1 * pt2
487    pt4 = pt2 * pt2
488
489    sa15 = sa * SQRT( sa )
490    sa2  = sa * sa
491
492
493    eqn_state_seawater_func =                                                  &
494         ( nom(1)        + nom(2)*pt1       + nom(3)*pt2    + nom(4)*pt3     + &
495           nom(5)*sa     + nom(6)*sa*pt1    + nom(7)*sa2    + nom(8)*p1      + &
496           nom(9)*p1*pt2 + nom(10)*p1*sa    + nom(11)*p2    + nom(12)*p2*pt2   &
497         ) /                                                                   &
498         ( den(1)        + den(2)*pt1       + den(3)*pt2    + den(4)*pt3     + &
499           den(5)*pt4    + den(6)*sa        + den(7)*sa*pt1 + den(8)*sa*pt3  + &
500           den(9)*sa15   + den(10)*sa15*pt2 + den(11)*p1    + den(12)*p2*pt3 + &
501           den(13)*p3*pt1                                                      &
502         )
503
504
505 END FUNCTION eqn_state_seawater_func
506
507
508!------------------------------------------------------------------------------!
509! Description:
510! ------------
511!> Reads the ocean parameters namelist
512!------------------------------------------------------------------------------!
513 SUBROUTINE ocean_parin
514
515    IMPLICIT NONE
516
517    CHARACTER (LEN=80) ::  line  !< dummy string that contains the current line of the parameter file
518
519
520    NAMELIST /ocean_parameters/  bc_sa_t, bottom_salinityflux, salinity,       &
521             sa_surface, sa_vertical_gradient, sa_vertical_gradient_level,     &
522             stokes_waveheight, stokes_wavelength, surface_cooling_spinup_time,&
523             top_salinityflux, wall_salinityflux, wave_breaking
524
525!
526!-- Try to find the namelist
527    REWIND ( 11 )
528    line = ' '
529    DO WHILE ( INDEX( line, '&ocean_parameters' ) == 0 )
530       READ ( 11, '(A)', END=12 )  line
531    ENDDO
532    BACKSPACE ( 11 )
533
534!
535!-- Read namelist
536    READ ( 11, ocean_parameters, ERR = 10 )
537!
538!-- Set switch that enables PALM's ocean mode
539    ocean_mode = .TRUE.
540
541    GOTO 12
542
543 10 BACKSPACE( 11 )
544    READ( 11 , '(A)') line
545    CALL parin_fail_message( 'ocean_parameters', line )
546
547 12 CONTINUE
548
549 END SUBROUTINE ocean_parin
550
551!------------------------------------------------------------------------------!
552! Description:
553! ------------
554!> Check parameters routine for the ocean mode
555!------------------------------------------------------------------------------!
556 SUBROUTINE ocean_check_parameters
557
558    USE control_parameters,                                                    &
559        ONLY:  coupling_char, coupling_mode, initializing_actions,             &
560               message_string, use_top_fluxes
561
562    USE pmc_interface,                                                         &
563        ONLY:  nested_run
564
565    IMPLICIT NONE
566
567
568!
569!-- Check for invalid combinations
570    IF ( nested_run )  THEN
571       message_string = 'ocean mode not allowed for nesting'
572       CALL message( 'ocean_check_parameters', 'PA0510', 1, 2, 0, 6, 0 )
573    ENDIF
574
575    IF ( TRIM( initializing_actions ) == 'cyclic_fill' )  THEN
576       message_string = 'ocean mode does not allow cyclic-fill initialization'
577       CALL message( 'ocean_check_parameters', 'PA0511', 1, 2, 0, 6, 0 )
578    ENDIF
579
580!
581!-- Check ocean setting
582    IF ( TRIM( coupling_mode ) == 'uncoupled'  .AND.                           &
583         TRIM( coupling_char ) == '_O' .AND.                                   &
584         .NOT. ocean_mode )  THEN
585
586!
587!--    Check whether an (uncoupled) atmospheric run has been declared as an
588!--    ocean run (this setting is done via palmrun-option -y)
589       message_string = 'ocean mode does not allow coupling_char = "' //       &
590                        TRIM( coupling_char ) // '" set by palmrun-option "-y"'
591       CALL message( 'ocean_check_parameters', 'PA0317', 1, 2, 0, 6, 0 )
592
593    ENDIF
594
595!
596!-- Ocean version must use flux boundary conditions at the top
597    IF ( .NOT. use_top_fluxes )  THEN
598       message_string = 'use_top_fluxes must be .TRUE. in ocean mode'
599       CALL message( 'ocean_check_parameters', 'PA0042', 1, 2, 0, 6, 0 )
600    ENDIF
601
602!
603!-- Boundary conditions for salinity
604    IF ( bc_sa_t == 'dirichlet' )  THEN
605       ibc_sa_t = 0
606    ELSEIF ( bc_sa_t == 'neumann' )  THEN
607       ibc_sa_t = 1
608    ELSE
609       message_string = 'unknown boundary condition: bc_sa_t = "' //           &
610                        TRIM( bc_sa_t ) // '"'
611       CALL message( 'ocean_check_parameters', 'PA0068', 1, 2, 0, 6, 0 )
612    ENDIF
613
614    IF ( top_salinityflux == 9999999.9_wp )  constant_top_salinityflux = .FALSE.
615
616    IF ( .NOT. salinity )  THEN
617       IF ( ( bottom_salinityflux /= 0.0_wp  .AND.                             &
618              bottom_salinityflux /= 9999999.9_wp )  .OR.                      &
619            ( top_salinityflux /= 0.0_wp     .AND.                             &
620              top_salinityflux /= 9999999.9_wp ) )                             &
621       THEN
622          message_string = 'salinityflux must not be set for ocean run ' //    &
623                           'without salinity'
624          CALL message( 'ocean_check_parameters', 'PA0509', 1, 2, 0, 6, 0 )
625       ENDIF
626    ENDIF
627
628    IF ( ibc_sa_t == 1  .AND.  top_salinityflux == 9999999.9_wp )  THEN
629       message_string = 'boundary condition: bc_sa_t = "' //                   &
630                        TRIM( bc_sa_t ) // '" requires to set top_salinityflux'
631       CALL message( 'ocean_check_parameters', 'PA0069', 1, 2, 0, 6, 0 )
632    ENDIF
633
634!
635!-- A fixed salinity at the top implies Dirichlet boundary condition for
636!-- salinity. In this case specification of a constant salinity flux is
637!-- forbidden.
638    IF ( ibc_sa_t == 0  .AND.  constant_top_salinityflux  .AND.                &
639         top_salinityflux /= 0.0_wp )  THEN
640       message_string = 'boundary condition: bc_sa_t = "' //                   &
641                        TRIM( bc_sa_t ) // '" is not allowed with ' //         &
642                        'top_salinityflux /= 0.0'
643       CALL message( 'ocean_check_parameters', 'PA0070', 1, 2, 0, 6, 0 )
644    ENDIF
645
646!
647!-- Check if Stokes force is to be used
648    IF ( stokes_waveheight /= 0.0_wp  .AND.  stokes_wavelength /= 0.0_wp )  THEN
649       stokes_force = .TRUE.
650    ELSE
651       IF ( ( stokes_waveheight <= 0.0_wp .AND. stokes_wavelength > 0.0_wp ) &
652            .OR.                                                               &
653            ( stokes_waveheight > 0.0_wp .AND. stokes_wavelength <= 0.0_wp ) &
654            .OR.                                                               &
655            ( stokes_waveheight < 0.0_wp .AND. stokes_wavelength < 0.0_wp  ) ) &
656       THEN
657          message_string = 'wrong settings for stokes_wavelength and/or ' //   &
658                           'stokes_waveheight'
659          CALL message( 'ocean_check_parameters', 'PA0460', 1, 2, 0, 6, 0 )
660       ENDIF
661    ENDIF
662
663 END SUBROUTINE ocean_check_parameters
664
665
666!------------------------------------------------------------------------------!
667! Description:
668! ------------
669!> Check data output.
670!------------------------------------------------------------------------------!
671 SUBROUTINE ocean_check_data_output( var, unit )
672 
673    IMPLICIT NONE
674
675    CHARACTER (LEN=*) ::  unit     !< unit of output variable
676    CHARACTER (LEN=*) ::  var      !< name of output variable
677
678
679    SELECT CASE ( TRIM( var ) )
680
681       CASE ( 'rho_sea_water' )
682          unit = 'kg/m3'
683
684       CASE ( 'sa' )
685          unit = 'psu'
686
687       CASE DEFAULT
688          unit = 'illegal'
689
690    END SELECT
691
692 END SUBROUTINE ocean_check_data_output
693
694
695!------------------------------------------------------------------------------!
696! Description:
697! ------------
698!> Check data output of profiles
699!------------------------------------------------------------------------------!
700 SUBROUTINE ocean_check_data_output_pr( variable, var_count, unit, dopr_unit )
701
702    USE arrays_3d,                                                             &
703        ONLY:  zu, zw
704
705    USE control_parameters,                                                    &
706        ONLY:  data_output_pr
707
708    USE indices
709
710    USE profil_parameter
711
712    USE statistics
713
714    IMPLICIT NONE
715
716    CHARACTER (LEN=*) ::  unit      !<
717    CHARACTER (LEN=*) ::  variable  !<
718    CHARACTER (LEN=*) ::  dopr_unit !< local value of dopr_unit
719
720    INTEGER(iwp) ::  var_count     !<
721
722    SELECT CASE ( TRIM( variable ) )
723
724       CASE ( 'prho' )
725          dopr_index(var_count) = 71
726          dopr_unit             = 'kg/m3'
727          hom(:,2,71,:) = SPREAD( zu, 2, statistic_regions+1 )
728          unit = dopr_unit
729
730       CASE ( 'rho_sea_water' )
731          dopr_index(var_count) = 64
732          dopr_unit             = 'kg/m3'
733          hom(:,2,64,:) = SPREAD( zu, 2, statistic_regions+1 )
734          IF ( data_output_pr(var_count)(1:1) == '#' )  THEN
735             dopr_initial_index(var_count) = 77
736             hom(:,2,77,:)             = SPREAD( zu, 2, statistic_regions+1 )
737             hom(nzb,2,77,:)           = 0.0_wp    ! because zu(nzb) is negative
738             data_output_pr(var_count) = data_output_pr(var_count)(2:)
739          ENDIF
740          unit = dopr_unit
741
742       CASE ( 'sa', '#sa' )
743          dopr_index(var_count) = 23
744          dopr_unit             = 'psu'
745          hom(:,2,23,:) = SPREAD( zu, 2, statistic_regions+1 )
746          IF ( data_output_pr(var_count)(1:1) == '#' )  THEN
747             dopr_initial_index(var_count) = 26
748             hom(:,2,26,:)             = SPREAD( zu, 2, statistic_regions+1 )
749             hom(nzb,2,26,:)           = 0.0_wp    ! because zu(nzb) is negative
750             data_output_pr(var_count) = data_output_pr(var_count)(2:)
751          ENDIF
752          unit = dopr_unit
753
754       CASE ( 'w"sa"' )
755          dopr_index(var_count) = 65
756          dopr_unit             = 'psu m/s'
757          hom(:,2,65,:) = SPREAD( zw, 2, statistic_regions+1 )
758          unit = dopr_unit
759
760       CASE ( 'w*sa*' )
761          dopr_index(var_count) = 66
762          dopr_unit             = 'psu m/s'
763          hom(:,2,66,:) = SPREAD( zw, 2, statistic_regions+1 )
764          unit = dopr_unit
765
766       CASE ( 'wsa' )
767          dopr_index(var_count) = 67
768          dopr_unit             = 'psu m/s'
769          hom(:,2,67,:) = SPREAD( zw, 2, statistic_regions+1 )
770          unit = dopr_unit
771
772       CASE DEFAULT
773          unit = 'illegal'
774
775    END SELECT
776
777
778 END SUBROUTINE ocean_check_data_output_pr
779
780
781!------------------------------------------------------------------------------!
782! Description:
783! ------------
784!> Define appropriate grid for netcdf variables.
785!> It is called out from subroutine netcdf.
786!------------------------------------------------------------------------------!
787 SUBROUTINE ocean_define_netcdf_grid( var, found, grid_x, grid_y, grid_z )
788   
789    IMPLICIT NONE
790
791    CHARACTER (LEN=*), INTENT(OUT) ::  grid_x   !< x grid of output variable
792    CHARACTER (LEN=*), INTENT(OUT) ::  grid_y   !< y grid of output variable
793    CHARACTER (LEN=*), INTENT(OUT) ::  grid_z   !< z grid of output variable
794    CHARACTER (LEN=*), INTENT(IN)  ::  var      !< name of output variable
795
796    LOGICAL, INTENT(OUT) ::  found   !< flag if output variable is found
797
798    found  = .TRUE.
799
800!
801!-- Check for the grid
802    SELECT CASE ( TRIM( var ) )
803
804       CASE ( 'rho_sea_water', 'rho_sea_water_xy', 'rho_sea_water_xz', &
805              'rho_sea_water_yz', 'sa', 'sa_xy', 'sa_xz', 'sa_yz' )
806          grid_x = 'x'
807          grid_y = 'y'
808          grid_z = 'zu'
809
810       CASE DEFAULT
811          found  = .FALSE.
812          grid_x = 'none'
813          grid_y = 'none'
814          grid_z = 'none'
815
816    END SELECT
817
818 END SUBROUTINE ocean_define_netcdf_grid
819
820
821!------------------------------------------------------------------------------!
822! Description:
823! ------------
824!> Average 3D data.
825!------------------------------------------------------------------------------!
826 SUBROUTINE ocean_3d_data_averaging( mode, variable )
827 
828
829    USE arrays_3d,                                                             &
830        ONLY:  rho_ocean, sa
831
832    USE averaging,                                                             &
833        ONLY:  rho_ocean_av, sa_av
834
835    USE control_parameters,                                                    &
836        ONLY:  average_count_3d
837
838    USE indices,                                                               &
839        ONLY:  nxlg, nxrg, nyng, nysg, nzb, nzt
840
841    IMPLICIT NONE
842
843    CHARACTER (LEN=*) ::  mode       !< flag defining mode 'allocate', 'sum' or 'average'
844    CHARACTER (LEN=*) ::  variable   !< name of variable
845
846    INTEGER(iwp) ::  i   !< loop index
847    INTEGER(iwp) ::  j   !< loop index
848    INTEGER(iwp) ::  k   !< loop index
849
850    IF ( mode == 'allocate' )  THEN
851
852       SELECT CASE ( TRIM( variable ) )
853
854          CASE ( 'rho_sea_water' )
855             IF ( .NOT. ALLOCATED( rho_ocean_av ) )  THEN
856                ALLOCATE( rho_ocean_av(nzb:nzt+1,nysg:nyng,nxlg:nxrg) )
857             ENDIF
858             rho_ocean_av = 0.0_wp
859
860          CASE ( 'sa' )
861             IF ( .NOT. ALLOCATED( sa_av ) )  THEN
862                ALLOCATE( sa_av(nzb:nzt+1,nysg:nyng,nxlg:nxrg) )
863             ENDIF
864             sa_av = 0.0_wp
865
866          CASE DEFAULT
867             CONTINUE
868
869       END SELECT
870
871    ELSEIF ( mode == 'sum' )  THEN
872
873       SELECT CASE ( TRIM( variable ) )
874
875          CASE ( 'rho_sea_water' )
876             IF ( ALLOCATED( rho_ocean_av ) )  THEN
877                DO  i = nxlg, nxrg
878                   DO  j = nysg, nyng
879                      DO  k = nzb, nzt+1
880                         rho_ocean_av(k,j,i) = rho_ocean_av(k,j,i) +           &
881                                               rho_ocean(k,j,i)
882                      ENDDO
883                   ENDDO
884                ENDDO
885             ENDIF
886
887          CASE ( 'sa' )
888             IF ( ALLOCATED( sa_av ) )  THEN
889                DO  i = nxlg, nxrg
890                   DO  j = nysg, nyng
891                      DO  k = nzb, nzt+1
892                         sa_av(k,j,i) = sa_av(k,j,i) + sa(k,j,i)
893                      ENDDO
894                   ENDDO
895                ENDDO
896             ENDIF
897
898          CASE DEFAULT
899             CONTINUE
900
901       END SELECT
902
903    ELSEIF ( mode == 'average' )  THEN
904
905       SELECT CASE ( TRIM( variable ) )
906
907          CASE ( 'rho_sea_water' )
908             IF ( ALLOCATED( rho_ocean_av ) ) THEN
909                DO  i = nxlg, nxrg
910                   DO  j = nysg, nyng
911                      DO  k = nzb, nzt+1
912                         rho_ocean_av(k,j,i) = rho_ocean_av(k,j,i) /           &
913                                               REAL( average_count_3d, KIND=wp )
914                      ENDDO
915                   ENDDO
916                ENDDO
917             ENDIF
918
919          CASE ( 'sa' )
920             IF ( ALLOCATED( sa_av ) ) THEN
921                DO  i = nxlg, nxrg
922                   DO  j = nysg, nyng
923                      DO  k = nzb, nzt+1
924                         sa_av(k,j,i) = sa_av(k,j,i) /                         &
925                                        REAL( average_count_3d, KIND=wp )
926                      ENDDO
927                   ENDDO
928                ENDDO
929             ENDIF
930
931       END SELECT
932
933    ENDIF
934
935 END SUBROUTINE ocean_3d_data_averaging
936
937
938!------------------------------------------------------------------------------!
939! Description:
940! ------------
941!> Define 2D output variables.
942!------------------------------------------------------------------------------!
943 SUBROUTINE ocean_data_output_2d( av, variable, found, grid, mode, local_pf,   &
944                                  nzb_do, nzt_do )
945 
946    USE arrays_3d,                                                             &
947        ONLY:  rho_ocean, sa
948
949    USE averaging,                                                             &
950        ONLY:  rho_ocean_av, sa_av
951
952    USE indices,                                                               &
953        ONLY: nxl, nxlg, nxr, nxrg, nyn, nyng, nys, nysg, nzb, nzt,            &
954              wall_flags_0
955
956    IMPLICIT NONE
957
958    CHARACTER (LEN=*) ::  grid       !< name of vertical grid
959    CHARACTER (LEN=*) ::  mode       !< either 'xy', 'xz' or 'yz'
960    CHARACTER (LEN=*) ::  variable   !< name of variable
961
962    INTEGER(iwp) ::  av        !< flag for (non-)average output
963    INTEGER(iwp) ::  flag_nr   !< number of masking flag
964    INTEGER(iwp) ::  i         !< loop index
965    INTEGER(iwp) ::  j         !< loop index
966    INTEGER(iwp) ::  k         !< loop index
967    INTEGER(iwp) ::  nzb_do    !< vertical output index (bottom)
968    INTEGER(iwp) ::  nzt_do    !< vertical output index (top)
969
970    LOGICAL ::  found   !< flag if output variable is found
971    LOGICAL ::  resorted  !< flag if output is already resorted
972
973    REAL(wp) ::  fill_value = -999.0_wp  !< value for the _FillValue attribute
974
975    REAL(wp), DIMENSION(nxl:nxr,nys:nyn,nzb_do:nzt_do) ::  local_pf !< local
976       !< array to which output data is resorted to
977
978    REAL(wp), DIMENSION(:,:,:), POINTER ::  to_be_resorted  !< points to selected output variable
979   
980    found = .TRUE.
981    resorted = .FALSE.
982!
983!-- Set masking flag for topography for not resorted arrays
984    flag_nr = 0
985
986    SELECT CASE ( TRIM( variable ) )
987
988       CASE ( 'rho_sea_water_xy', 'rho_sea_water_xz', 'rho_sea_water_yz' )
989          IF ( av == 0 )  THEN
990             to_be_resorted => rho_ocean
991          ELSE
992             IF ( .NOT. ALLOCATED( rho_ocean_av ) ) THEN
993                ALLOCATE( rho_ocean_av(nzb:nzt+1,nysg:nyng,nxlg:nxrg) )
994                rho_ocean_av = REAL( fill_value, KIND = wp )
995             ENDIF
996             to_be_resorted => rho_ocean_av
997          ENDIF
998
999       CASE ( 'sa_xy', 'sa_xz', 'sa_yz' )
1000          IF ( av == 0 )  THEN
1001             to_be_resorted => sa
1002          ELSE
1003             IF ( .NOT. ALLOCATED( sa_av ) ) THEN
1004                ALLOCATE( sa_av(nzb:nzt+1,nysg:nyng,nxlg:nxrg) )
1005                sa_av = REAL( fill_value, KIND = wp )
1006             ENDIF
1007             to_be_resorted => sa_av
1008          ENDIF
1009          IF ( mode == 'xy' ) grid = 'zu'
1010
1011       CASE DEFAULT
1012          found = .FALSE.
1013          grid  = 'none'
1014
1015    END SELECT
1016
1017    IF ( found .AND. .NOT. resorted )  THEN
1018       DO  i = nxl, nxr
1019          DO  j = nys, nyn
1020             DO  k = nzb_do, nzt_do
1021                local_pf(i,j,k) = MERGE( to_be_resorted(k,j,i),                &
1022                                         REAL( fill_value, KIND = wp ),        &
1023                                         BTEST( wall_flags_0(k,j,i), flag_nr ) )
1024             ENDDO
1025          ENDDO
1026       ENDDO
1027       resorted = .TRUE.
1028    ENDIF
1029 
1030 END SUBROUTINE ocean_data_output_2d
1031
1032 
1033!------------------------------------------------------------------------------!
1034! Description:
1035! ------------
1036!> Define 3D output variables.
1037!------------------------------------------------------------------------------!
1038 SUBROUTINE ocean_data_output_3d( av, variable, found, local_pf, nzb_do, nzt_do )
1039 
1040
1041    USE arrays_3d,                                                             &
1042        ONLY:  rho_ocean, sa
1043
1044    USE averaging,                                                             &
1045        ONLY:  rho_ocean_av, sa_av
1046
1047    USE indices,                                                               &
1048        ONLY:  nxl, nxlg, nxr, nxrg, nyn, nyng, nys, nysg, nzb, nzt,           &
1049               wall_flags_0
1050
1051    IMPLICIT NONE
1052
1053    CHARACTER (LEN=*) ::  variable   !< name of variable
1054
1055    INTEGER(iwp) ::  av        !< flag for (non-)average output
1056    INTEGER(iwp) ::  flag_nr   !< number of masking flag
1057    INTEGER(iwp) ::  i         !< loop index
1058    INTEGER(iwp) ::  j         !< loop index
1059    INTEGER(iwp) ::  k         !< loop index
1060    INTEGER(iwp) ::  nzb_do    !< lower limit of the data output (usually 0)
1061    INTEGER(iwp) ::  nzt_do    !< vertical upper limit of the data output (usually nz_do3d)
1062
1063    LOGICAL ::  found     !< flag if output variable is found
1064    LOGICAL ::  resorted  !< flag if output is already resorted
1065
1066    REAL(wp) ::  fill_value = -999.0_wp  !< value for the _FillValue attribute
1067
1068    REAL(sp), DIMENSION(nxl:nxr,nys:nyn,nzb_do:nzt_do) ::  local_pf   !< local
1069                                  !< array to which output data is resorted to
1070
1071    REAL(wp), DIMENSION(:,:,:), POINTER ::  to_be_resorted  !< points to selected output variable
1072
1073    found = .TRUE.
1074    resorted = .FALSE.
1075!
1076!-- Set masking flag for topography for not resorted arrays
1077    flag_nr = 0
1078
1079    SELECT CASE ( TRIM( variable ) )
1080
1081       CASE ( 'rho_sea_water' )
1082          IF ( av == 0 )  THEN
1083             to_be_resorted => rho_ocean
1084          ELSE
1085             IF ( .NOT. ALLOCATED( rho_ocean_av ) ) THEN
1086                ALLOCATE( rho_ocean_av(nzb:nzt+1,nysg:nyng,nxlg:nxrg) )
1087                rho_ocean_av = REAL( fill_value, KIND = wp )
1088             ENDIF
1089             to_be_resorted => rho_ocean_av
1090          ENDIF
1091
1092       CASE ( 'sa' )
1093          IF ( av == 0 )  THEN
1094             to_be_resorted => sa
1095          ELSE
1096             IF ( .NOT. ALLOCATED( sa_av ) ) THEN
1097                ALLOCATE( sa_av(nzb:nzt+1,nysg:nyng,nxlg:nxrg) )
1098                sa_av = REAL( fill_value, KIND = wp )
1099             ENDIF
1100             to_be_resorted => sa_av
1101          ENDIF
1102
1103       CASE DEFAULT
1104          found = .FALSE.
1105
1106    END SELECT
1107
1108
1109    IF ( found  .AND.  .NOT. resorted )  THEN
1110       DO  i = nxl, nxr
1111          DO  j = nys, nyn
1112             DO  k = nzb_do, nzt_do
1113                local_pf(i,j,k) = MERGE( to_be_resorted(k,j,i),                &
1114                                         REAL( fill_value, KIND = wp ),        &
1115                                         BTEST( wall_flags_0(k,j,i), flag_nr ) )
1116             ENDDO
1117          ENDDO
1118       ENDDO
1119       resorted = .TRUE.
1120    ENDIF
1121
1122 END SUBROUTINE ocean_data_output_3d
1123
1124
1125!------------------------------------------------------------------------------!
1126! Description:
1127! ------------
1128!> Header output for ocean parameters
1129!------------------------------------------------------------------------------!
1130 SUBROUTINE ocean_header( io )
1131
1132
1133    IMPLICIT NONE
1134
1135    INTEGER(iwp), INTENT(IN) ::  io   !< Unit of the output file
1136
1137!
1138!-- Write ocean header
1139    WRITE( io, 1 )
1140    IF ( stokes_force  )  WRITE( io, 2 )  stokes_waveheight, stokes_wavelength
1141    IF ( wave_breaking )  THEN
1142       WRITE( io, 3 )  alpha_wave_breaking, timescale_wave_breaking
1143    ENDIF
1144    IF ( .NOT. salinity )  WRITE( io, 4 )
1145    IF ( surface_cooling_spinup_time /= 999999.9_wp )  THEN
1146       WRITE( io, 5 )  surface_cooling_spinup_time
1147    ENDIF
1148
11491   FORMAT (//' Ocean settings:'/                                              &
1150              ' ------------------------------------------'/)
11512   FORMAT ('    --> Craik-Leibovich vortex force and Stokes drift switched',  &
1152                     ' on'/                                                    &
1153            '        waveheight: ',F4.1,' m   wavelength: ',F6.1,' m')
11543   FORMAT ('    --> wave breaking generated turbulence switched on'/          &
1155            '        alpha:    ',F4.1/                                         &
1156            '        timescale:',F5.1,' s')
11574   FORMAT ('    --> prognostic salinity equation is switched off' )
11585   FORMAT ('    --> surface heat flux is switched off after ',F8.1,' s')
1159
1160 END SUBROUTINE ocean_header
1161
1162
1163!------------------------------------------------------------------------------!
1164! Description:
1165! ------------
1166!> Allocate arrays and assign pointers.
1167!------------------------------------------------------------------------------!
1168 SUBROUTINE ocean_init_arrays
1169
1170    USE indices,                                                               &
1171        ONLY:  nxlg, nxrg, nyng, nysg, nzb, nzt
1172
1173    IMPLICIT NONE
1174
1175    ALLOCATE( prho_1(nzb:nzt+1,nysg:nyng,nxlg:nxrg),                           &
1176              rho_1(nzb:nzt+1,nysg:nyng,nxlg:nxrg),                            &
1177              sa_1(nzb:nzt+1,nysg:nyng,nxlg:nxrg),                             &
1178              sa_3(nzb:nzt+1,nysg:nyng,nxlg:nxrg) )
1179
1180    IF (  salinity )  THEN
1181       ALLOCATE( sa_2(nzb:nzt+1,nysg:nyng,nxlg:nxrg) )
1182    ENDIF
1183
1184    prho => prho_1
1185    rho_ocean  => rho_1  ! routines calc_mean_profile and diffusion_e require
1186                         ! density to be a pointer
1187
1188!
1189!-- Initial assignment of pointers
1190    IF ( salinity )  THEN
1191       sa => sa_1;  sa_p => sa_2;  tsa_m => sa_3
1192    ELSE
1193       sa => sa_1;  sa_p => sa_1;  tsa_m => sa_3
1194    ENDIF
1195
1196 END SUBROUTINE ocean_init_arrays
1197
1198
1199!------------------------------------------------------------------------------!
1200! Description:
1201! ------------
1202!> Initialization of quantities needed for the ocean mode
1203!------------------------------------------------------------------------------!
1204 SUBROUTINE ocean_init
1205
1206
1207    USE arrays_3d,                                                             &
1208        ONLY:  dzu, dzw, hyp, pt_init, ref_state, u_stokes_zu, u_stokes_zw,    &
1209               v_stokes_zu, v_stokes_zw, zu, zw
1210
1211    USE basic_constants_and_equations_mod,                                     &
1212        ONLY:  g
1213
1214    USE basic_constants_and_equations_mod,                                     &
1215        ONLY:  pi
1216
1217    USE control_parameters,                                                    &
1218        ONLY:  initializing_actions, molecular_viscosity, rho_surface,         &
1219               rho_reference, surface_pressure, top_momentumflux_u,            &
1220               top_momentumflux_v, use_single_reference_value
1221
1222    USE indices,                                                               &
1223        ONLY:  nxl, nxlg, nxrg, nyng, nys, nysg, nzb, nzt
1224
1225    USE kinds
1226
1227    USE pegrid,                                                                &
1228        ONLY:  myid
1229
1230    USE statistics,                                                            &
1231        ONLY:  hom, statistic_regions
1232
1233    IMPLICIT NONE
1234
1235    INTEGER(iwp) ::  i  !< loop index
1236    INTEGER(iwp) ::  j  !< loop index
1237    INTEGER(iwp) ::  k  !< loop index
1238    INTEGER(iwp) ::  n  !< loop index
1239
1240    REAL(wp) ::  alpha !< angle of surface stress
1241    REAL(wp) ::  dum   !< dummy argument
1242    REAL(wp) ::  pt_l  !< local scalar for pt used in equation of state function
1243    REAL(wp) ::  sa_l  !< local scalar for sa used in equation of state function
1244    REAL(wp) ::  velocity_amplitude  !< local scalar for amplitude of Stokes drift velocity
1245    REAL(wp) ::  x     !< temporary variable to store surface stress along x
1246    REAL(wp) ::  y     !< temporary variable to store surface stress along y
1247
1248    REAL(wp), DIMENSION(nzb:nzt+1) ::  rho_ocean_init  !< local array for initial density
1249
1250    ALLOCATE( hyp(nzb:nzt+1) )
1251
1252
1253!
1254!-- In case of no restart run, calculate the inital salinity profilevcusing the
1255!-- given salinity gradients
1256    IF ( TRIM( initializing_actions ) /= 'read_restart_data' )  THEN
1257
1258       sa_init = sa_surface
1259!
1260!--    Last arguments gives back the gradient at top level to be used as
1261!--    possible Neumann boundary condition. This is not realized for the ocean
1262!--    mode, therefore a dummy argument is used.
1263       IF ( salinity )  THEN
1264          CALL init_vertical_profiles( sa_vertical_gradient_level_ind,          &
1265                                       sa_vertical_gradient_level,              &
1266                                       sa_vertical_gradient, sa_init,           &
1267                                       sa_surface, dum )
1268       ENDIF
1269    ENDIF
1270
1271!
1272!-- Initialize required 3d-arrays
1273    IF ( TRIM( initializing_actions ) /= 'read_restart_data'  .AND.            &
1274         TRIM( initializing_actions ) /= 'cyclic_fill' )  THEN
1275!
1276!--    Initialization via computed 1D-model profiles
1277       IF ( INDEX( initializing_actions, 'set_constant_profiles' ) /= 0 )  THEN
1278
1279          DO  i = nxlg, nxrg
1280             DO  j = nysg, nyng
1281                sa(:,j,i) = sa_init
1282             ENDDO
1283          ENDDO
1284
1285       ENDIF
1286!
1287!--    Store initial profiles for output purposes etc.
1288!--    Store initial salinity profile
1289       hom(:,1,26,:)  = SPREAD( sa(:,nys,nxl), 2, statistic_regions+1 )
1290!
1291!--    Initialize old and new time levels.
1292       tsa_m = 0.0_wp
1293       sa_p  = sa
1294
1295    ELSEIF ( TRIM( initializing_actions ) == 'read_restart_data' )  THEN
1296
1297!
1298!--    Initialize new time levels (only done in order to set boundary values
1299!--    including ghost points)
1300       sa_p = sa
1301!
1302!--    Allthough tendency arrays are set in prognostic_equations, they have
1303!--    have to be predefined here because they are used (but multiplied with 0)
1304!--    there before they are set.
1305       tsa_m = 0.0_wp
1306
1307    ENDIF
1308
1309!
1310!-- Set water density near the ocean surface
1311    rho_surface = 1027.62_wp
1312
1313!
1314!-- Set kinematic viscosity to sea water at 20C.
1315!-- This changes the default value that is given for air!
1316    molecular_viscosity = 1.05E-6_wp
1317
1318!
1319!-- Change sign of buoyancy/stability terms because density gradient is used
1320!-- instead of the potential temperature gradient to calculate the buoyancy
1321    atmos_ocean_sign = -1.0_wp
1322
1323!
1324!-- Calculate initial vertical profile of hydrostatic pressure (in Pa)
1325!-- and the reference density (used later in buoyancy term)
1326!-- First step: Calculate pressure using reference density
1327    hyp(nzt+1) = surface_pressure * 100.0_wp
1328    hyp(nzt)   = hyp(nzt+1) + rho_surface * g * 0.5_wp * dzu(nzt+1)
1329    rho_ocean_init(nzt)   = rho_surface
1330    rho_ocean_init(nzt+1) = rho_surface  ! only required for output
1331
1332    DO  k = nzt-1, 1, -1
1333       hyp(k) = hyp(k+1) + rho_surface * g * dzu(k)
1334    ENDDO
1335    hyp(0) = hyp(1) + rho_surface * g * dzu(1)
1336
1337!
1338!-- Second step: Iteratively calculate in situ density (based on presssure)
1339!-- and pressure (based on in situ density)
1340    DO  n = 1, 5
1341
1342       rho_reference = rho_surface * 0.5_wp * dzu(nzt+1)
1343
1344       DO  k = nzt, 0, -1
1345
1346          sa_l = 0.5_wp * ( sa_init(k) + sa_init(k+1) )
1347          pt_l = 0.5_wp * ( pt_init(k) + pt_init(k+1) )
1348
1349          rho_ocean_init(k) = eqn_state_seawater_func( hyp(k), pt_l, sa_l )
1350
1351          rho_reference = rho_reference + rho_ocean_init(k) * dzu(k+1)
1352
1353       ENDDO
1354
1355       rho_reference = rho_reference / ( zw(nzt) - zu(nzb) )
1356
1357       hyp(nzt) = hyp(nzt+1) + rho_surface * g * 0.5_wp * dzu(nzt+1)
1358       DO  k = nzt-1, 0, -1
1359          hyp(k) = hyp(k+1) + g * 0.5_wp * ( rho_ocean_init(k)                 &
1360                                           + rho_ocean_init(k+1) ) * dzu(k+1)
1361       ENDDO
1362
1363    ENDDO
1364
1365!
1366!-- Calculate the reference potential density
1367    prho_reference = 0.0_wp
1368    DO  k = 0, nzt
1369
1370       sa_l = 0.5_wp * ( sa_init(k) + sa_init(k+1) )
1371       pt_l = 0.5_wp * ( pt_init(k) + pt_init(k+1) )
1372
1373       prho_reference = prho_reference + dzu(k+1) * &
1374                        eqn_state_seawater_func( 0.0_wp, pt_l, sa_l )
1375
1376    ENDDO
1377
1378    prho_reference = prho_reference / ( zu(nzt) - zu(nzb) )
1379
1380!
1381!-- Calculate the 3d array of initial in situ and potential density,
1382!-- based on the initial temperature and salinity profile
1383    CALL eqn_state_seawater
1384
1385!
1386!-- Store initial density profile
1387    hom(:,1,77,:)  = SPREAD( rho_ocean_init(:), 2, statistic_regions+1 )
1388
1389!
1390!-- Set the reference state to be used in the buoyancy terms
1391    IF ( use_single_reference_value )  THEN
1392       ref_state(:) = rho_reference
1393    ELSE
1394       ref_state(:) = rho_ocean_init(:)
1395    ENDIF
1396
1397!
1398!-- Calculate the Stokes drift velocity profile
1399    IF ( stokes_force )  THEN
1400
1401!
1402!--    First, calculate angle of surface stress
1403       x = -top_momentumflux_u
1404       y = -top_momentumflux_v
1405       IF ( x == 0.0_wp )  THEN
1406          IF ( y > 0.0_wp )  THEN
1407             alpha = pi / 2.0_wp
1408          ELSEIF ( y < 0.0_wp )  THEN
1409             alpha = 3.0_wp * pi / 2.0_wp
1410          ENDIF
1411       ELSE
1412          IF ( x < 0.0_wp )  THEN
1413             alpha = ATAN( y / x ) + pi
1414          ELSE
1415             IF ( y < 0.0_wp )  THEN
1416                alpha = ATAN( y / x ) + 2.0_wp * pi
1417             ELSE
1418                alpha = ATAN( y / x )
1419             ENDIF
1420          ENDIF
1421       ENDIF
1422
1423       velocity_amplitude = ( pi * stokes_waveheight / stokes_wavelength )**2 *&
1424                            SQRT( g * stokes_wavelength / ( 2.0_wp * pi ) )
1425
1426       DO  k = nzb, nzt
1427          u_stokes_zu(k) = velocity_amplitude * COS( alpha ) *                 &
1428                           EXP( 4.0_wp * pi * zu(k) / stokes_wavelength )
1429          u_stokes_zw(k) = velocity_amplitude * COS( alpha ) *                 &
1430                           EXP( 4.0_wp * pi * zw(k) / stokes_wavelength )
1431          v_stokes_zu(k) = velocity_amplitude * SIN( alpha ) *                 &
1432                           EXP( 4.0_wp * pi * zu(k) / stokes_wavelength )
1433          v_stokes_zw(k) = velocity_amplitude * SIN( alpha ) *                 &
1434                           EXP( 4.0_wp * pi * zw(k) / stokes_wavelength )
1435       ENDDO
1436       u_stokes_zu(nzt+1) = u_stokes_zw(nzt) ! because zu(nzt+1) changes the sign
1437       u_stokes_zw(nzt+1) = u_stokes_zw(nzt) ! because zw(nzt+1) changes the sign
1438       v_stokes_zu(nzt+1) = v_stokes_zw(nzt) ! because zu(nzt+1) changes the sign
1439       v_stokes_zw(nzt+1) = v_stokes_zw(nzt) ! because zw(nzt+1) changes the sign
1440
1441    ENDIF
1442
1443!
1444!-- Wave breaking effects
1445    IF ( wave_breaking )  THEN
1446!
1447!--    Calculate friction velocity at ocean surface
1448       u_star_wave_breaking = SQRT( SQRT( top_momentumflux_u**2 +              &
1449                                          top_momentumflux_v**2 ) )
1450!
1451!--    Set the time scale of random forcing. The vertical grid spacing at the
1452!--    ocean surface is assumed as the length scale of turbulence.
1453!--    Formula follows Noh et al. (2004), JPO
1454       timescale_wave_breaking = 0.1_wp * dzw(nzt) / alpha_wave_breaking /     &
1455                                 u_star_wave_breaking
1456!
1457!--    Set random number seeds differently on the processor cores in order to
1458!--    create different random number sequences
1459       iran_ocean = iran_ocean + myid
1460    ENDIF
1461
1462 END SUBROUTINE ocean_init
1463
1464
1465!------------------------------------------------------------------------------!
1466! Description:
1467! ------------
1468!> Prognostic equation for salinity.
1469!> Vector-optimized version
1470!------------------------------------------------------------------------------!
1471 SUBROUTINE ocean_prognostic_equations
1472
1473    USE advec_s_bc_mod,                                                        &
1474        ONLY:  advec_s_bc
1475
1476    USE advec_s_pw_mod,                                                        &
1477        ONLY:  advec_s_pw
1478
1479    USE advec_s_up_mod,                                                        &
1480        ONLY:  advec_s_up
1481
1482    USE advec_ws,                                                              &
1483        ONLY:  advec_s_ws
1484
1485    USE arrays_3d,                                                             &
1486        ONLY:  rdf_sc, tend, tsa_m
1487
1488    USE control_parameters,                                                    &
1489        ONLY:  dt_3d, intermediate_timestep_count,                             &
1490               intermediate_timestep_count_max, scalar_advec, simulated_time,  &
1491               timestep_scheme, tsc, ws_scheme_sca
1492
1493    USE cpulog,                                                                &
1494        ONLY:  cpu_log, log_point
1495
1496    USE diffusion_s_mod,                                                       &
1497        ONLY:  diffusion_s
1498
1499    USE indices,                                                               &
1500        ONLY:  nxl, nxr, nyn, nys, nzb, nzt, wall_flags_0
1501
1502    USE surface_mod,                                                           &
1503        ONLY:  surf_def_v, surf_def_h, surf_lsm_h, surf_lsm_v, surf_usm_h,     &
1504               surf_usm_v
1505
1506    USE user_actions_mod,                                                      &
1507        ONLY:  user_actions
1508
1509    IMPLICIT NONE
1510
1511    INTEGER(iwp) ::  i       !< loop index
1512    INTEGER(iwp) ::  j       !< loop index
1513    INTEGER(iwp) ::  k       !< loop index
1514
1515    REAL(wp)     ::  sbt     !< weighting factor for sub-time step
1516
1517!
1518!-- Switch of the surface heat flux, if requested
1519    IF ( surface_cooling_spinup_time /= 999999.9_wp )  THEN
1520       IF ( .NOT. surface_cooling_switched_off  .AND.                          &
1521            simulated_time >= surface_cooling_spinup_time )  THEN
1522
1523          surf_def_h(2)%shf = 0.0_wp
1524          surface_cooling_switched_off = .TRUE.
1525
1526       ENDIF
1527    ENDIF
1528
1529!
1530!-- Compute prognostic equations for the ocean mode
1531!-- First, start with salinity
1532    IF ( salinity )  THEN
1533
1534       CALL cpu_log( log_point(37), 'sa-equation', 'start' )
1535
1536!
1537!--    sa-tendency terms with communication
1538       sbt = tsc(2)
1539       IF ( scalar_advec == 'bc-scheme' )  THEN
1540
1541          IF ( timestep_scheme(1:5) /= 'runge' )  THEN
1542!
1543!--          Bott-Chlond scheme always uses Euler time step. Thus:
1544             sbt = 1.0_wp
1545          ENDIF
1546          tend = 0.0_wp
1547          CALL advec_s_bc( sa, 'sa' )
1548
1549       ENDIF
1550
1551!
1552!--    sa-tendency terms with no communication
1553       IF ( scalar_advec /= 'bc-scheme' )  THEN
1554          tend = 0.0_wp
1555          IF ( timestep_scheme(1:5) == 'runge' )  THEN
1556             IF ( ws_scheme_sca )  THEN
1557                CALL advec_s_ws( sa, 'sa' )
1558             ELSE
1559                CALL advec_s_pw( sa )
1560             ENDIF
1561          ELSE
1562             CALL advec_s_up( sa )
1563          ENDIF
1564       ENDIF
1565
1566       CALL diffusion_s( sa,                                                   &
1567                         surf_def_h(0)%sasws, surf_def_h(1)%sasws,             &
1568                         surf_def_h(2)%sasws,                                  &
1569                         surf_lsm_h%sasws,    surf_usm_h%sasws,                &
1570                         surf_def_v(0)%sasws, surf_def_v(1)%sasws,             &
1571                         surf_def_v(2)%sasws, surf_def_v(3)%sasws,             &
1572                         surf_lsm_v(0)%sasws, surf_lsm_v(1)%sasws,             &
1573                         surf_lsm_v(2)%sasws, surf_lsm_v(3)%sasws,             &
1574                         surf_usm_v(0)%sasws, surf_usm_v(1)%sasws,             &
1575                         surf_usm_v(2)%sasws, surf_usm_v(3)%sasws )
1576
1577       CALL user_actions( 'sa-tendency' )
1578
1579!
1580!--    Prognostic equation for salinity
1581       DO  i = nxl, nxr
1582          DO  j = nys, nyn
1583             DO  k = nzb+1, nzt
1584                sa_p(k,j,i) = sa(k,j,i) + ( dt_3d * ( sbt * tend(k,j,i) +      &
1585                                                      tsc(3) * tsa_m(k,j,i) )  &
1586                                                  - tsc(5) * rdf_sc(k) *       &
1587                                                    ( sa(k,j,i) - sa_init(k) ) &
1588                                          )                                    &
1589                                            * MERGE( 1.0_wp, 0.0_wp,           &
1590                                               BTEST( wall_flags_0(k,j,i), 0 ) &
1591                                                   )
1592                IF ( sa_p(k,j,i) < 0.0_wp )  sa_p(k,j,i) = 0.1_wp * sa(k,j,i)
1593             ENDDO
1594          ENDDO
1595       ENDDO
1596
1597!
1598!--    Calculate tendencies for the next Runge-Kutta step
1599       IF ( timestep_scheme(1:5) == 'runge' )  THEN
1600          IF ( intermediate_timestep_count == 1 )  THEN
1601             DO  i = nxl, nxr
1602                DO  j = nys, nyn
1603                   DO  k = nzb+1, nzt
1604                      tsa_m(k,j,i) = tend(k,j,i)
1605                   ENDDO
1606                ENDDO
1607             ENDDO
1608          ELSEIF ( intermediate_timestep_count < intermediate_timestep_count_max ) &
1609          THEN
1610             DO  i = nxl, nxr
1611                DO  j = nys, nyn
1612                   DO  k = nzb+1, nzt
1613                      tsa_m(k,j,i) =   -9.5625_wp * tend(k,j,i) +              &
1614                                        5.3125_wp * tsa_m(k,j,i)
1615                   ENDDO
1616                ENDDO
1617             ENDDO
1618          ENDIF
1619       ENDIF
1620
1621       CALL cpu_log( log_point(37), 'sa-equation', 'stop' )
1622
1623    ENDIF
1624
1625!
1626!-- Calculate density by the equation of state for seawater
1627    CALL cpu_log( log_point(38), 'eqns-seawater', 'start' )
1628    CALL eqn_state_seawater
1629    CALL cpu_log( log_point(38), 'eqns-seawater', 'stop' )
1630
1631 END SUBROUTINE ocean_prognostic_equations
1632
1633
1634!------------------------------------------------------------------------------!
1635! Description:
1636! ------------
1637!> Prognostic equations for ocean mode (so far, salinity only)
1638!> Cache-optimized version
1639!------------------------------------------------------------------------------!
1640 SUBROUTINE ocean_prognostic_equations_ij( i, j, i_omp_start, tn )
1641
1642    USE advec_s_pw_mod,                                                        &
1643        ONLY:  advec_s_pw
1644
1645    USE advec_s_up_mod,                                                        &
1646        ONLY:  advec_s_up
1647
1648    USE advec_ws,                                                              &
1649        ONLY:  advec_s_ws
1650
1651    USE arrays_3d,                                                             &
1652        ONLY:  diss_l_sa, diss_s_sa, flux_l_sa, flux_s_sa, rdf_sc, tend, tsa_m
1653
1654    USE control_parameters,                                                    &
1655        ONLY:  dt_3d, intermediate_timestep_count,                             &
1656               intermediate_timestep_count_max, simulated_time,                &
1657               timestep_scheme, tsc, ws_scheme_sca
1658
1659    USE diffusion_s_mod,                                                       &
1660        ONLY:  diffusion_s
1661
1662    USE indices,                                                               &
1663        ONLY:  nzb, nzt, wall_flags_0
1664
1665    USE surface_mod,                                                           &
1666        ONLY:  surf_def_v, surf_def_h, surf_lsm_h, surf_lsm_v, surf_usm_h,     &
1667               surf_usm_v
1668
1669    USE user_actions_mod,                                                      &
1670        ONLY:  user_actions
1671
1672    IMPLICIT NONE
1673
1674    INTEGER(iwp) ::  i             !< loop index x direction
1675    INTEGER(iwp) ::  i_omp_start   !< first loop index of i-loop in calling    &
1676                                   !< routine prognostic_equations
1677    INTEGER(iwp) ::  j             !< loop index y direction
1678    INTEGER(iwp) ::  k             !< loop index z direction
1679    INTEGER(iwp) ::  tn            !< task number of openmp task
1680
1681
1682!
1683!-- Switch of the surface heat flux, if requested
1684    IF ( surface_cooling_spinup_time /= 999999.9_wp )  THEN
1685       IF ( .NOT. surface_cooling_switched_off  .AND.                          &
1686            simulated_time >= surface_cooling_spinup_time )  THEN
1687
1688          surf_def_h(2)%shf = 0.0_wp
1689          surface_cooling_switched_off = .TRUE.
1690
1691       ENDIF
1692    ENDIF
1693
1694!
1695!-- Compute prognostic equations for the ocean mode
1696!-- First, start with tendency-terms for salinity
1697    IF ( salinity )  THEN
1698
1699       tend(:,j,i) = 0.0_wp
1700       IF ( timestep_scheme(1:5) == 'runge' ) &
1701       THEN
1702          IF ( ws_scheme_sca )  THEN
1703             CALL advec_s_ws( i, j, sa, 'sa', flux_s_sa,  diss_s_sa, flux_l_sa,&
1704                              diss_l_sa, i_omp_start, tn  )
1705          ELSE
1706             CALL advec_s_pw( i, j, sa )
1707          ENDIF
1708       ELSE
1709          CALL advec_s_up( i, j, sa )
1710       ENDIF
1711       CALL diffusion_s( i, j, sa,                                             &
1712                         surf_def_h(0)%sasws, surf_def_h(1)%sasws,             &
1713                         surf_def_h(2)%sasws,                                  &
1714                         surf_lsm_h%sasws,    surf_usm_h%sasws,                &
1715                         surf_def_v(0)%sasws, surf_def_v(1)%sasws,             &
1716                         surf_def_v(2)%sasws, surf_def_v(3)%sasws,             &
1717                         surf_lsm_v(0)%sasws, surf_lsm_v(1)%sasws,             &
1718                         surf_lsm_v(2)%sasws, surf_lsm_v(3)%sasws,             &
1719                         surf_usm_v(0)%sasws, surf_usm_v(1)%sasws,             &
1720                         surf_usm_v(2)%sasws, surf_usm_v(3)%sasws )
1721
1722       CALL user_actions( i, j, 'sa-tendency' )
1723
1724!
1725!--    Prognostic equation for salinity
1726       DO  k = nzb+1, nzt
1727
1728          sa_p(k,j,i) = sa(k,j,i) + ( dt_3d *                                  &
1729                                              ( tsc(2) * tend(k,j,i) +         &
1730                                                tsc(3) * tsa_m(k,j,i) )        &
1731                                    - tsc(5) * rdf_sc(k)                       &
1732                                             * ( sa(k,j,i) - sa_init(k) )      &
1733                                    ) * MERGE( 1.0_wp, 0.0_wp,                 &
1734                                               BTEST( wall_flags_0(k,j,i), 0 ) )
1735
1736          IF ( sa_p(k,j,i) < 0.0_wp )  sa_p(k,j,i) = 0.1_wp * sa(k,j,i)
1737
1738       ENDDO
1739
1740!
1741!--    Calculate tendencies for the next Runge-Kutta step
1742       IF ( timestep_scheme(1:5) == 'runge' )  THEN
1743          IF ( intermediate_timestep_count == 1 )  THEN
1744             DO  k = nzb+1, nzt
1745                tsa_m(k,j,i) = tend(k,j,i)
1746             ENDDO
1747          ELSEIF ( intermediate_timestep_count < intermediate_timestep_count_max ) &
1748          THEN
1749             DO  k = nzb+1, nzt
1750                tsa_m(k,j,i) =   -9.5625_wp * tend(k,j,i) +                    &
1751                                  5.3125_wp * tsa_m(k,j,i)
1752             ENDDO
1753          ENDIF
1754       ENDIF
1755
1756    ENDIF
1757
1758!
1759!-- Calculate density by the equation of state for seawater
1760    CALL eqn_state_seawater( i, j )
1761
1762 END SUBROUTINE ocean_prognostic_equations_ij
1763
1764
1765!------------------------------------------------------------------------------!
1766! Description:
1767! ------------
1768!> Swapping of timelevels.
1769!------------------------------------------------------------------------------!
1770 SUBROUTINE ocean_swap_timelevel( mod_count )
1771
1772    IMPLICIT NONE
1773
1774    INTEGER, INTENT(IN) ::  mod_count  !< flag defining where pointers point to
1775
1776
1777    SELECT CASE ( mod_count )
1778
1779       CASE ( 0 )
1780          IF ( salinity )  THEN
1781             sa => sa_1;    sa_p => sa_2
1782          ENDIF
1783
1784       CASE ( 1 )
1785          IF ( salinity )  THEN
1786             sa => sa_2;    sa_p => sa_1
1787          ENDIF
1788
1789    END SELECT
1790
1791 END SUBROUTINE ocean_swap_timelevel
1792
1793
1794!------------------------------------------------------------------------------!
1795! Description:
1796! ------------
1797!> This routine reads the respective restart data for the ocean module.
1798!------------------------------------------------------------------------------!
1799 SUBROUTINE ocean_rrd_global( found )
1800
1801
1802    USE control_parameters,                                                    &
1803        ONLY: length, restart_string
1804
1805
1806    IMPLICIT NONE
1807
1808    LOGICAL, INTENT(OUT)  ::  found
1809
1810
1811    found = .TRUE.
1812
1813    SELECT CASE ( restart_string(1:length) )
1814
1815       CASE ( 'bc_sa_t' )
1816          READ ( 13 )  bc_sa_t
1817
1818       CASE ( 'bottom_salinityflux' )
1819          READ ( 13 )  bottom_salinityflux
1820
1821       CASE ( 'salinity' )
1822          READ ( 13 )  salinity
1823
1824       CASE ( 'sa_init' )
1825          READ ( 13 )  sa_init
1826
1827       CASE ( 'sa_surface' )
1828          READ ( 13 )  sa_surface
1829
1830       CASE ( 'sa_vertical_gradient' )
1831          READ ( 13 )  sa_vertical_gradient
1832
1833       CASE ( 'sa_vertical_gradient_level' )
1834          READ ( 13 )  sa_vertical_gradient_level
1835
1836       CASE ( 'stokes_waveheight' )
1837          READ ( 13 )  stokes_waveheight
1838
1839       CASE ( 'stokes_wavelength' )
1840          READ ( 13 )  stokes_wavelength
1841
1842       CASE ( 'surface_cooling_spinup_time' )
1843          READ ( 13 )  surface_cooling_spinup_time
1844
1845       CASE ( 'top_salinityflux' )
1846          READ ( 13 )  top_salinityflux
1847
1848       CASE ( 'wall_salinityflux' )
1849          READ ( 13 )  wall_salinityflux
1850
1851       CASE ( 'wave_breaking' )
1852          READ ( 13 )  wave_breaking
1853
1854       CASE DEFAULT
1855
1856          found = .FALSE.
1857
1858    END SELECT
1859
1860 END SUBROUTINE ocean_rrd_global
1861
1862
1863!------------------------------------------------------------------------------!
1864! Description:
1865! ------------
1866!> This routine reads the respective restart data for the ocean module.
1867!------------------------------------------------------------------------------!
1868 SUBROUTINE ocean_rrd_local( i, k, nxlf, nxlc, nxl_on_file, nxrf, nxrc,        &
1869                             nxr_on_file, nynf, nync, nyn_on_file, nysf,       &
1870                             nysc, nys_on_file, tmp_2d, tmp_3d, found )
1871
1872    USE averaging,                                                             &
1873        ONLY:  rho_ocean_av, sa_av
1874
1875    USE control_parameters,                                                    &
1876        ONLY:  length, restart_string
1877
1878    USE indices,                                                               &
1879        ONLY:  nbgp, nxlg, nxrg, nyng, nysg, nzb, nzt
1880
1881    USE pegrid
1882
1883
1884    IMPLICIT NONE
1885
1886    INTEGER(iwp) ::  i               !<
1887    INTEGER(iwp) ::  k               !<
1888    INTEGER(iwp) ::  nxlc            !<
1889    INTEGER(iwp) ::  nxlf            !<
1890    INTEGER(iwp) ::  nxl_on_file     !<
1891    INTEGER(iwp) ::  nxrc            !<
1892    INTEGER(iwp) ::  nxrf            !<
1893    INTEGER(iwp) ::  nxr_on_file     !<
1894    INTEGER(iwp) ::  nync            !<
1895    INTEGER(iwp) ::  nynf            !<
1896    INTEGER(iwp) ::  nyn_on_file     !<
1897    INTEGER(iwp) ::  nysc            !<
1898    INTEGER(iwp) ::  nysf            !<
1899    INTEGER(iwp) ::  nys_on_file     !<
1900
1901    LOGICAL, INTENT(OUT)  ::  found
1902
1903    REAL(wp), DIMENSION(nys_on_file-nbgp:nyn_on_file+nbgp,nxl_on_file-nbgp:nxr_on_file+nbgp) :: tmp_2d   !<
1904    REAL(wp), DIMENSION(nzb:nzt+1,nys_on_file-nbgp:nyn_on_file+nbgp,nxl_on_file-nbgp:nxr_on_file+nbgp) :: tmp_3d   !<
1905
1906
1907    found = .TRUE.
1908
1909    SELECT CASE ( restart_string(1:length) )
1910
1911       CASE ( 'rho_ocean_av' )
1912          IF ( .NOT. ALLOCATED( rho_ocean_av ) )  THEN
1913             ALLOCATE( rho_ocean_av(nzb:nzt+1,nysg:nyng,nxlg:nxrg) )
1914          ENDIF
1915          IF ( k == 1 )  READ ( 13 )  tmp_3d
1916          rho_ocean_av(:,nysc-nbgp:nync+nbgp,nxlc-nbgp:nxrc+nbgp) =            &
1917                              tmp_3d(:,nysf-nbgp:nynf+nbgp,nxlf-nbgp:nxrf+nbgp)
1918
1919       CASE ( 'sa' )
1920          IF ( k == 1 )  READ ( 13 )  tmp_3d
1921          sa(:,nysc-nbgp:nync+nbgp,nxlc-nbgp:nxrc+nbgp) =                      &
1922                              tmp_3d(:,nysf-nbgp:nynf+nbgp,nxlf-nbgp:nxrf+nbgp)
1923
1924       CASE ( 'sa_av' )
1925          IF ( .NOT. ALLOCATED( sa_av ) )  THEN
1926              ALLOCATE( sa_av(nzb:nzt+1,nysg:nyng,nxlg:nxrg) )
1927          ENDIF
1928          IF ( k == 1 )  READ ( 13 )  tmp_3d
1929          sa_av(:,nysc-nbgp:nync+nbgp,nxlc-nbgp:nxrc+nbgp) =                   &
1930                              tmp_3d(:,nysf-nbgp:nynf+nbgp,nxlf-nbgp:nxrf+nbgp)
1931
1932       CASE DEFAULT
1933          found = .FALSE.
1934
1935    END SELECT
1936
1937 END SUBROUTINE ocean_rrd_local
1938
1939
1940!------------------------------------------------------------------------------!
1941! Description:
1942! ------------
1943!> This routine writes the respective restart data for the ocean module.
1944!------------------------------------------------------------------------------!
1945 SUBROUTINE ocean_wrd_global
1946
1947
1948    IMPLICIT NONE
1949
1950    CALL wrd_write_string( 'bc_sa_t' )
1951    WRITE ( 14 )  bc_sa_t
1952
1953    CALL wrd_write_string( 'bottom_salinityflux' )
1954    WRITE ( 14 )  bottom_salinityflux
1955
1956    CALL wrd_write_string( 'salinity' )
1957    WRITE ( 14 )  salinity
1958
1959    CALL wrd_write_string( 'sa_init' )
1960    WRITE ( 14 )  sa_init
1961
1962    CALL wrd_write_string( 'sa_surface' )
1963    WRITE ( 14 )  sa_surface
1964
1965    CALL wrd_write_string( 'sa_vertical_gradient' )
1966    WRITE ( 14 )  sa_vertical_gradient
1967
1968    CALL wrd_write_string( 'sa_vertical_gradient_level' )
1969    WRITE ( 14 )  sa_vertical_gradient_level
1970
1971    CALL wrd_write_string( 'stokes_waveheight' )
1972    WRITE ( 14 )  stokes_waveheight
1973
1974    CALL wrd_write_string( 'stokes_wavelength' )
1975    WRITE ( 14 )  stokes_wavelength
1976
1977    CALL wrd_write_string( 'surface_cooling_spinup_time' )
1978    WRITE ( 14 )  surface_cooling_spinup_time
1979
1980    CALL wrd_write_string( 'top_salinityflux' )
1981    WRITE ( 14 )  top_salinityflux
1982
1983    CALL wrd_write_string( 'wall_salinityflux' )
1984    WRITE ( 14 )  wall_salinityflux
1985
1986    CALL wrd_write_string( 'wave_breaking' )
1987    WRITE ( 14 )  wave_breaking
1988
1989 END SUBROUTINE ocean_wrd_global
1990
1991
1992!------------------------------------------------------------------------------!
1993! Description:
1994! ------------
1995!> This routine writes the respective restart data for the ocean module.
1996!------------------------------------------------------------------------------!
1997 SUBROUTINE ocean_wrd_local
1998
1999    USE averaging,                                                             &
2000        ONLY:  rho_ocean_av, sa_av
2001
2002    IMPLICIT NONE
2003
2004    IF ( ALLOCATED( rho_ocean_av ) )  THEN
2005       CALL wrd_write_string( 'rho_ocean_av' )
2006       WRITE ( 14 )  rho_ocean_av
2007    ENDIF
2008
2009    CALL wrd_write_string( 'sa' )
2010    WRITE ( 14 )  sa
2011
2012    IF ( ALLOCATED( sa_av ) )  THEN
2013       CALL wrd_write_string( 'sa_av' )
2014       WRITE ( 14 )  sa_av
2015    ENDIF
2016
2017 END SUBROUTINE ocean_wrd_local
2018
2019
2020!------------------------------------------------------------------------------!
2021! Description:
2022! ------------
2023!> This routine calculates the Craik Leibovich vortex force and the additional
2024!> effect of the Stokes drift on the Coriolis force
2025!> Call for all gridpoints.
2026!------------------------------------------------------------------------------!
2027 SUBROUTINE stokes_drift_terms( component )
2028
2029    USE arrays_3d,                                                             &
2030        ONLY:  ddzu, u, u_stokes_zu, u_stokes_zw, v, v_stokes_zu,              &
2031               v_stokes_zw, w, tend
2032
2033    USE control_parameters,                                                    &
2034        ONLY:  f, fs, message_string
2035
2036    USE grid_variables,                                                        &
2037        ONLY:  ddx, ddy
2038
2039    USE indices,                                                               &
2040        ONLY:  nxl, nxr, nys, nysv, nyn, nzb, nzt
2041
2042    IMPLICIT NONE
2043
2044    INTEGER(iwp) ::  component  !< component of momentum equation
2045    INTEGER(iwp) ::  i          !< loop index along x
2046    INTEGER(iwp) ::  j          !< loop index along y
2047    INTEGER(iwp) ::  k          !< loop index along z
2048
2049
2050!
2051!-- Compute Stokes terms for the respective velocity components
2052    SELECT CASE ( component )
2053
2054!
2055!--    u-component
2056       CASE ( 1 )
2057          DO  i = nxl, nxr
2058             DO  j = nysv, nyn
2059                DO  k = nzb+1, nzt
2060                   tend(k,j,i) = tend(k,j,i) + v_stokes_zu(k) * (              &
2061                                   0.5 * ( v(k,j+1,i) - v(k,j+1,i-1)           &
2062                                         + v(k,j,i)   - v(k,j,i-1)   ) * ddx   &
2063                                 - 0.5 * ( u(k,j+1,i) - u(k,j-1,i) )   * ddy   &
2064                                                                )              &
2065                                 + f * v_stokes_zu(k)
2066                ENDDO
2067             ENDDO
2068          ENDDO
2069
2070!
2071!--    v-component
2072       CASE ( 2 )
2073          DO  i = nxl, nxr
2074             DO  j = nysv, nyn
2075                DO  k = nzb+1, nzt
2076                   tend(k,j,i) = tend(k,j,i) - u_stokes_zu(k) * (              &
2077                                   0.5 * ( v(k,j,i+1) - v(k,j,i-1) )   * ddx   &
2078                                 - 0.5 * ( u(k,j,i) - u(k,j-1,i)               &
2079                                         + u(k,j,i+1) - u(k,j-1,i+1) ) * ddy   &
2080                                                                )              &
2081                                 - f * u_stokes_zu(k)
2082                ENDDO
2083             ENDDO
2084          ENDDO
2085
2086!
2087!--    w-component
2088       CASE ( 3 )
2089          DO  i = nxl, nxr
2090             DO  j = nys, nyn
2091                DO  k = nzb+1, nzt
2092                   tend(k,j,i) = tend(k,j,i) + u_stokes_zw(k) * (              &
2093                                             0.5 * ( u(k+1,j,i) - u(k,j,i)     &
2094                                                   + u(k+1,j,i+1) - u(k,j,i+1) &
2095                                                   ) * ddzu(k+1)               &
2096                                           - 0.5 * ( w(k,j,i+1) - w(k,j,i-1)   &
2097                                                   ) * ddx      )              &
2098                                             - v_stokes_zw(k) * (              &
2099                                             0.5 * ( w(k,j+1,i) - w(k,j-1,i)   &
2100                                                   ) * ddy                     &
2101                                           - 0.5 * ( v(k+1,j,i) - v(k,j,i)     &
2102                                                   + v(k+1,j+1,i) - v(k,j+1,i) &
2103                                                   ) * ddzu(k)  )              &
2104                                           + fs * u_stokes_zw(k)
2105                ENDDO
2106             ENDDO
2107          ENDDO
2108
2109       CASE DEFAULT
2110          WRITE( message_string, * ) 'wrong component of Stokes force: ',      &
2111                                     component
2112          CALL message( 'stokes_drift_terms', 'PA0091', 1, 2, 0, 6, 0 )
2113
2114    END SELECT
2115
2116 END SUBROUTINE stokes_drift_terms
2117
2118
2119!------------------------------------------------------------------------------!
2120! Description:
2121! ------------
2122!> This routine calculates the Craik Leibovich vortex force and the additional
2123!> effect of the Stokes drift on the Coriolis force
2124!> Call for gridpoints i,j.
2125!------------------------------------------------------------------------------!
2126
2127 SUBROUTINE stokes_drift_terms_ij( i, j, component )
2128
2129    USE arrays_3d,                                                             &
2130        ONLY:  ddzu, u, u_stokes_zu, u_stokes_zw, v, v_stokes_zu,              &
2131               v_stokes_zw, w, tend
2132
2133    USE control_parameters,                                                    &
2134        ONLY:  f, fs, message_string
2135
2136    USE grid_variables,                                                        &
2137        ONLY:  ddx, ddy
2138
2139    USE indices,                                                               &
2140        ONLY:  nzb, nzt
2141
2142    IMPLICIT NONE
2143
2144    INTEGER(iwp) ::  component  !< component of momentum equation
2145    INTEGER(iwp) ::  i          !< loop index along x
2146    INTEGER(iwp) ::  j          !< loop index along y
2147    INTEGER(iwp) ::  k          !< loop incex along z
2148
2149
2150!
2151!-- Compute Stokes terms for the respective velocity components
2152    SELECT CASE ( component )
2153
2154!
2155!--    u-component
2156       CASE ( 1 )
2157          DO  k = nzb+1, nzt
2158             tend(k,j,i) = tend(k,j,i) + v_stokes_zu(k) * (                    &
2159                                     0.5 * ( v(k,j+1,i) - v(k,j+1,i-1)         &
2160                                           + v(k,j,i)   - v(k,j,i-1)   ) * ddx &
2161                                   - 0.5 * ( u(k,j+1,i) - u(k,j-1,i) )   * ddy &
2162                                                          )                    &
2163                                       + f * v_stokes_zu(k)
2164          ENDDO
2165!
2166!--    v-component
2167       CASE ( 2 )
2168          DO  k = nzb+1, nzt
2169             tend(k,j,i) = tend(k,j,i) - u_stokes_zu(k) * (                    &
2170                                     0.5 * ( v(k,j,i+1) - v(k,j,i-1) )   * ddx &
2171                                   - 0.5 * ( u(k,j,i) - u(k,j-1,i)             &
2172                                           + u(k,j,i+1) - u(k,j-1,i+1) ) * ddy &
2173                                                          )                    &
2174                                       - f * u_stokes_zu(k)
2175          ENDDO
2176
2177!
2178!--    w-component
2179       CASE ( 3 )
2180          DO  k = nzb+1, nzt
2181             tend(k,j,i) = tend(k,j,i) + u_stokes_zw(k) * (              &
2182                                     0.5 * ( u(k+1,j,i) - u(k,j,i)     &
2183                                                   + u(k+1,j,i+1) - u(k,j,i+1) &
2184                                                   ) * ddzu(k+1)               &
2185                                           - 0.5 * ( w(k,j,i+1) - w(k,j,i-1)   &
2186                                                   ) * ddx )                   &
2187                                       - v_stokes_zw(k) * (                    &
2188                                             0.5 * ( w(k,j+1,i) - w(k,j-1,i)   &
2189                                                   ) * ddy                     &
2190                                           - 0.5 * ( v(k+1,j,i) - v(k,j,i)     &
2191                                                   + v(k+1,j+1,i) - v(k,j+1,i) &
2192                                                   ) * ddzu(k)  )              &
2193                                       + fs * u_stokes_zw(k)
2194          ENDDO
2195
2196       CASE DEFAULT
2197          WRITE( message_string, * ) ' wrong component: ', component
2198          CALL message( 'stokes_drift_terms', 'PA0091', 1, 2, 0, 6, 0 )
2199
2200    END SELECT
2201
2202 END SUBROUTINE stokes_drift_terms_ij
2203
2204
2205!------------------------------------------------------------------------------!
2206! Description:
2207! ------------
2208!> This routine calculates turbulence generated by wave breaking near the ocean
2209!> surface, following a parameterization given in Noh et al. (2004), JPO
2210!> Call for all gridpoints.
2211!> TODO: so far, this routine only works if the model time step has about the
2212!>       same value as the time scale of wave breaking!
2213!------------------------------------------------------------------------------!
2214 SUBROUTINE wave_breaking_term( component )
2215
2216    USE arrays_3d,                                                             &
2217        ONLY:  u_p, v_p
2218
2219    USE control_parameters,                                                    &
2220        ONLY:  dt_3d, message_string
2221
2222    USE indices,                                                               &
2223        ONLY:  nxl, nxlu, nxr, nys, nysv, nyn, nzt
2224
2225    IMPLICIT NONE
2226
2227    INTEGER(iwp) ::  component  !< component of momentum equation
2228    INTEGER(iwp) ::  i          !< loop index along x
2229    INTEGER(iwp) ::  j          !< loop index along y
2230
2231    REAL(wp) ::  random_gauss  !< function that creates a random number with a
2232                               !< Gaussian distribution
2233
2234
2235!
2236!-- Compute wave breaking terms for the respective velocity components.
2237!-- Velocities are directly manipulated, since this is not a real force
2238    SELECT CASE ( component )
2239
2240!
2241!--    u-component
2242       CASE ( 1 )
2243          DO  i = nxlu, nxr
2244             DO  j = nys, nyn
2245                u_p(nzt,j,i) = u_p(nzt,j,i) +                                  &
2246                               ( random_gauss( iran_ocean, 1.0_wp ) - 1.0_wp ) &
2247                               * alpha_wave_breaking * u_star_wave_breaking    &
2248                               / timescale_wave_breaking * dt_3d
2249             ENDDO
2250          ENDDO
2251!
2252!--    v-component
2253       CASE ( 2 )
2254          DO  i = nxl, nxr
2255             DO  j = nysv, nyn
2256                v_p(nzt,j,i) = v_p(nzt,j,i) +                                  &
2257                               ( random_gauss( iran_ocean, 1.0_wp ) - 1.0_wp ) &
2258                               * alpha_wave_breaking * u_star_wave_breaking    &
2259                               / timescale_wave_breaking * dt_3d
2260             ENDDO
2261          ENDDO
2262
2263       CASE DEFAULT
2264          WRITE( message_string, * ) 'wrong component of wave breaking: ',     &
2265                                     component
2266          CALL message( 'stokes_drift_terms', 'PA0466', 1, 2, 0, 6, 0 )
2267
2268    END SELECT
2269
2270 END SUBROUTINE wave_breaking_term
2271
2272
2273!------------------------------------------------------------------------------!
2274! Description:
2275! ------------
2276!> This routine calculates turbulence generated by wave breaking near the ocean
2277!> surface, following a parameterization given in Noh et al. (2004), JPO
2278!> Call for gridpoint i,j.
2279!> TODO: so far, this routine only works if the model time step has about the
2280!>       same value as the time scale of wave breaking!
2281!------------------------------------------------------------------------------!
2282 SUBROUTINE wave_breaking_term_ij( i, j, component )
2283
2284    USE arrays_3d,                                                             &
2285        ONLY:  u_p, v_p
2286
2287    USE control_parameters,                                                    &
2288        ONLY:  dt_3d, message_string
2289
2290    USE indices,                                                               &
2291        ONLY:  nzt
2292
2293    IMPLICIT NONE
2294
2295    INTEGER(iwp) ::  component  !< component of momentum equation
2296    INTEGER(iwp) ::  i          !< loop index along x
2297    INTEGER(iwp) ::  j          !< loop index along y
2298
2299    REAL(wp) ::  random_gauss  !< function that creates a random number with a
2300                               !< Gaussian distribution
2301
2302!
2303!-- Compute wave breaking terms for the respective velocity components
2304    SELECT CASE ( component )
2305
2306!
2307!--    u-/v-component
2308       CASE ( 1 )
2309          u_p(nzt,j,i) = u_p(nzt,j,i) +                                        &
2310                         ( random_gauss( iran_ocean, 1.0_wp ) - 1.0_wp )       &
2311                         * alpha_wave_breaking * u_star_wave_breaking          &
2312                         / timescale_wave_breaking * dt_3d
2313
2314       CASE ( 2 )
2315          v_p(nzt,j,i) = v_p(nzt,j,i) +                                        &
2316                         ( random_gauss( iran_ocean, 1.0_wp ) - 1.0_wp )       &
2317                         * alpha_wave_breaking * u_star_wave_breaking          &
2318                         / timescale_wave_breaking * dt_3d
2319
2320       CASE DEFAULT
2321          WRITE( message_string, * ) 'wrong component of wave breaking: ',     &
2322                                     component
2323          CALL message( 'stokes_drift_terms', 'PA0466', 1, 2, 0, 6, 0 )
2324
2325    END SELECT
2326
2327 END SUBROUTINE wave_breaking_term_ij
2328
2329
2330 END MODULE ocean_mod
Note: See TracBrowser for help on using the repository browser.