source: palm/trunk/SOURCE/surface_output_mod.f90 @ 3646

Last change on this file since 3646 was 3646, checked in by kanani, 3 years ago

Bugfix: replace simulated_time by time_since_reference_point where required

  • Property svn:keywords set to Id
File size: 204.8 KB
Line 
1!> @file surface_output_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 1997-2018 Leibniz Universitaet Hannover
18!------------------------------------------------------------------------------!
19!
20! Current revisions:
21! ------------------
22!
23!
24! Former revisions:
25! -----------------
26! $Id: surface_output_mod.f90 3646 2018-12-28 17:58:49Z kanani $
27! Bugfix: use time_since_reference_point instead of simulated_time (relevant
28! when using wall/soil spinup)
29!
30! 3614 2018-12-10 07:05:46Z raasch
31! unused variables removed
32!
33! 3572 2018-11-28 11:40:28Z suehring
34! Added short- and longwave radiation flux arrays (e.g. diffuse, direct,
35! reflected, resedual) for all surfaces (M. Salim)
36!
37! 3494 2018-11-06 14:51:27Z suehring
38! Bugfix in gathering surface data from different types and orientation.
39! Output of total number of surfaces and vertices added.
40! String length is output, for more convinient post-processing.
41! Last actions added.
42!
43! 3483 2018-11-02 14:19:26Z raasch
44! bugfix: missed directives for MPI added
45!
46! 3421 2018-10-24 18:39:32Z gronemeier
47! Add output variables
48! Write data into binary file
49!
50! 3420 2018-10-24 17:30:08Z gronemeier
51! Initial implementation from Klaus Ketelsen and Matthias Suehring
52!
53!
54! Authors:
55! --------
56! @author Klaus Ketelsen, Matthias Suehring
57!
58! Description:
59! ------------
60!> Generate output for surface data.
61!>
62!> @todo Create namelist file for post-processing tool.
63!------------------------------------------------------------------------------!
64
65MODULE surface_output_mod
66
67   USE kinds
68
69   USE arrays_3d,                                                              &
70       ONLY:  zu, zw
71       
72   USE control_parameters,                                                     &
73       ONLY:  surface_data_output
74       
75   USE grid_variables,                                                         &
76       ONLY: dx,dy
77       
78   USE indices,                                                                &
79       ONLY: nxl, nxr, nys, nyn, nzb, nzt
80       
81   USE pegrid
82       
83   USE surface_mod,                                                            &
84       ONLY:  surf_def_h, surf_def_v, surf_lsm_h, surf_lsm_v,                  &
85              surf_usm_h, surf_usm_v
86
87   IMPLICIT NONE
88
89   TYPE surf_out                      !< data structure which contains all surfaces elements of all types on subdomain
90   
91      INTEGER(iwp) ::  ns             !< number of surface elements on subdomain
92      INTEGER(iwp) ::  ns_total       !< total number of surface elements
93      INTEGER(iwp) ::  npoints        !< number of points / vertices which define a surface element (on subdomain)
94      INTEGER(iwp) ::  npoints_total  !< total number of points / vertices which define a surface element
95     
96      REAL(wp) ::  fillvalue = -9999.9_wp !< fillvalue for surface elements which are not defined
97     
98      REAL(wp), DIMENSION(:), ALLOCATABLE   ::  var_out  !< output variables
99      REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  var_av   !< variables used for averaging
100      REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  points   !< points  / vertices of a surface element
101      REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  polygons !< polygon data of a surface element
102   END TYPE surf_out
103   
104   CHARACTER(LEN=100), DIMENSION(300)       ::  data_output_surf = ' '  !< namelist variable which describes the output variables
105   CHARACTER(LEN=100), DIMENSION(0:1,300)   ::  dosurf = ' '            !< internal variable which describes the output variables and separates
106                                                                        !< averaged from non-averaged output
107   
108   INTEGER(iwp) ::  average_count_surf = 0                !< number of ensemble members used for averaging
109   INTEGER(iwp) ::  dosurf_no(0:1) = 0                    !< number of surface output quantities
110
111   LOGICAL :: first_output(0:1) = .FALSE.                 !< true if first output was already called
112
113   REAL(wp) ::  averaging_interval_surf  = 9999999.9_wp   !< averaging interval
114   REAL(wp) ::  dt_dosurf = 9999999.9_wp                  !< time interval for instantaneous data output
115   REAL(wp) ::  dt_dosurf_av = 9999999.9_wp               !< time interval for averaged data output
116   REAL(wp) ::  skip_time_dosurf = 0.0_wp                 !< skip time for instantaneous data output
117   REAL(wp) ::  skip_time_dosurf_av = 0.0_wp              !< skip time for averaged data output
118   REAL(wp) ::  time_dosurf = 0.0_wp                      !< internal counter variable to check for instantaneous data output
119   REAL(wp) ::  time_dosurf_av = 0.0_wp                   !< internal counter variable to check for averaged data output
120
121   
122   TYPE(surf_out) ::  surfaces      !< variable which contains all required output information
123   
124   SAVE
125
126   PRIVATE
127
128   INTERFACE  surface_output
129      MODULE PROCEDURE surface_output
130   END INTERFACE  surface_output
131   
132   INTERFACE  surface_output_averaging
133      MODULE PROCEDURE surface_output_averaging
134   END INTERFACE  surface_output_averaging
135   
136   INTERFACE  surface_output_check_parameters
137      MODULE PROCEDURE surface_output_check_parameters
138   END INTERFACE  surface_output_check_parameters
139   
140   INTERFACE  surface_output_init
141      MODULE PROCEDURE surface_output_init
142   END INTERFACE  surface_output_init
143   
144   INTERFACE  surface_output_last_action
145      MODULE PROCEDURE surface_output_last_action
146   END INTERFACE  surface_output_last_action
147     
148   INTERFACE  surface_output_parin
149      MODULE PROCEDURE surface_output_parin
150   END INTERFACE  surface_output_parin
151
152!
153!--Public subroutines
154   PUBLIC surface_output, surface_output_averaging,                            &
155          surface_output_check_parameters, surface_output_init,                &
156          surface_output_last_action, surface_output_parin
157!
158!--Public variables
159   PUBLIC average_count_surf, averaging_interval_surf, dt_dosurf, dt_dosurf_av,&
160          skip_time_dosurf, skip_time_dosurf_av, time_dosurf, time_dosurf_av
161
162 CONTAINS
163
164!------------------------------------------------------------------------------!
165! Description:
166! ------------
167!> Initialization surface-data output data structure: calculation of vertices
168!> and polygon data for the surface elements, allocation of required arrays.
169!------------------------------------------------------------------------------!
170   SUBROUTINE surface_output_init
171   
172      IMPLICIT NONE
173
174      INTEGER(iwp) ::  i                 !< grid index in x-direction, also running variable for counting non-average data output
175      INTEGER(iwp) ::  j                 !< grid index in y-direction, also running variable for counting average data output
176      INTEGER(iwp) ::  k                 !< grid index in z-direction
177      INTEGER(iwp) ::  l                 !< running index for surface-element orientation
178      INTEGER(iwp) ::  m                 !< running index for surface elements
179      INTEGER(iwp) ::  npg               !< counter variable for all surface elements ( or polygons )
180      INTEGER(iwp) ::  point_index_count !< local counter variable for point index
181     
182      INTEGER(iwp), DIMENSION(0:numprocs-1) :: num_points_on_pe   !< array which contains the number of points on all mpi ranks
183      INTEGER(iwp), ALLOCATABLE, DIMENSION(:,:,:) ::  point_index !< dummy array used to check where the reference points for surface polygons are located
184           
185!
186!--   Determine the number of surface elements on subdomain
187      surfaces%ns = surf_def_h(0)%ns + surf_lsm_h%ns + surf_usm_h%ns           & !horizontal upward-facing
188                  + surf_def_h(1)%ns                                           & !horizontal downard-facing   
189                  + surf_def_v(0)%ns + surf_lsm_v(0)%ns + surf_usm_v(0)%ns     & !northward-facing
190                  + surf_def_v(1)%ns + surf_lsm_v(1)%ns + surf_usm_v(1)%ns     & !southward-facing   
191                  + surf_def_v(2)%ns + surf_lsm_v(2)%ns + surf_usm_v(2)%ns     & !westward-facing   
192                  + surf_def_v(3)%ns + surf_lsm_v(3)%ns + surf_usm_v(3)%ns       !eastward-facing   
193!
194!--   Allocate output variable and set to _FillValue attribute
195      ALLOCATE ( surfaces%var_out(1:surfaces%ns) )
196      surfaces%var_out = surfaces%fillvalue
197!
198!--   If there is an output of time average output variables, allocate the
199!--   required array.
200      IF ( dosurf_no(1) > 0 )  THEN
201         ALLOCATE ( surfaces%var_av(1:surfaces%ns,1:dosurf_no(1)) )
202         surfaces%var_av = 0.0_wp
203      ENDIF
204!
205!--   Initialize points and polygon data.
206!--   In a first step, count the number of points which are defining
207!--   the surfaces and the polygons.
208      ALLOCATE( point_index(nzb:nzt+1,nys-1:nyn+1,nxl-1:nxr+1) )
209      point_index = -1
210!
211!--   Horizontal default surfaces
212      surfaces%npoints = 0
213      DO  l = 0, 1
214         DO  m = 1, surf_def_h(0)%ns
215!
216!--         Determine the indices of the respective grid cell inside the topography
217            i = surf_def_h(0)%i(m) + surf_def_h(0)%ioff
218            j = surf_def_h(0)%j(m) + surf_def_h(0)%joff
219            k = surf_def_h(0)%k(m) + surf_def_h(0)%koff
220!
221!--         Check if the vertices that define the surface element are already
222!--         defined, if not, increment the counter.
223            IF ( point_index(k,j,i) < 0 )  THEN
224               surfaces%npoints   = surfaces%npoints + 1   
225               point_index(k,j,i) = surfaces%npoints - 1
226            ENDIF
227            IF ( point_index(k,j,i+1) < 0 )  THEN
228               surfaces%npoints     = surfaces%npoints + 1   
229               point_index(k,j,i+1) = surfaces%npoints - 1
230            ENDIF
231            IF ( point_index(k,j+1,i+1) < 0 )  THEN
232               surfaces%npoints       = surfaces%npoints + 1   
233               point_index(k,j+1,i+1) = surfaces%npoints - 1
234            ENDIF
235            IF ( point_index(k,j+1,i) < 0 )  THEN
236               surfaces%npoints     = surfaces%npoints + 1   
237               point_index(k,j+1,i) = surfaces%npoints - 1
238            ENDIF           
239         ENDDO
240      ENDDO
241      DO  m = 1, surf_lsm_h%ns
242         i = surf_lsm_h%i(m) + surf_lsm_h%ioff
243         j = surf_lsm_h%j(m) + surf_lsm_h%joff
244         k = surf_lsm_h%k(m) + surf_lsm_h%koff
245
246         IF ( point_index(k,j,i) < 0 )  THEN
247            surfaces%npoints   = surfaces%npoints + 1   
248            point_index(k,j,i) = surfaces%npoints - 1
249         ENDIF
250         IF ( point_index(k,j,i+1) < 0 )  THEN
251            surfaces%npoints     = surfaces%npoints + 1   
252            point_index(k,j,i+1) = surfaces%npoints - 1
253         ENDIF
254         IF ( point_index(k,j+1,i+1) < 0 )  THEN
255            surfaces%npoints       = surfaces%npoints + 1   
256            point_index(k,j+1,i+1) = surfaces%npoints - 1
257         ENDIF
258         IF ( point_index(k,j+1,i) < 0 )  THEN
259            surfaces%npoints     = surfaces%npoints + 1   
260            point_index(k,j+1,i) = surfaces%npoints - 1
261         ENDIF   
262      ENDDO
263      DO  m = 1, surf_usm_h%ns
264         i = surf_usm_h%i(m) + surf_usm_h%ioff
265         j = surf_usm_h%j(m) + surf_usm_h%joff
266         k = surf_usm_h%k(m) + surf_usm_h%koff
267
268         IF ( point_index(k,j,i) < 0 )  THEN
269            surfaces%npoints   = surfaces%npoints + 1   
270            point_index(k,j,i) = surfaces%npoints - 1
271         ENDIF
272         IF ( point_index(k,j,i+1) < 0 )  THEN
273            surfaces%npoints     = surfaces%npoints + 1   
274            point_index(k,j,i+1) = surfaces%npoints - 1
275         ENDIF
276         IF ( point_index(k,j+1,i+1) < 0 )  THEN
277            surfaces%npoints       = surfaces%npoints + 1   
278            point_index(k,j+1,i+1) = surfaces%npoints - 1
279         ENDIF
280         IF ( point_index(k,j+1,i) < 0 )  THEN
281            surfaces%npoints     = surfaces%npoints + 1   
282            point_index(k,j+1,i) = surfaces%npoints - 1
283         ENDIF     
284      ENDDO
285!
286!--   Vertical surfaces
287      DO  l = 0, 3
288         DO  m = 1, surf_def_v(l)%ns
289!
290!--         Determine the indices of the respective grid cell inside the topography.
291!--         Please note, j-index for north-facing surfaces ( l==0 ) is
292!--         identical to the reference j-index outside the grid box.
293!--         Equivalent for east-facing surfaces and i-index.
294            i = surf_def_v(l)%i(m) + MERGE( surf_def_v(l)%ioff, 0, l == 3 )
295            j = surf_def_v(l)%j(m) + MERGE( surf_def_v(l)%joff, 0, l == 1 )
296            k = surf_def_v(l)%k(m) + surf_def_v(l)%koff
297!
298!--         Lower left /front vertex
299            IF ( point_index(k,j,i) < 0 )  THEN
300               surfaces%npoints   = surfaces%npoints + 1   
301               point_index(k,j,i) = surfaces%npoints - 1
302            ENDIF
303!
304!--         Upper / lower right index for north- and south-facing surfaces
305            IF ( l == 0  .OR.  l == 1 )  THEN
306               IF ( point_index(k,j,i+1) < 0 )  THEN
307                  surfaces%npoints     = surfaces%npoints + 1   
308                  point_index(k,j,i+1) = surfaces%npoints - 1
309               ENDIF
310               IF ( point_index(k+1,j,i+1) < 0 )  THEN
311                  surfaces%npoints       = surfaces%npoints + 1   
312                  point_index(k+1,j,i+1) = surfaces%npoints - 1
313               ENDIF
314!
315!--         Upper / lower front index for east- and west-facing surfaces
316            ELSEIF ( l == 2  .OR.  l == 3 )  THEN
317               IF ( point_index(k,j+1,i) < 0 )  THEN
318                  surfaces%npoints     = surfaces%npoints + 1   
319                  point_index(k,j+1,i) = surfaces%npoints - 1
320               ENDIF
321               IF ( point_index(k+1,j+1,i) < 0 )  THEN
322                  surfaces%npoints       = surfaces%npoints + 1   
323                  point_index(k+1,j+1,i) = surfaces%npoints - 1
324               ENDIF
325            ENDIF
326!
327!--         Upper left / front vertex
328            IF ( point_index(k+1,j,i) < 0 )  THEN
329               surfaces%npoints     = surfaces%npoints + 1   
330               point_index(k+1,j,i) = surfaces%npoints - 1
331            ENDIF
332         ENDDO
333         DO  m = 1, surf_lsm_v(l)%ns
334            i = surf_lsm_v(l)%i(m) + MERGE( surf_lsm_v(l)%ioff, 0, l == 3 )
335            j = surf_lsm_v(l)%j(m) + MERGE( surf_lsm_v(l)%joff, 0, l == 1 )
336            k = surf_lsm_v(l)%k(m) + surf_lsm_v(l)%koff
337!
338!--         Lower left /front vertex
339            IF ( point_index(k,j,i) < 0 )  THEN
340               surfaces%npoints   = surfaces%npoints + 1   
341               point_index(k,j,i) = surfaces%npoints - 1
342            ENDIF
343!
344!--         Upper / lower right index for north- and south-facing surfaces
345            IF ( l == 0  .OR.  l == 1 )  THEN
346               IF ( point_index(k,j,i+1) < 0 )  THEN
347                  surfaces%npoints     = surfaces%npoints + 1   
348                  point_index(k,j,i+1) = surfaces%npoints - 1
349               ENDIF
350               IF ( point_index(k+1,j,i+1) < 0 )  THEN
351                  surfaces%npoints       = surfaces%npoints + 1   
352                  point_index(k+1,j,i+1) = surfaces%npoints - 1
353               ENDIF
354!
355!--         Upper / lower front index for east- and west-facing surfaces
356            ELSEIF ( l == 2  .OR.  l == 3 )  THEN
357               IF ( point_index(k,j+1,i) < 0 )  THEN
358                  surfaces%npoints     = surfaces%npoints + 1   
359                  point_index(k,j+1,i) = surfaces%npoints - 1
360               ENDIF
361               IF ( point_index(k+1,j+1,i) < 0 )  THEN
362                  surfaces%npoints       = surfaces%npoints + 1   
363                  point_index(k+1,j+1,i) = surfaces%npoints - 1
364               ENDIF
365            ENDIF
366!
367!--         Upper left / front vertex
368            IF ( point_index(k+1,j,i) < 0 )  THEN
369               surfaces%npoints     = surfaces%npoints + 1   
370               point_index(k+1,j,i) = surfaces%npoints - 1
371            ENDIF
372         ENDDO
373
374         DO  m = 1, surf_usm_v(l)%ns
375            i = surf_usm_v(l)%i(m) + MERGE( surf_usm_v(l)%ioff, 0, l == 3 )
376            j = surf_usm_v(l)%j(m) + MERGE( surf_usm_v(l)%joff, 0, l == 1 )
377            k = surf_usm_v(l)%k(m) + surf_usm_v(l)%koff
378!
379!--         Lower left /front vertex
380            IF ( point_index(k,j,i) < 0 )  THEN
381               surfaces%npoints   = surfaces%npoints + 1   
382               point_index(k,j,i) = surfaces%npoints - 1
383            ENDIF
384!
385!--         Upper / lower right index for north- and south-facing surfaces
386            IF ( l == 0  .OR.  l == 1 )  THEN
387               IF ( point_index(k,j,i+1) < 0 )  THEN
388                  surfaces%npoints     = surfaces%npoints + 1   
389                  point_index(k,j,i+1) = surfaces%npoints - 1
390               ENDIF
391               IF ( point_index(k+1,j,i+1) < 0 )  THEN
392                  surfaces%npoints       = surfaces%npoints + 1   
393                  point_index(k+1,j,i+1) = surfaces%npoints - 1
394               ENDIF
395!
396!--         Upper / lower front index for east- and west-facing surfaces
397            ELSEIF ( l == 2  .OR.  l == 3 )  THEN
398               IF ( point_index(k,j+1,i) < 0 )  THEN
399                  surfaces%npoints     = surfaces%npoints + 1   
400                  point_index(k,j+1,i) = surfaces%npoints - 1
401               ENDIF
402               IF ( point_index(k+1,j+1,i) < 0 )  THEN
403                  surfaces%npoints       = surfaces%npoints + 1   
404                  point_index(k+1,j+1,i) = surfaces%npoints - 1
405               ENDIF
406            ENDIF
407!
408!--         Upper left / front vertex
409            IF ( point_index(k+1,j,i) < 0 )  THEN
410               surfaces%npoints     = surfaces%npoints + 1   
411               point_index(k+1,j,i) = surfaces%npoints - 1
412            ENDIF
413         ENDDO
414
415      ENDDO
416!
417!--   Allocate the number of points and polygons. Note, the number of polygons
418!--   is identical to the number of surfaces elements, whereas the number
419!--   of points (vertices) which define the polygons can be larger.
420      ALLOCATE( surfaces%points(3,1:surfaces%npoints) )
421      ALLOCATE( surfaces%polygons(5,1:surfaces%ns)    )
422!
423!--   Note, PARAVIEW expects consecutively ordered points which can be
424!--   unambiguously identified.
425!--   Hence, all PEs know where they should start counting, depending on the
426!--   number of points on the other PE's with lower MPI rank.
427#if defined( __parallel )
428      CALL MPI_ALLGATHER( surfaces%npoints, 1, MPI_INTEGER,                    &
429                          num_points_on_pe, 1, MPI_INTEGER, comm2d, ierr  )
430#else
431      num_points_on_pe = surfaces%npoints
432#endif
433
434!
435!--   After the number of vertices is counted, repeat the loops and define the
436!--   vertices. Start with the horizontal default surfaces
437!--   First, however, determine the offset where couting of points should be
438!--   started, which is the sum of points of all PE's with lower MPI rank.
439      i                 = 0
440      point_index_count = 0
441      DO WHILE ( i < myid  .AND.  i <= SIZE( num_points_on_pe ) )
442         point_index_count = point_index_count + num_points_on_pe(i)
443         i                 = i + 1
444      ENDDO
445         
446     
447      surfaces%npoints = 0
448      point_index      = -1
449      npg              = 0
450     
451      DO  l = 0, 1
452         DO  m = 1, surf_def_h(0)%ns
453!
454!--         Determine the indices of the respective grid cell inside the topography
455            i = surf_def_h(0)%i(m) + surf_def_h(0)%ioff
456            j = surf_def_h(0)%j(m) + surf_def_h(0)%joff
457            k = surf_def_h(0)%k(m) + surf_def_h(0)%koff
458!
459!--         Check if the vertices that define the surface element are already
460!--         defined, if not, increment the counter.
461            IF ( point_index(k,j,i) < 0 )  THEN
462               surfaces%npoints   = surfaces%npoints + 1   
463               point_index(k,j,i) = point_index_count
464               point_index_count  = point_index_count + 1               
465               surfaces%points(1,surfaces%npoints) = ( i - 0.5_wp ) * dx
466               surfaces%points(2,surfaces%npoints) = ( j - 0.5_wp ) * dy
467               surfaces%points(3,surfaces%npoints) = zw(k)
468            ENDIF
469            IF ( point_index(k,j,i+1) < 0 )  THEN
470               surfaces%npoints     = surfaces%npoints + 1   
471               point_index(k,j,i+1) = point_index_count
472               point_index_count    = point_index_count + 1 
473               surfaces%points(1,surfaces%npoints) = ( i + 1 - 0.5_wp ) * dx
474               surfaces%points(2,surfaces%npoints) = ( j     - 0.5_wp ) * dy
475               surfaces%points(3,surfaces%npoints) = zw(k)
476            ENDIF
477            IF ( point_index(k,j+1,i+1) < 0 )  THEN
478               surfaces%npoints       = surfaces%npoints + 1   
479               point_index(k,j+1,i+1) = point_index_count
480               point_index_count      = point_index_count + 1 
481               surfaces%points(1,surfaces%npoints) = ( i + 1 - 0.5_wp ) * dx
482               surfaces%points(2,surfaces%npoints) = ( j + 1 - 0.5_wp ) * dy
483               surfaces%points(3,surfaces%npoints) = zw(k)
484            ENDIF
485            IF ( point_index(k,j+1,i) < 0 )  THEN
486               surfaces%npoints     = surfaces%npoints + 1   
487               point_index(k,j+1,i) = point_index_count
488               point_index_count    = point_index_count + 1 
489               surfaces%points(1,surfaces%npoints) = ( i     - 0.5_wp ) * dx
490               surfaces%points(2,surfaces%npoints) = ( j + 1 - 0.5_wp ) * dy
491               surfaces%points(3,surfaces%npoints) = zw(k)
492            ENDIF
493           
494            npg                        = npg + 1
495            surfaces%polygons(1,npg)   = 4
496            surfaces%polygons(2,npg)   = point_index(k,j,i)
497            surfaces%polygons(3,npg)   = point_index(k,j,i+1)
498            surfaces%polygons(4,npg)   = point_index(k,j+1,i+1)
499            surfaces%polygons(5,npg)   = point_index(k,j+1,i)
500         ENDDO
501      ENDDO
502      DO  m = 1, surf_lsm_h%ns
503         i = surf_lsm_h%i(m) + surf_lsm_h%ioff
504         j = surf_lsm_h%j(m) + surf_lsm_h%joff
505         k = surf_lsm_h%k(m) + surf_lsm_h%koff
506         IF ( point_index(k,j,i) < 0 )  THEN
507            surfaces%npoints   = surfaces%npoints + 1   
508            point_index(k,j,i) = point_index_count
509            point_index_count  = point_index_count + 1 
510            surfaces%points(1,surfaces%npoints) = ( i - 0.5_wp ) * dx
511            surfaces%points(2,surfaces%npoints) = ( j - 0.5_wp ) * dy
512            surfaces%points(3,surfaces%npoints) = zw(k)
513         ENDIF
514         IF ( point_index(k,j,i+1) < 0 )  THEN
515            surfaces%npoints     = surfaces%npoints + 1   
516            point_index(k,j,i+1) = point_index_count
517            point_index_count    = point_index_count + 1 
518            surfaces%points(1,surfaces%npoints) = ( i + 1 - 0.5_wp ) * dx
519            surfaces%points(2,surfaces%npoints) = ( j     - 0.5_wp ) * dy
520            surfaces%points(3,surfaces%npoints) = zw(k)
521         ENDIF
522         IF ( point_index(k,j+1,i+1) < 0 )  THEN
523            surfaces%npoints       = surfaces%npoints + 1   
524            point_index(k,j+1,i+1) = point_index_count
525            point_index_count      = point_index_count + 1 
526            surfaces%points(1,surfaces%npoints) = ( i + 1 - 0.5_wp ) * dx
527            surfaces%points(2,surfaces%npoints) = ( j + 1 - 0.5_wp ) * dy
528            surfaces%points(3,surfaces%npoints) = zw(k)
529         ENDIF
530         IF ( point_index(k,j+1,i) < 0 )  THEN
531            surfaces%npoints     = surfaces%npoints + 1   
532            point_index(k,j+1,i) = point_index_count
533            point_index_count    = point_index_count + 1 
534            surfaces%points(1,surfaces%npoints) = ( i     - 0.5_wp ) * dx
535            surfaces%points(2,surfaces%npoints) = ( j + 1 - 0.5_wp ) * dy
536            surfaces%points(3,surfaces%npoints) = zw(k)
537         ENDIF
538         
539         npg                        = npg + 1
540         surfaces%polygons(1,npg)   = 4
541         surfaces%polygons(2,npg)   = point_index(k,j,i)
542         surfaces%polygons(3,npg)   = point_index(k,j,i+1)
543         surfaces%polygons(4,npg)   = point_index(k,j+1,i+1)
544         surfaces%polygons(5,npg)   = point_index(k,j+1,i) 
545      ENDDO
546
547      DO  m = 1, surf_usm_h%ns
548         i = surf_usm_h%i(m) + surf_usm_h%ioff
549         j = surf_usm_h%j(m) + surf_usm_h%joff
550         k = surf_usm_h%k(m) + surf_usm_h%koff
551
552         IF ( point_index(k,j,i) < 0 )  THEN
553            surfaces%npoints   = surfaces%npoints + 1   
554            point_index(k,j,i) = point_index_count
555            point_index_count  = point_index_count + 1 
556            surfaces%points(1,surfaces%npoints) = ( i - 0.5_wp ) * dx
557            surfaces%points(2,surfaces%npoints) = ( j - 0.5_wp ) * dy
558            surfaces%points(3,surfaces%npoints) = zw(k)
559         ENDIF
560         IF ( point_index(k,j,i+1) < 0 )  THEN
561            surfaces%npoints     = surfaces%npoints + 1   
562            point_index(k,j,i+1) = point_index_count
563            point_index_count    = point_index_count + 1 
564            surfaces%points(1,surfaces%npoints) = ( i + 1 - 0.5_wp ) * dx
565            surfaces%points(2,surfaces%npoints) = ( j     - 0.5_wp ) * dy
566            surfaces%points(3,surfaces%npoints) = zw(k)
567         ENDIF
568         IF ( point_index(k,j+1,i+1) < 0 )  THEN
569            surfaces%npoints       = surfaces%npoints + 1   
570            point_index(k,j+1,i+1) = point_index_count
571            point_index_count      = point_index_count + 1 
572            surfaces%points(1,surfaces%npoints) = ( i + 1 - 0.5_wp ) * dx
573            surfaces%points(2,surfaces%npoints) = ( j + 1 - 0.5_wp ) * dy
574            surfaces%points(3,surfaces%npoints) = zw(k)
575         ENDIF
576         IF ( point_index(k,j+1,i) < 0 )  THEN
577            surfaces%npoints     = surfaces%npoints + 1   
578            point_index(k,j+1,i) = point_index_count
579            point_index_count    = point_index_count + 1 
580            surfaces%points(1,surfaces%npoints) = ( i     - 0.5_wp ) * dx
581            surfaces%points(2,surfaces%npoints) = ( j + 1 - 0.5_wp ) * dy
582            surfaces%points(3,surfaces%npoints) = zw(k)
583         ENDIF
584         
585         npg                        = npg + 1
586         surfaces%polygons(1,npg)   = 4
587         surfaces%polygons(2,npg)   = point_index(k,j,i)
588         surfaces%polygons(3,npg)   = point_index(k,j,i+1)
589         surfaces%polygons(4,npg)   = point_index(k,j+1,i+1)
590         surfaces%polygons(5,npg)   = point_index(k,j+1,i)   
591      ENDDO
592
593      DO  l = 0, 3
594         DO  m = 1, surf_def_v(l)%ns
595!
596!--         Determine the indices of the respective grid cell inside the topography.
597!--         Please note, j-index for north-facing surfaces ( l==0 ) is
598!--         identical to the reference j-index outside the grid box.
599!--         Equivalent for east-facing surfaces and i-index.
600            i = surf_def_v(l)%i(m) + MERGE( surf_def_v(l)%ioff, 0, l == 3 )
601            j = surf_def_v(l)%j(m) + MERGE( surf_def_v(l)%joff, 0, l == 1 )
602            k = surf_def_v(l)%k(m) + surf_def_v(l)%koff
603!
604!--         Lower left /front vertex
605            IF ( point_index(k,j,i) < 0 )  THEN
606               surfaces%npoints   = surfaces%npoints + 1   
607               point_index(k,j,i) = point_index_count
608               point_index_count  = point_index_count + 1 
609               surfaces%points(1,surfaces%npoints) = ( i - 0.5_wp ) * dx
610               surfaces%points(2,surfaces%npoints) = ( j - 0.5_wp ) * dy
611               surfaces%points(3,surfaces%npoints) = zw(k-1)
612            ENDIF
613!
614!--         Upper / lower right index for north- and south-facing surfaces
615            IF ( l == 0  .OR.  l == 1 )  THEN
616               IF ( point_index(k,j,i+1) < 0 )  THEN
617                  surfaces%npoints     = surfaces%npoints + 1   
618                  point_index(k,j,i+1) = point_index_count
619                  point_index_count    = point_index_count + 1
620                  surfaces%points(1,surfaces%npoints) = ( i + 1 - 0.5_wp ) * dx
621                  surfaces%points(2,surfaces%npoints) = ( j     - 0.5_wp ) * dy
622                  surfaces%points(3,surfaces%npoints) = zw(k-1)
623               ENDIF
624               IF ( point_index(k+1,j,i+1) < 0 )  THEN
625                  surfaces%npoints       = surfaces%npoints + 1   
626                  point_index(k+1,j,i+1) = point_index_count
627                  point_index_count      = point_index_count + 1
628                  surfaces%points(1,surfaces%npoints) = ( i + 1 - 0.5_wp ) * dx
629                  surfaces%points(2,surfaces%npoints) = ( j     - 0.5_wp ) * dy
630                  surfaces%points(3,surfaces%npoints) = zw(k)
631               ENDIF
632!
633!--         Upper / lower front index for east- and west-facing surfaces
634            ELSEIF ( l == 2  .OR.  l == 3 )  THEN
635               IF ( point_index(k,j+1,i) < 0 )  THEN
636                  surfaces%npoints     = surfaces%npoints + 1   
637                  point_index(k,j+1,i) = point_index_count
638                  point_index_count    = point_index_count + 1
639                  surfaces%points(1,surfaces%npoints) = ( i     - 0.5_wp ) * dx
640                  surfaces%points(2,surfaces%npoints) = ( j + 1 - 0.5_wp ) * dy
641                  surfaces%points(3,surfaces%npoints) = zw(k-1)
642               ENDIF
643               IF ( point_index(k+1,j+1,i) < 0 )  THEN
644                  surfaces%npoints       = surfaces%npoints + 1   
645                  point_index(k+1,j+1,i) = point_index_count
646                  point_index_count      = point_index_count + 1
647                  surfaces%points(1,surfaces%npoints) = ( i     - 0.5_wp ) * dx
648                  surfaces%points(2,surfaces%npoints) = ( j + 1 - 0.5_wp ) * dy
649                  surfaces%points(3,surfaces%npoints) = zw(k)
650               ENDIF
651            ENDIF
652!
653!--         Upper left / front vertex
654            IF ( point_index(k+1,j,i) < 0 )  THEN
655               surfaces%npoints     = surfaces%npoints + 1   
656               point_index(k+1,j,i) = point_index_count
657               point_index_count    = point_index_count + 1
658               surfaces%points(1,surfaces%npoints) = ( i - 0.5_wp ) * dx
659               surfaces%points(2,surfaces%npoints) = ( j - 0.5_wp ) * dy
660               surfaces%points(3,surfaces%npoints) = zw(k)
661            ENDIF
662           
663            npg = npg + 1           
664            IF ( l == 0  .OR.  l == 1 )  THEN
665               surfaces%polygons(1,npg)   = 4
666               surfaces%polygons(2,npg)   = point_index(k,j,i)
667               surfaces%polygons(3,npg)   = point_index(k,j,i+1)
668               surfaces%polygons(4,npg)   = point_index(k+1,j,i+1)
669               surfaces%polygons(5,npg)   = point_index(k+1,j,i) 
670            ELSE
671               surfaces%polygons(1,npg)   = 4
672               surfaces%polygons(2,npg)   = point_index(k,j,i)
673               surfaces%polygons(3,npg)   = point_index(k,j+1,i)
674               surfaces%polygons(4,npg)   = point_index(k+1,j+1,i)
675               surfaces%polygons(5,npg)   = point_index(k+1,j,i)
676            ENDIF
677           
678         ENDDO
679
680         DO  m = 1, surf_lsm_v(l)%ns
681            i = surf_lsm_v(l)%i(m) + MERGE( surf_lsm_v(l)%ioff, 0, l == 3 )
682            j = surf_lsm_v(l)%j(m) + MERGE( surf_lsm_v(l)%joff, 0, l == 1 )
683            k = surf_lsm_v(l)%k(m) + surf_lsm_v(l)%koff
684!
685!--         Lower left /front vertex
686            IF ( point_index(k,j,i) < 0 )  THEN
687               surfaces%npoints   = surfaces%npoints + 1   
688               point_index(k,j,i) = point_index_count
689               point_index_count  = point_index_count + 1
690               surfaces%points(1,surfaces%npoints) = ( i - 0.5_wp ) * dx
691               surfaces%points(2,surfaces%npoints) = ( j - 0.5_wp ) * dy
692               surfaces%points(3,surfaces%npoints) = zw(k-1)
693            ENDIF
694!
695!--         Upper / lower right index for north- and south-facing surfaces
696            IF ( l == 0  .OR.  l == 1 )  THEN
697               IF ( point_index(k,j,i+1) < 0 )  THEN
698                  surfaces%npoints     = surfaces%npoints + 1   
699                  point_index(k,j,i+1) = point_index_count
700                  point_index_count    = point_index_count + 1
701                  surfaces%points(1,surfaces%npoints) = ( i + 1 - 0.5_wp ) * dx
702                  surfaces%points(2,surfaces%npoints) = ( j     - 0.5_wp ) * dy
703                  surfaces%points(3,surfaces%npoints) = zw(k-1)
704               ENDIF
705               IF ( point_index(k+1,j,i+1) < 0 )  THEN
706                  surfaces%npoints       = surfaces%npoints + 1   
707                  point_index(k+1,j,i+1) = point_index_count
708                  point_index_count      = point_index_count + 1
709                  surfaces%points(1,surfaces%npoints) = ( i + 1 - 0.5_wp ) * dx
710                  surfaces%points(2,surfaces%npoints) = ( j     - 0.5_wp ) * dy
711                  surfaces%points(3,surfaces%npoints) = zw(k)
712               ENDIF
713!
714!--         Upper / lower front index for east- and west-facing surfaces
715            ELSEIF ( l == 2  .OR.  l == 3 )  THEN
716               IF ( point_index(k,j+1,i) < 0 )  THEN
717                  surfaces%npoints     = surfaces%npoints + 1   
718                  point_index(k,j+1,i) = point_index_count
719                  point_index_count    = point_index_count + 1
720                  surfaces%points(1,surfaces%npoints) = ( i     - 0.5_wp ) * dx
721                  surfaces%points(2,surfaces%npoints) = ( j + 1 - 0.5_wp ) * dy
722                  surfaces%points(3,surfaces%npoints) = zw(k-1)
723               ENDIF
724               IF ( point_index(k+1,j+1,i) < 0 )  THEN
725                  surfaces%npoints       = surfaces%npoints + 1   
726                  point_index(k+1,j+1,i) = point_index_count
727                  point_index_count      = point_index_count + 1
728                  surfaces%points(1,surfaces%npoints) = ( i     - 0.5_wp ) * dx
729                  surfaces%points(2,surfaces%npoints) = ( j + 1 - 0.5_wp ) * dy
730                  surfaces%points(3,surfaces%npoints) = zw(k)
731               ENDIF
732            ENDIF
733!
734!--         Upper left / front vertex
735            IF ( point_index(k+1,j,i) < 0 )  THEN
736               surfaces%npoints     = surfaces%npoints + 1   
737               point_index(k+1,j,i) = point_index_count
738               point_index_count    = point_index_count + 1
739               surfaces%points(1,surfaces%npoints) = ( i - 0.5_wp ) * dx
740               surfaces%points(2,surfaces%npoints) = ( j - 0.5_wp ) * dy
741               surfaces%points(3,surfaces%npoints) = zw(k)
742            ENDIF
743           
744            npg = npg + 1           
745            IF ( l == 0  .OR.  l == 1 )  THEN
746               surfaces%polygons(1,npg)   = 4
747               surfaces%polygons(2,npg)   = point_index(k,j,i)
748               surfaces%polygons(3,npg)   = point_index(k,j,i+1)
749               surfaces%polygons(4,npg)   = point_index(k+1,j,i+1)
750               surfaces%polygons(5,npg)   = point_index(k+1,j,i) 
751            ELSE
752               surfaces%polygons(1,npg)   = 4
753               surfaces%polygons(2,npg)   = point_index(k,j,i)
754               surfaces%polygons(3,npg)   = point_index(k,j+1,i)
755               surfaces%polygons(4,npg)   = point_index(k+1,j+1,i)
756               surfaces%polygons(5,npg)   = point_index(k+1,j,i)
757            ENDIF
758         ENDDO
759         DO  m = 1, surf_usm_v(l)%ns
760            i = surf_usm_v(l)%i(m) + MERGE( surf_usm_v(l)%ioff, 0, l == 3 )
761            j = surf_usm_v(l)%j(m) + MERGE( surf_usm_v(l)%joff, 0, l == 1 )
762            k = surf_usm_v(l)%k(m) + surf_usm_v(l)%koff
763!
764!--         Lower left /front vertex
765            IF ( point_index(k,j,i) < 0 )  THEN
766               surfaces%npoints   = surfaces%npoints + 1   
767               point_index(k,j,i) = point_index_count
768               point_index_count  = point_index_count + 1
769               surfaces%points(1,surfaces%npoints) = ( i - 0.5_wp ) * dx
770               surfaces%points(2,surfaces%npoints) = ( j - 0.5_wp ) * dy
771               surfaces%points(3,surfaces%npoints) = zw(k-1)
772            ENDIF
773!
774!--         Upper / lower right index for north- and south-facing surfaces
775            IF ( l == 0  .OR.  l == 1 )  THEN
776               IF ( point_index(k,j,i+1) < 0 )  THEN
777                  surfaces%npoints     = surfaces%npoints + 1   
778                  point_index(k,j,i+1) = point_index_count
779                  point_index_count    = point_index_count + 1
780                  surfaces%points(1,surfaces%npoints) = ( i + 1 - 0.5_wp ) * dx
781                  surfaces%points(2,surfaces%npoints) = ( j     - 0.5_wp ) * dy
782                  surfaces%points(3,surfaces%npoints) = zw(k-1)
783               ENDIF
784               IF ( point_index(k+1,j,i+1) < 0 )  THEN
785                  surfaces%npoints       = surfaces%npoints + 1   
786                  point_index(k+1,j,i+1) = point_index_count
787                  point_index_count      = point_index_count + 1
788                  surfaces%points(1,surfaces%npoints) = ( i + 1 - 0.5_wp ) * dx
789                  surfaces%points(2,surfaces%npoints) = ( j     - 0.5_wp ) * dy
790                  surfaces%points(3,surfaces%npoints) = zw(k)
791               ENDIF
792!
793!--         Upper / lower front index for east- and west-facing surfaces
794            ELSEIF ( l == 2  .OR.  l == 3 )  THEN
795               IF ( point_index(k,j+1,i) < 0 )  THEN
796                  surfaces%npoints     = surfaces%npoints + 1   
797                  point_index(k,j+1,i) = point_index_count
798                  point_index_count    = point_index_count + 1
799                  surfaces%points(1,surfaces%npoints) = ( i     - 0.5_wp ) * dx
800                  surfaces%points(2,surfaces%npoints) = ( j + 1 - 0.5_wp ) * dy
801                  surfaces%points(3,surfaces%npoints) = zw(k-1)
802               ENDIF
803               IF ( point_index(k+1,j+1,i) < 0 )  THEN
804                  surfaces%npoints       = surfaces%npoints + 1   
805                  point_index(k+1,j+1,i) = point_index_count
806                  point_index_count      = point_index_count + 1
807                  surfaces%points(1,surfaces%npoints) = ( i     - 0.5_wp ) * dx
808                  surfaces%points(2,surfaces%npoints) = ( j + 1 - 0.5_wp ) * dy
809                  surfaces%points(3,surfaces%npoints) = zw(k)
810               ENDIF
811            ENDIF
812!
813!--         Upper left / front vertex
814            IF ( point_index(k+1,j,i) < 0 )  THEN
815               surfaces%npoints     = surfaces%npoints + 1   
816               point_index(k+1,j,i) = point_index_count
817               point_index_count    = point_index_count + 1
818               surfaces%points(1,surfaces%npoints) = ( i - 0.5_wp ) * dx
819               surfaces%points(2,surfaces%npoints) = ( j - 0.5_wp ) * dy
820               surfaces%points(3,surfaces%npoints) = zw(k)
821            ENDIF
822           
823            npg = npg + 1           
824            IF ( l == 0  .OR.  l == 1 )  THEN
825               surfaces%polygons(1,npg)   = 4
826               surfaces%polygons(2,npg)   = point_index(k,j,i)
827               surfaces%polygons(3,npg)   = point_index(k,j,i+1)
828               surfaces%polygons(4,npg)   = point_index(k+1,j,i+1)
829               surfaces%polygons(5,npg)   = point_index(k+1,j,i) 
830            ELSE
831               surfaces%polygons(1,npg)   = 4
832               surfaces%polygons(2,npg)   = point_index(k,j,i)
833               surfaces%polygons(3,npg)   = point_index(k,j+1,i)
834               surfaces%polygons(4,npg)   = point_index(k+1,j+1,i)
835               surfaces%polygons(5,npg)   = point_index(k+1,j,i)
836            ENDIF
837         ENDDO
838
839      ENDDO
840!
841!--   Deallocate temporary dummy variable
842      DEALLOCATE ( point_index )
843!
844!--   Sum-up total number of surface elements and vertices on domain. This
845!--   will be needed for post-processing.
846      surfaces%npoints_total = 0
847#if defined( __parallel )
848       CALL MPI_ALLREDUCE( surfaces%npoints, surfaces%npoints_total, 1,        &
849                           MPI_INTEGER, MPI_SUM, comm2d, ierr )
850       CALL MPI_ALLREDUCE( surfaces%ns, surfaces%ns_total, 1,                  &
851                           MPI_INTEGER, MPI_SUM, comm2d, ierr )
852#else
853       surfaces%npoints_total = surfaces%npoints
854       surfaces%ns_total      = surfaces%ns
855#endif
856
857   END SUBROUTINE surface_output_init
858   
859!------------------------------------------------------------------------------!
860! Description:
861! ------------
862!> Routine for controlling the data output. Surface data is collected from
863!> different types of surfaces (default, natural, urban) and different
864!> orientation and written to one 1D-output array. Further, NetCDF routines
865!> are called to write the surface data in the respective NetCDF files.
866!------------------------------------------------------------------------------!   
867   SUBROUTINE surface_output( av )
868   
869      USE control_parameters,                                                  &
870          ONLY:  io_blocks, io_group, time_since_reference_point
871
872      USE pegrid,                                                              &
873          ONLY:  comm2d, ierr
874
875   
876      IMPLICIT NONE
877
878      CHARACTER(LEN=100) ::  trimvar = ' ' !< dummy for single output variable
879     
880      INTEGER(iwp) ::  av     !< id indicating average or non-average data output
881      INTEGER(iwp) ::  i      !< loop index
882      INTEGER(iwp) ::  n_out  !< counter variables for surface output
883
884!
885!--   Return, if nothing to output
886      IF ( dosurf_no(av) == 0 )  RETURN
887!
888!--   Open files
889      CALL check_open( 25+av )
890!
891!--   Write coordinates
892      IF ( .NOT. first_output(av) )  THEN
893         DO  i = 0, io_blocks-1
894            IF ( i == io_group )  THEN
895               WRITE ( 25+av )  surfaces%npoints
896               WRITE ( 25+av )  surfaces%npoints_total
897               WRITE ( 25+av )  surfaces%ns
898               WRITE ( 25+av )  surfaces%ns_total
899               WRITE ( 25+av )  surfaces%points
900               WRITE ( 25+av )  surfaces%polygons
901            ENDIF
902#if defined( __parallel )
903            CALL MPI_BARRIER( comm2d, ierr )
904#endif
905            first_output(av) = .TRUE.
906         ENDDO
907      ENDIF
908
909      n_out = 0
910      DO  WHILE ( dosurf(av,n_out+1)(1:1) /= ' ' )
911
912         n_out   = n_out + 1
913         trimvar = TRIM( dosurf(av,n_out) )
914!
915!--      Set the output array to the _FillValue in case it is not
916!--      defined for each type of surface.
917         surfaces%var_out = surfaces%fillvalue
918         SELECT CASE ( trimvar )
919
920            CASE ( 'us' )
921!
922!--            Output of instantaneous data
923               IF ( av == 0 )  THEN
924                  CALL surface_output_collect( surf_def_h(0)%us,               &
925                                               surf_def_h(1)%us,               &
926                                               surf_lsm_h%us,                  &
927                                               surf_usm_h%us,                  &
928                                               surf_def_v(0)%us,               &
929                                               surf_lsm_v(0)%us,               &
930                                               surf_usm_v(0)%us,               &
931                                               surf_def_v(1)%us,               &
932                                               surf_lsm_v(1)%us,               &
933                                               surf_usm_v(1)%us,               &
934                                               surf_def_v(2)%us,               &
935                                               surf_lsm_v(2)%us,               &
936                                               surf_usm_v(2)%us,               &
937                                               surf_def_v(3)%us,               &
938                                               surf_lsm_v(3)%us,               &
939                                               surf_usm_v(3)%us ) 
940               ELSE
941!
942!--               Output of averaged data
943                  surfaces%var_out(:) = surfaces%var_av(:,n_out) /             &
944                                        REAL( average_count_surf, KIND=wp )
945                  surfaces%var_av(:,n_out) = 0.0_wp
946                                                       
947               ENDIF
948
949            CASE ( 'ts' )
950!
951!--            Output of instantaneous data
952               IF ( av == 0 )  THEN
953                  CALL surface_output_collect( surf_def_h(0)%ts,               &
954                                               surf_def_h(1)%ts,               &
955                                               surf_lsm_h%ts,                  &
956                                               surf_usm_h%ts,                  &
957                                               surf_def_v(0)%ts,               &
958                                               surf_lsm_v(0)%ts,               &
959                                               surf_usm_v(0)%ts,               &
960                                               surf_def_v(1)%ts,               &
961                                               surf_lsm_v(1)%ts,               &
962                                               surf_usm_v(1)%ts,               &
963                                               surf_def_v(2)%ts,               &
964                                               surf_lsm_v(2)%ts,               &
965                                               surf_usm_v(2)%ts,               &
966                                               surf_def_v(3)%ts,               &
967                                               surf_lsm_v(3)%ts,               &
968                                               surf_usm_v(3)%ts ) 
969               ELSE
970!
971!--               Output of averaged data
972                  surfaces%var_out(:) = surfaces%var_av(:,n_out) /             &
973                                        REAL( average_count_surf, KIND=wp )
974                  surfaces%var_av(:,n_out) = 0.0_wp
975                                                       
976               ENDIF
977
978            CASE ( 'qs' )
979!
980!--            Output of instantaneous data
981               IF ( av == 0 )  THEN
982                  CALL surface_output_collect( surf_def_h(0)%qs,               &
983                                               surf_def_h(1)%qs,               &
984                                               surf_lsm_h%qs,                  &
985                                               surf_usm_h%qs,                  &
986                                               surf_def_v(0)%qs,               &
987                                               surf_lsm_v(0)%qs,               &
988                                               surf_usm_v(0)%qs,               &
989                                               surf_def_v(1)%qs,               &
990                                               surf_lsm_v(1)%qs,               &
991                                               surf_usm_v(1)%qs,               &
992                                               surf_def_v(2)%qs,               &
993                                               surf_lsm_v(2)%qs,               &
994                                               surf_usm_v(2)%qs,               &
995                                               surf_def_v(3)%qs,               &
996                                               surf_lsm_v(3)%qs,               &
997                                               surf_usm_v(3)%qs ) 
998               ELSE
999!
1000!--               Output of averaged data
1001                  surfaces%var_out(:) = surfaces%var_av(:,n_out) /             &
1002                                        REAL( average_count_surf, KIND=wp )
1003                  surfaces%var_av(:,n_out) = 0.0_wp
1004                                                       
1005               ENDIF
1006
1007            CASE ( 'ss' )
1008!
1009!--            Output of instantaneous data
1010               IF ( av == 0 )  THEN
1011                  CALL surface_output_collect( surf_def_h(0)%ss,               &
1012                                               surf_def_h(1)%ss,               &
1013                                               surf_lsm_h%ss,                  &
1014                                               surf_usm_h%ss,                  &
1015                                               surf_def_v(0)%ss,               &
1016                                               surf_lsm_v(0)%ss,               &
1017                                               surf_usm_v(0)%ss,               &
1018                                               surf_def_v(1)%ss,               &
1019                                               surf_lsm_v(1)%ss,               &
1020                                               surf_usm_v(1)%ss,               &
1021                                               surf_def_v(2)%ss,               &
1022                                               surf_lsm_v(2)%ss,               &
1023                                               surf_usm_v(2)%ss,               &
1024                                               surf_def_v(3)%ss,               &
1025                                               surf_lsm_v(3)%ss,               &
1026                                               surf_usm_v(3)%ss ) 
1027               ELSE
1028!
1029!--               Output of averaged data
1030                  surfaces%var_out(:) = surfaces%var_av(:,n_out) /             &
1031                                        REAL( average_count_surf, KIND=wp )
1032                  surfaces%var_av(:,n_out) = 0.0_wp
1033                                                       
1034               ENDIF
1035
1036            CASE ( 'qcs' )
1037!
1038!--            Output of instantaneous data
1039               IF ( av == 0 )  THEN
1040                  CALL surface_output_collect( surf_def_h(0)%qcs,              &
1041                                               surf_def_h(1)%qcs,              &
1042                                               surf_lsm_h%qcs,                 &
1043                                               surf_usm_h%qcs,                 &
1044                                               surf_def_v(0)%qcs,              &
1045                                               surf_lsm_v(0)%qcs,              &
1046                                               surf_usm_v(0)%qcs,              &
1047                                               surf_def_v(1)%qcs,              &
1048                                               surf_lsm_v(1)%qcs,              &
1049                                               surf_usm_v(1)%qcs,              &
1050                                               surf_def_v(2)%qcs,              &
1051                                               surf_lsm_v(2)%qcs,              &
1052                                               surf_usm_v(2)%qcs,              &
1053                                               surf_def_v(3)%qcs,              &
1054                                               surf_lsm_v(3)%qcs,              &
1055                                               surf_usm_v(3)%qcs ) 
1056               ELSE
1057!
1058!--               Output of averaged data
1059                  surfaces%var_out(:) = surfaces%var_av(:,n_out) /             &
1060                                        REAL( average_count_surf, KIND=wp )
1061                  surfaces%var_av(:,n_out) = 0.0_wp
1062                                                       
1063               ENDIF
1064
1065            CASE ( 'ncs' )
1066!
1067!--            Output of instantaneous data
1068               IF ( av == 0 )  THEN
1069                  CALL surface_output_collect( surf_def_h(0)%ncs,              &
1070                                               surf_def_h(1)%ncs,              &
1071                                               surf_lsm_h%ncs,                 &
1072                                               surf_usm_h%ncs,                 &
1073                                               surf_def_v(0)%ncs,              &
1074                                               surf_lsm_v(0)%ncs,              &
1075                                               surf_usm_v(0)%ncs,              &
1076                                               surf_def_v(1)%ncs,              &
1077                                               surf_lsm_v(1)%ncs,              &
1078                                               surf_usm_v(1)%ncs,              &
1079                                               surf_def_v(2)%ncs,              &
1080                                               surf_lsm_v(2)%ncs,              &
1081                                               surf_usm_v(2)%ncs,              &
1082                                               surf_def_v(3)%ncs,              &
1083                                               surf_lsm_v(3)%ncs,              &
1084                                               surf_usm_v(3)%ncs ) 
1085               ELSE
1086!
1087!--               Output of averaged data
1088                  surfaces%var_out(:) = surfaces%var_av(:,n_out) /             &
1089                                        REAL( average_count_surf, KIND=wp )
1090                  surfaces%var_av(:,n_out) = 0.0_wp
1091                                                       
1092               ENDIF
1093
1094            CASE ( 'qrs' )
1095!
1096!--            Output of instantaneous data
1097               IF ( av == 0 )  THEN
1098                  CALL surface_output_collect( surf_def_h(0)%qrs,              &
1099                                               surf_def_h(1)%qrs,              &
1100                                               surf_lsm_h%qrs,                 &
1101                                               surf_usm_h%qrs,                 &
1102                                               surf_def_v(0)%qrs,              &
1103                                               surf_lsm_v(0)%qrs,              &
1104                                               surf_usm_v(0)%qrs,              &
1105                                               surf_def_v(1)%qrs,              &
1106                                               surf_lsm_v(1)%qrs,              &
1107                                               surf_usm_v(1)%qrs,              &
1108                                               surf_def_v(2)%qrs,              &
1109                                               surf_lsm_v(2)%qrs,              &
1110                                               surf_usm_v(2)%qrs,              &
1111                                               surf_def_v(3)%qrs,              &
1112                                               surf_lsm_v(3)%qrs,              &
1113                                               surf_usm_v(3)%qrs ) 
1114               ELSE
1115!
1116!--               Output of averaged data
1117                  surfaces%var_out(:) = surfaces%var_av(:,n_out) /             &
1118                                        REAL( average_count_surf, KIND=wp )
1119                  surfaces%var_av(:,n_out) = 0.0_wp
1120                                                       
1121               ENDIF
1122
1123            CASE ( 'nrs' )
1124!
1125!--            Output of instantaneous data
1126               IF ( av == 0 )  THEN
1127                  CALL surface_output_collect( surf_def_h(0)%nrs,              &
1128                                               surf_def_h(1)%nrs,              &
1129                                               surf_lsm_h%nrs,                 &
1130                                               surf_usm_h%nrs,                 &
1131                                               surf_def_v(0)%nrs,              &
1132                                               surf_lsm_v(0)%nrs,              &
1133                                               surf_usm_v(0)%nrs,              &
1134                                               surf_def_v(1)%nrs,              &
1135                                               surf_lsm_v(1)%nrs,              &
1136                                               surf_usm_v(1)%nrs,              &
1137                                               surf_def_v(2)%nrs,              &
1138                                               surf_lsm_v(2)%nrs,              &
1139                                               surf_usm_v(2)%nrs,              &
1140                                               surf_def_v(3)%nrs,              &
1141                                               surf_lsm_v(3)%nrs,              &
1142                                               surf_usm_v(3)%nrs ) 
1143               ELSE
1144!
1145!--               Output of averaged data
1146                  surfaces%var_out(:) = surfaces%var_av(:,n_out) /             &
1147                                        REAL( average_count_surf, KIND=wp )
1148                  surfaces%var_av(:,n_out) = 0.0_wp
1149                                                       
1150               ENDIF
1151
1152            CASE ( 'ol' )
1153!
1154!--            Output of instantaneous data
1155               IF ( av == 0 )  THEN
1156                  CALL surface_output_collect( surf_def_h(0)%ol,               &
1157                                               surf_def_h(1)%ol,               &
1158                                               surf_lsm_h%ol,                  &
1159                                               surf_usm_h%ol,                  &
1160                                               surf_def_v(0)%ol,               &
1161                                               surf_lsm_v(0)%ol,               &
1162                                               surf_usm_v(0)%ol,               &
1163                                               surf_def_v(1)%ol,               &
1164                                               surf_lsm_v(1)%ol,               &
1165                                               surf_usm_v(1)%ol,               &
1166                                               surf_def_v(2)%ol,               &
1167                                               surf_lsm_v(2)%ol,               &
1168                                               surf_usm_v(2)%ol,               &
1169                                               surf_def_v(3)%ol,               &
1170                                               surf_lsm_v(3)%ol,               &
1171                                               surf_usm_v(3)%ol ) 
1172               ELSE
1173!
1174!--               Output of averaged data
1175                  surfaces%var_out(:) = surfaces%var_av(:,n_out) /             &
1176                                        REAL( average_count_surf, KIND=wp )
1177                  surfaces%var_av(:,n_out) = 0.0_wp
1178                                                       
1179               ENDIF
1180
1181            CASE ( 'z0' )
1182!
1183!--            Output of instantaneous data
1184               IF ( av == 0 )  THEN
1185                  CALL surface_output_collect( surf_def_h(0)%z0,               &
1186                                               surf_def_h(1)%z0,               &
1187                                               surf_lsm_h%z0,                  &
1188                                               surf_usm_h%z0,                  &
1189                                               surf_def_v(0)%z0,               &
1190                                               surf_lsm_v(0)%z0,               &
1191                                               surf_usm_v(0)%z0,               &
1192                                               surf_def_v(1)%z0,               &
1193                                               surf_lsm_v(1)%z0,               &
1194                                               surf_usm_v(1)%z0,               &
1195                                               surf_def_v(2)%z0,               &
1196                                               surf_lsm_v(2)%z0,               &
1197                                               surf_usm_v(2)%z0,               &
1198                                               surf_def_v(3)%z0,               &
1199                                               surf_lsm_v(3)%z0,               &
1200                                               surf_usm_v(3)%z0 )
1201               ELSE
1202!
1203!--               Output of averaged data
1204                  surfaces%var_out(:) = surfaces%var_av(:,n_out) /             &
1205                                        REAL( average_count_surf, KIND=wp )
1206                  surfaces%var_av(:,n_out) = 0.0_wp
1207                                                       
1208               ENDIF
1209
1210            CASE ( 'z0h' )
1211!
1212!--            Output of instantaneous data
1213               IF ( av == 0 )  THEN
1214                  CALL surface_output_collect( surf_def_h(0)%z0h,              &
1215                                               surf_def_h(1)%z0h,              &
1216                                               surf_lsm_h%z0h,                 &
1217                                               surf_usm_h%z0h,                 &
1218                                               surf_def_v(0)%z0h,              &
1219                                               surf_lsm_v(0)%z0h,              &
1220                                               surf_usm_v(0)%z0h,              &
1221                                               surf_def_v(1)%z0h,              &
1222                                               surf_lsm_v(1)%z0h,              &
1223                                               surf_usm_v(1)%z0h,              &
1224                                               surf_def_v(2)%z0h,              &
1225                                               surf_lsm_v(2)%z0h,              &
1226                                               surf_usm_v(2)%z0h,              &
1227                                               surf_def_v(3)%z0h,              &
1228                                               surf_lsm_v(3)%z0h,              &
1229                                               surf_usm_v(3)%z0h )
1230               ELSE
1231!
1232!--               Output of averaged data
1233                  surfaces%var_out(:) = surfaces%var_av(:,n_out) /             &
1234                                        REAL( average_count_surf, KIND=wp )
1235                  surfaces%var_av(:,n_out) = 0.0_wp
1236                                                       
1237               ENDIF
1238
1239            CASE ( 'z0q' )
1240!
1241!--            Output of instantaneous data
1242               IF ( av == 0 )  THEN
1243                  CALL surface_output_collect( surf_def_h(0)%z0q,              &
1244                                               surf_def_h(1)%z0q,              &
1245                                               surf_lsm_h%z0q,                 &
1246                                               surf_usm_h%z0q,                 &
1247                                               surf_def_v(0)%z0q,              &
1248                                               surf_lsm_v(0)%z0q,              &
1249                                               surf_usm_v(0)%z0q,              &
1250                                               surf_def_v(1)%z0q,              &
1251                                               surf_lsm_v(1)%z0q,              &
1252                                               surf_usm_v(1)%z0q,              &
1253                                               surf_def_v(2)%z0q,              &
1254                                               surf_lsm_v(2)%z0q,              &
1255                                               surf_usm_v(2)%z0q,              &
1256                                               surf_def_v(3)%z0q,              &
1257                                               surf_lsm_v(3)%z0q,              &
1258                                               surf_usm_v(3)%z0q ) 
1259               ELSE
1260!
1261!--               Output of averaged data
1262                  surfaces%var_out(:) = surfaces%var_av(:,n_out) /             &
1263                                        REAL( average_count_surf, KIND=wp )
1264                  surfaces%var_av(:,n_out) = 0.0_wp
1265
1266               ENDIF
1267
1268            CASE ( 'theta1' )
1269!
1270!--            Output of instantaneous data
1271               IF ( av == 0 )  THEN
1272                  CALL surface_output_collect( surf_def_h(0)%pt1,              &
1273                                               surf_def_h(1)%pt1,              &
1274                                               surf_lsm_h%pt1,                 &
1275                                               surf_usm_h%pt1,                 &
1276                                               surf_def_v(0)%pt1,              &
1277                                               surf_lsm_v(0)%pt1,              &
1278                                               surf_usm_v(0)%pt1,              &
1279                                               surf_def_v(1)%pt1,              &
1280                                               surf_lsm_v(1)%pt1,              &
1281                                               surf_usm_v(1)%pt1,              &
1282                                               surf_def_v(2)%pt1,              &
1283                                               surf_lsm_v(2)%pt1,              &
1284                                               surf_usm_v(2)%pt1,              &
1285                                               surf_def_v(3)%pt1,              &
1286                                               surf_lsm_v(3)%pt1,              &
1287                                               surf_usm_v(3)%pt1 )
1288               ELSE
1289!
1290!--               Output of averaged data
1291                  surfaces%var_out(:) = surfaces%var_av(:,n_out) /             &
1292                                        REAL( average_count_surf, KIND=wp )
1293                  surfaces%var_av(:,n_out) = 0.0_wp
1294                                                       
1295               ENDIF
1296
1297            CASE ( 'qv1' )
1298!
1299!--            Output of instantaneous data
1300               IF ( av == 0 )  THEN
1301                  CALL surface_output_collect( surf_def_h(0)%qv1,              &
1302                                               surf_def_h(1)%qv1,              &
1303                                               surf_lsm_h%qv1,                 &
1304                                               surf_usm_h%qv1,                 &
1305                                               surf_def_v(0)%qv1,              &
1306                                               surf_lsm_v(0)%qv1,              &
1307                                               surf_usm_v(0)%qv1,              &
1308                                               surf_def_v(1)%qv1,              &
1309                                               surf_lsm_v(1)%qv1,              &
1310                                               surf_usm_v(1)%qv1,              &
1311                                               surf_def_v(2)%qv1,              &
1312                                               surf_lsm_v(2)%qv1,              &
1313                                               surf_usm_v(2)%qv1,              &
1314                                               surf_def_v(3)%qv1,              &
1315                                               surf_lsm_v(3)%qv1,              &
1316                                               surf_usm_v(3)%qv1 )
1317               ELSE
1318!
1319!--               Output of averaged data
1320                  surfaces%var_out(:) = surfaces%var_av(:,n_out) /             &
1321                                        REAL( average_count_surf, KIND=wp )
1322                  surfaces%var_av(:,n_out) = 0.0_wp
1323                                                       
1324               ENDIF
1325
1326            CASE ( 'thetav1' )
1327!
1328!--            Output of instantaneous data
1329               IF ( av == 0 )  THEN
1330                  CALL surface_output_collect( surf_def_h(0)%vpt1,             &
1331                                               surf_def_h(1)%vpt1,             &
1332                                               surf_lsm_h%vpt1,                &
1333                                               surf_usm_h%vpt1,                &
1334                                               surf_def_v(0)%vpt1,             &
1335                                               surf_lsm_v(0)%vpt1,             &
1336                                               surf_usm_v(0)%vpt1,             &
1337                                               surf_def_v(1)%vpt1,             &
1338                                               surf_lsm_v(1)%vpt1,             &
1339                                               surf_usm_v(1)%vpt1,             &
1340                                               surf_def_v(2)%vpt1,             &
1341                                               surf_lsm_v(2)%vpt1,             &
1342                                               surf_usm_v(2)%vpt1,             &
1343                                               surf_def_v(3)%vpt1,             &
1344                                               surf_lsm_v(3)%vpt1,             &
1345                                               surf_usm_v(3)%vpt1 )
1346               ELSE
1347!
1348!--               Output of averaged data
1349                  surfaces%var_out(:) = surfaces%var_av(:,n_out) /             &
1350                                        REAL( average_count_surf, KIND=wp )
1351                  surfaces%var_av(:,n_out) = 0.0_wp
1352                                                       
1353               ENDIF
1354
1355            CASE ( 'usws' )
1356!
1357!--            Output of instantaneous data
1358               IF ( av == 0 )  THEN
1359                  CALL surface_output_collect( surf_def_h(0)%usws,             &
1360                                               surf_def_h(1)%usws,             &
1361                                               surf_lsm_h%usws,                &
1362                                               surf_usm_h%usws,                &
1363                                               surf_def_v(0)%usws,             &
1364                                               surf_lsm_v(0)%usws,             &
1365                                               surf_usm_v(0)%usws,             &
1366                                               surf_def_v(1)%usws,             &
1367                                               surf_lsm_v(1)%usws,             &
1368                                               surf_usm_v(1)%usws,             &
1369                                               surf_def_v(2)%usws,             &
1370                                               surf_lsm_v(2)%usws,             &
1371                                               surf_usm_v(2)%usws,             &
1372                                               surf_def_v(3)%usws,             &
1373                                               surf_lsm_v(3)%usws,             &
1374                                               surf_usm_v(3)%usws )
1375               ELSE
1376!
1377!--               Output of averaged data
1378                  surfaces%var_out(:) = surfaces%var_av(:,n_out) /             &
1379                                        REAL( average_count_surf, KIND=wp )
1380                  surfaces%var_av(:,n_out) = 0.0_wp
1381                                                       
1382               ENDIF
1383
1384            CASE ( 'vsws' )
1385!
1386!--            Output of instantaneous data
1387               IF ( av == 0 )  THEN
1388                  CALL surface_output_collect( surf_def_h(0)%vsws,             &
1389                                               surf_def_h(1)%vsws,             &
1390                                               surf_lsm_h%vsws,                &
1391                                               surf_usm_h%vsws,                &
1392                                               surf_def_v(0)%vsws,             &
1393                                               surf_lsm_v(0)%vsws,             &
1394                                               surf_usm_v(0)%vsws,             &
1395                                               surf_def_v(1)%vsws,             &
1396                                               surf_lsm_v(1)%vsws,             &
1397                                               surf_usm_v(1)%vsws,             &
1398                                               surf_def_v(2)%vsws,             &
1399                                               surf_lsm_v(2)%vsws,             &
1400                                               surf_usm_v(2)%vsws,             &
1401                                               surf_def_v(3)%vsws,             &
1402                                               surf_lsm_v(3)%vsws,             &
1403                                               surf_usm_v(3)%vsws )
1404               ELSE
1405!
1406!--               Output of averaged data
1407                  surfaces%var_out(:) = surfaces%var_av(:,n_out) /             &
1408                                        REAL( average_count_surf, KIND=wp )
1409                  surfaces%var_av(:,n_out) = 0.0_wp
1410                                                       
1411               ENDIF
1412
1413            CASE ( 'shf' )
1414!
1415!--            Output of instantaneous data
1416               IF ( av == 0 )  THEN
1417                  CALL surface_output_collect( surf_def_h(0)%shf,              &
1418                                               surf_def_h(1)%shf,              &
1419                                               surf_lsm_h%shf,                 &
1420                                               surf_usm_h%shf,                 &
1421                                               surf_def_v(0)%shf,              &
1422                                               surf_lsm_v(0)%shf,              &
1423                                               surf_usm_v(0)%shf,              &
1424                                               surf_def_v(1)%shf,              &
1425                                               surf_lsm_v(1)%shf,              &
1426                                               surf_usm_v(1)%shf,              &
1427                                               surf_def_v(2)%shf,              &
1428                                               surf_lsm_v(2)%shf,              &
1429                                               surf_usm_v(2)%shf,              &
1430                                               surf_def_v(3)%shf,              &
1431                                               surf_lsm_v(3)%shf,              &
1432                                               surf_usm_v(3)%shf )
1433               ELSE
1434!
1435!--               Output of averaged data
1436                  surfaces%var_out(:) = surfaces%var_av(:,n_out) /             &
1437                                        REAL( average_count_surf, KIND=wp )
1438                  surfaces%var_av(:,n_out) = 0.0_wp
1439               ENDIF
1440
1441            CASE ( 'qsws' )
1442!
1443!--            Output of instantaneous data
1444               IF ( av == 0 )  THEN
1445                  CALL surface_output_collect( surf_def_h(0)%qsws,             &
1446                                               surf_def_h(1)%qsws,             &
1447                                               surf_lsm_h%qsws,                &
1448                                               surf_usm_h%qsws,                &
1449                                               surf_def_v(0)%qsws,             &
1450                                               surf_lsm_v(0)%qsws,             &
1451                                               surf_usm_v(0)%qsws,             &
1452                                               surf_def_v(1)%qsws,             &
1453                                               surf_lsm_v(1)%qsws,             &
1454                                               surf_usm_v(1)%qsws,             &
1455                                               surf_def_v(2)%qsws,             &
1456                                               surf_lsm_v(2)%qsws,             &
1457                                               surf_usm_v(2)%qsws,             &
1458                                               surf_def_v(3)%qsws,             &
1459                                               surf_lsm_v(3)%qsws,             &
1460                                               surf_usm_v(3)%qsws )
1461               ELSE
1462!
1463!--               Output of averaged data
1464                  surfaces%var_out(:) = surfaces%var_av(:,n_out) /             &
1465                                        REAL( average_count_surf, KIND=wp )
1466                  surfaces%var_av(:,n_out) = 0.0_wp
1467                                                       
1468               ENDIF
1469
1470            CASE ( 'ssws' )
1471!
1472!--            Output of instantaneous data
1473               IF ( av == 0 )  THEN
1474                  CALL surface_output_collect( surf_def_h(0)%ssws,             &
1475                                               surf_def_h(1)%ssws,             &
1476                                               surf_lsm_h%ssws,                &
1477                                               surf_usm_h%ssws,                &
1478                                               surf_def_v(0)%ssws,             &
1479                                               surf_lsm_v(0)%ssws,             &
1480                                               surf_usm_v(0)%ssws,             &
1481                                               surf_def_v(1)%ssws,             &
1482                                               surf_lsm_v(1)%ssws,             &
1483                                               surf_usm_v(1)%ssws,             &
1484                                               surf_def_v(2)%ssws,             &
1485                                               surf_lsm_v(2)%ssws,             &
1486                                               surf_usm_v(2)%ssws,             &
1487                                               surf_def_v(3)%ssws,             &
1488                                               surf_lsm_v(3)%ssws,             &
1489                                               surf_usm_v(3)%ssws )
1490               ELSE
1491!
1492!--               Output of averaged data
1493                  surfaces%var_out(:) = surfaces%var_av(:,n_out) /             &
1494                                        REAL( average_count_surf, KIND=wp )
1495                  surfaces%var_av(:,n_out) = 0.0_wp
1496                                                       
1497               ENDIF
1498
1499            CASE ( 'qcsws' )
1500!
1501!--            Output of instantaneous data
1502               IF ( av == 0 )  THEN
1503                  CALL surface_output_collect( surf_def_h(0)%qcsws,            &
1504                                               surf_def_h(1)%qcsws,            &
1505                                               surf_lsm_h%qcsws,               &
1506                                               surf_usm_h%qcsws,               &
1507                                               surf_def_v(0)%qcsws,            &
1508                                               surf_lsm_v(0)%qcsws,            &
1509                                               surf_usm_v(0)%qcsws,            &
1510                                               surf_def_v(1)%qcsws,            &
1511                                               surf_lsm_v(1)%qcsws,            &
1512                                               surf_usm_v(1)%qcsws,            &
1513                                               surf_def_v(2)%qcsws,            &
1514                                               surf_lsm_v(2)%qcsws,            &
1515                                               surf_usm_v(2)%qcsws,            &
1516                                               surf_def_v(3)%qcsws,            &
1517                                               surf_lsm_v(3)%qcsws,            &
1518                                               surf_usm_v(3)%qcsws )
1519               ELSE
1520!
1521!--               Output of averaged data
1522                  surfaces%var_out(:) = surfaces%var_av(:,n_out) /             &
1523                                        REAL( average_count_surf, KIND=wp )
1524                  surfaces%var_av(:,n_out) = 0.0_wp
1525                                                       
1526               ENDIF
1527
1528            CASE ( 'ncsws' )
1529!
1530!--            Output of instantaneous data
1531               IF ( av == 0 )  THEN
1532                  CALL surface_output_collect( surf_def_h(0)%ncsws,            &
1533                                               surf_def_h(1)%ncsws,            &
1534                                               surf_lsm_h%ncsws,               &
1535                                               surf_usm_h%ncsws,               &
1536                                               surf_def_v(0)%ncsws,            &
1537                                               surf_lsm_v(0)%ncsws,            &
1538                                               surf_usm_v(0)%ncsws,            &
1539                                               surf_def_v(1)%ncsws,            &
1540                                               surf_lsm_v(1)%ncsws,            &
1541                                               surf_usm_v(1)%ncsws,            &
1542                                               surf_def_v(2)%ncsws,            &
1543                                               surf_lsm_v(2)%ncsws,            &
1544                                               surf_usm_v(2)%ncsws,            &
1545                                               surf_def_v(3)%ncsws,            &
1546                                               surf_lsm_v(3)%ncsws,            &
1547                                               surf_usm_v(3)%ncsws )
1548               ELSE
1549!
1550!--               Output of averaged data
1551                  surfaces%var_out(:) = surfaces%var_av(:,n_out) /             &
1552                                        REAL( average_count_surf, KIND=wp )
1553                  surfaces%var_av(:,n_out) = 0.0_wp
1554                                                       
1555               ENDIF
1556
1557            CASE ( 'qrsws' )
1558!
1559!--            Output of instantaneous data
1560               IF ( av == 0 )  THEN
1561                  CALL surface_output_collect( surf_def_h(0)%qrsws,            &
1562                                               surf_def_h(1)%qrsws,            &
1563                                               surf_lsm_h%qrsws,               &
1564                                               surf_usm_h%qrsws,               &
1565                                               surf_def_v(0)%qrsws,            &
1566                                               surf_lsm_v(0)%qrsws,            &
1567                                               surf_usm_v(0)%qrsws,            &
1568                                               surf_def_v(1)%qrsws,            &
1569                                               surf_lsm_v(1)%qrsws,            &
1570                                               surf_usm_v(1)%qrsws,            &
1571                                               surf_def_v(2)%qrsws,            &
1572                                               surf_lsm_v(2)%qrsws,            &
1573                                               surf_usm_v(2)%qrsws,            &
1574                                               surf_def_v(3)%qrsws,            &
1575                                               surf_lsm_v(3)%qrsws,            &
1576                                               surf_usm_v(3)%qrsws )
1577               ELSE
1578!
1579!--               Output of averaged data
1580                  surfaces%var_out(:) = surfaces%var_av(:,n_out) /             &
1581                                        REAL( average_count_surf, KIND=wp )
1582                  surfaces%var_av(:,n_out) = 0.0_wp
1583                                                       
1584               ENDIF
1585
1586            CASE ( 'nrsws' )
1587!
1588!--            Output of instantaneous data
1589               IF ( av == 0 )  THEN
1590                  CALL surface_output_collect( surf_def_h(0)%nrsws,            &
1591                                               surf_def_h(1)%nrsws,            &
1592                                               surf_lsm_h%nrsws,               &
1593                                               surf_usm_h%nrsws,               &
1594                                               surf_def_v(0)%nrsws,            &
1595                                               surf_lsm_v(0)%nrsws,            &
1596                                               surf_usm_v(0)%nrsws,            &
1597                                               surf_def_v(1)%nrsws,            &
1598                                               surf_lsm_v(1)%nrsws,            &
1599                                               surf_usm_v(1)%nrsws,            &
1600                                               surf_def_v(2)%nrsws,            &
1601                                               surf_lsm_v(2)%nrsws,            &
1602                                               surf_usm_v(2)%nrsws,            &
1603                                               surf_def_v(3)%nrsws,            &
1604                                               surf_lsm_v(3)%nrsws,            &
1605                                               surf_usm_v(3)%nrsws )
1606               ELSE
1607!
1608!--               Output of averaged data
1609                  surfaces%var_out(:) = surfaces%var_av(:,n_out) /             &
1610                                        REAL( average_count_surf, KIND=wp )
1611                  surfaces%var_av(:,n_out) = 0.0_wp
1612                                                       
1613               ENDIF
1614
1615            CASE ( 'sasws' )
1616!
1617!--            Output of instantaneous data
1618               IF ( av == 0 )  THEN
1619                  CALL surface_output_collect( surf_def_h(0)%sasws,            &
1620                                               surf_def_h(1)%sasws,            &
1621                                               surf_lsm_h%sasws,               &
1622                                               surf_usm_h%sasws,               &
1623                                               surf_def_v(0)%sasws,            &
1624                                               surf_lsm_v(0)%sasws,            &
1625                                               surf_usm_v(0)%sasws,            &
1626                                               surf_def_v(1)%sasws,            &
1627                                               surf_lsm_v(1)%sasws,            &
1628                                               surf_usm_v(1)%sasws,            &
1629                                               surf_def_v(2)%sasws,            &
1630                                               surf_lsm_v(2)%sasws,            &
1631                                               surf_usm_v(2)%sasws,            &
1632                                               surf_def_v(3)%sasws,            &
1633                                               surf_lsm_v(3)%sasws,            &
1634                                               surf_usm_v(3)%sasws )
1635               ELSE
1636!
1637!--               Output of averaged data
1638                  surfaces%var_out(:) = surfaces%var_av(:,n_out) /             &
1639                                        REAL( average_count_surf, KIND=wp )
1640                  surfaces%var_av(:,n_out) = 0.0_wp
1641                                                       
1642               ENDIF
1643
1644            CASE ( 'q_surface' )
1645!
1646!--            Output of instantaneous data
1647               IF ( av == 0 )  THEN
1648                  CALL surface_output_collect( surf_def_h(0)%q_surface,        &
1649                                               surf_def_h(1)%q_surface,        &
1650                                               surf_lsm_h%q_surface,           &
1651                                               surf_usm_h%q_surface,           &
1652                                               surf_def_v(0)%q_surface,        &
1653                                               surf_lsm_v(0)%q_surface,        &
1654                                               surf_usm_v(0)%q_surface,        &
1655                                               surf_def_v(1)%q_surface,        &
1656                                               surf_lsm_v(1)%q_surface,        &
1657                                               surf_usm_v(1)%q_surface,        &
1658                                               surf_def_v(2)%q_surface,        &
1659                                               surf_lsm_v(2)%q_surface,        &
1660                                               surf_usm_v(2)%q_surface,        &
1661                                               surf_def_v(3)%q_surface,        &
1662                                               surf_lsm_v(3)%q_surface,        &
1663                                               surf_usm_v(3)%q_surface )
1664               ELSE
1665!
1666!--               Output of averaged data
1667                  surfaces%var_out(:) = surfaces%var_av(:,n_out) /             &
1668                                        REAL( average_count_surf, KIND=wp )
1669                  surfaces%var_av(:,n_out) = 0.0_wp
1670                                                       
1671               ENDIF
1672
1673            CASE ( 'theta_surface' )
1674!
1675!--            Output of instantaneous data
1676               IF ( av == 0 )  THEN
1677                  CALL surface_output_collect( surf_def_h(0)%pt_surface,       &
1678                                               surf_def_h(1)%pt_surface,       &
1679                                               surf_lsm_h%pt_surface,          &
1680                                               surf_usm_h%pt_surface,          &
1681                                               surf_def_v(0)%pt_surface,       &
1682                                               surf_lsm_v(0)%pt_surface,       &
1683                                               surf_usm_v(0)%pt_surface,       &
1684                                               surf_def_v(1)%pt_surface,       &
1685                                               surf_lsm_v(1)%pt_surface,       &
1686                                               surf_usm_v(1)%pt_surface,       &
1687                                               surf_def_v(2)%pt_surface,       &
1688                                               surf_lsm_v(2)%pt_surface,       &
1689                                               surf_usm_v(2)%pt_surface,       &
1690                                               surf_def_v(3)%pt_surface,       &
1691                                               surf_lsm_v(3)%pt_surface,       &
1692                                               surf_usm_v(3)%pt_surface )
1693               ELSE
1694!
1695!--               Output of averaged data
1696                  surfaces%var_out(:) = surfaces%var_av(:,n_out) /             &
1697                                        REAL( average_count_surf, KIND=wp )
1698                  surfaces%var_av(:,n_out) = 0.0_wp
1699                                                       
1700               ENDIF
1701
1702            CASE ( 'thetav_surface' )
1703!
1704!--            Output of instantaneous data
1705               IF ( av == 0 )  THEN
1706                  CALL surface_output_collect( surf_def_h(0)%vpt_surface,      &
1707                                               surf_def_h(1)%vpt_surface,      &
1708                                               surf_lsm_h%vpt_surface,         &
1709                                               surf_usm_h%vpt_surface,         &
1710                                               surf_def_v(0)%vpt_surface,      &
1711                                               surf_lsm_v(0)%vpt_surface,      &
1712                                               surf_usm_v(0)%vpt_surface,      &
1713                                               surf_def_v(1)%vpt_surface,      &
1714                                               surf_lsm_v(1)%vpt_surface,      &
1715                                               surf_usm_v(1)%vpt_surface,      &
1716                                               surf_def_v(2)%vpt_surface,      &
1717                                               surf_lsm_v(2)%vpt_surface,      &
1718                                               surf_usm_v(2)%vpt_surface,      &
1719                                               surf_def_v(3)%vpt_surface,      &
1720                                               surf_lsm_v(3)%vpt_surface,      &
1721                                               surf_usm_v(3)%vpt_surface)
1722               ELSE
1723!
1724!--               Output of averaged data
1725                  surfaces%var_out(:) = surfaces%var_av(:,n_out) /             &
1726                                        REAL( average_count_surf, KIND=wp )
1727                  surfaces%var_av(:,n_out) = 0.0_wp
1728                                                       
1729               ENDIF
1730
1731            CASE ( 'rad_net' )
1732!
1733!--            Output of instantaneous data
1734               IF ( av == 0 )  THEN
1735                  CALL surface_output_collect( surf_def_h(0)%rad_net,          &
1736                                               surf_def_h(1)%rad_net,          &
1737                                               surf_lsm_h%rad_net,             &
1738                                               surf_usm_h%rad_net,             &
1739                                               surf_def_v(0)%rad_net,          &
1740                                               surf_lsm_v(0)%rad_net,          &
1741                                               surf_usm_v(0)%rad_net,          &
1742                                               surf_def_v(1)%rad_net,          &
1743                                               surf_lsm_v(1)%rad_net,          &
1744                                               surf_usm_v(1)%rad_net,          &
1745                                               surf_def_v(2)%rad_net,          &
1746                                               surf_lsm_v(2)%rad_net,          &
1747                                               surf_usm_v(2)%rad_net,          &
1748                                               surf_def_v(3)%rad_net,          &
1749                                               surf_lsm_v(3)%rad_net,          &
1750                                               surf_usm_v(3)%rad_net ) 
1751               ELSE
1752!
1753!--               Output of averaged data
1754                  surfaces%var_out(:) = surfaces%var_av(:,n_out) /             &
1755                                        REAL( average_count_surf, KIND=wp )
1756                  surfaces%var_av(:,n_out) = 0.0_wp
1757                                                       
1758               ENDIF
1759
1760            CASE ( 'rad_lw_in' )
1761!
1762!--            Output of instantaneous data
1763               IF ( av == 0 )  THEN
1764                  CALL surface_output_collect( surf_def_h(0)%rad_lw_in,        &
1765                                               surf_def_h(1)%rad_lw_in,        &
1766                                               surf_lsm_h%rad_lw_in,           &
1767                                               surf_usm_h%rad_lw_in,           &
1768                                               surf_def_v(0)%rad_lw_in,        &
1769                                               surf_lsm_v(0)%rad_lw_in,        &
1770                                               surf_usm_v(0)%rad_lw_in,        &
1771                                               surf_def_v(1)%rad_lw_in,        &
1772                                               surf_lsm_v(1)%rad_lw_in,        &
1773                                               surf_usm_v(1)%rad_lw_in,        &
1774                                               surf_def_v(2)%rad_lw_in,        &
1775                                               surf_lsm_v(2)%rad_lw_in,        &
1776                                               surf_usm_v(2)%rad_lw_in,        &
1777                                               surf_def_v(3)%rad_lw_in,        &
1778                                               surf_lsm_v(3)%rad_lw_in,        &
1779                                               surf_usm_v(3)%rad_lw_in )
1780               ELSE
1781!
1782!--               Output of averaged data
1783                  surfaces%var_out(:) = surfaces%var_av(:,n_out) /             &
1784                                        REAL( average_count_surf, KIND=wp )
1785                  surfaces%var_av(:,n_out) = 0.0_wp
1786                                                       
1787               ENDIF
1788
1789            CASE ( 'rad_lw_out' )
1790!
1791!--            Output of instantaneous data
1792               IF ( av == 0 )  THEN
1793                  CALL surface_output_collect( surf_def_h(0)%rad_lw_out,       &
1794                                               surf_def_h(1)%rad_lw_out,       &
1795                                               surf_lsm_h%rad_lw_out,          &
1796                                               surf_usm_h%rad_lw_out,          &
1797                                               surf_def_v(0)%rad_lw_out,       &
1798                                               surf_lsm_v(0)%rad_lw_out,       &
1799                                               surf_usm_v(0)%rad_lw_out,       &
1800                                               surf_def_v(1)%rad_lw_out,       &
1801                                               surf_lsm_v(1)%rad_lw_out,       &
1802                                               surf_usm_v(1)%rad_lw_out,       &
1803                                               surf_def_v(2)%rad_lw_out,       &
1804                                               surf_lsm_v(2)%rad_lw_out,       &
1805                                               surf_usm_v(2)%rad_lw_out,       &
1806                                               surf_def_v(3)%rad_lw_out,       &
1807                                               surf_lsm_v(3)%rad_lw_out,       &
1808                                               surf_usm_v(3)%rad_lw_out )
1809               ELSE
1810!
1811!--               Output of averaged data
1812                  surfaces%var_out(:) = surfaces%var_av(:,n_out) /             &
1813                                        REAL( average_count_surf, KIND=wp )
1814                  surfaces%var_av(:,n_out) = 0.0_wp
1815                                                       
1816               ENDIF
1817
1818            CASE ( 'rad_sw_in' )
1819!
1820!--            Output of instantaneous data
1821               IF ( av == 0 )  THEN
1822                  CALL surface_output_collect( surf_def_h(0)%rad_sw_in,        &
1823                                               surf_def_h(1)%rad_sw_in,        &
1824                                               surf_lsm_h%rad_sw_in,           &
1825                                               surf_usm_h%rad_sw_in,           &
1826                                               surf_def_v(0)%rad_sw_in,        &
1827                                               surf_lsm_v(0)%rad_sw_in,        &
1828                                               surf_usm_v(0)%rad_sw_in,        &
1829                                               surf_def_v(1)%rad_sw_in,        &
1830                                               surf_lsm_v(1)%rad_sw_in,        &
1831                                               surf_usm_v(1)%rad_sw_in,        &
1832                                               surf_def_v(2)%rad_sw_in,        &
1833                                               surf_lsm_v(2)%rad_sw_in,        &
1834                                               surf_usm_v(2)%rad_sw_in,        &
1835                                               surf_def_v(3)%rad_sw_in,        &
1836                                               surf_lsm_v(3)%rad_sw_in,        &
1837                                               surf_usm_v(3)%rad_sw_in )
1838               ELSE
1839!
1840!--               Output of averaged data
1841                  surfaces%var_out(:) = surfaces%var_av(:,n_out) /             &
1842                                        REAL( average_count_surf, KIND=wp )
1843                  surfaces%var_av(:,n_out) = 0.0_wp
1844                                                       
1845               ENDIF
1846
1847            CASE ( 'rad_sw_out' )
1848!
1849!--            Output of instantaneous data
1850               IF ( av == 0 )  THEN
1851                  CALL surface_output_collect( surf_def_h(0)%rad_sw_out,       &
1852                                               surf_def_h(1)%rad_sw_out,       &
1853                                               surf_lsm_h%rad_sw_out,          &
1854                                               surf_usm_h%rad_sw_out,          &
1855                                               surf_def_v(0)%rad_sw_out,       &
1856                                               surf_lsm_v(0)%rad_sw_out,       &
1857                                               surf_usm_v(0)%rad_sw_out,       &
1858                                               surf_def_v(1)%rad_sw_out,       &
1859                                               surf_lsm_v(1)%rad_sw_out,       &
1860                                               surf_usm_v(1)%rad_sw_out,       &
1861                                               surf_def_v(2)%rad_sw_out,       &
1862                                               surf_lsm_v(2)%rad_sw_out,       &
1863                                               surf_usm_v(2)%rad_sw_out,       &
1864                                               surf_def_v(3)%rad_sw_out,       &
1865                                               surf_lsm_v(3)%rad_sw_out,       &
1866                                               surf_usm_v(3)%rad_sw_out )
1867               ELSE
1868!
1869!--               Output of averaged data
1870                  surfaces%var_out(:) = surfaces%var_av(:,n_out) /             &
1871                                        REAL( average_count_surf, KIND=wp )
1872                  surfaces%var_av(:,n_out) = 0.0_wp
1873                                                       
1874               ENDIF
1875
1876            CASE ( 'ghf' )
1877!
1878!--            Output of instantaneous data
1879               IF ( av == 0 )  THEN
1880                  CALL surface_output_collect( surf_def_h(0)%ghf,              &
1881                                               surf_def_h(1)%ghf,              &
1882                                               surf_lsm_h%ghf,                 &
1883                                               surf_usm_h%ghf,                 &
1884                                               surf_def_v(0)%ghf,              &
1885                                               surf_lsm_v(0)%ghf,              &
1886                                               surf_usm_v(0)%ghf,              &
1887                                               surf_def_v(1)%ghf,              &
1888                                               surf_lsm_v(1)%ghf,              &
1889                                               surf_usm_v(1)%ghf,              &
1890                                               surf_def_v(2)%ghf,              &
1891                                               surf_lsm_v(2)%ghf,              &
1892                                               surf_usm_v(2)%ghf,              &
1893                                               surf_def_v(3)%ghf,              &
1894                                               surf_lsm_v(3)%ghf,              &
1895                                               surf_usm_v(3)%ghf )     
1896                                                                        ELSE
1897!
1898!--               Output of averaged data
1899                  surfaces%var_out(:) = surfaces%var_av(:,n_out) /             &
1900                                        REAL( average_count_surf, KIND=wp )
1901                  surfaces%var_av(:,n_out) = 0.0_wp
1902                                                       
1903               ENDIF
1904                     
1905            CASE ( 'r_a' )                                                     
1906!
1907!--            Output of instantaneous data
1908               IF ( av == 0 )  THEN
1909                  CALL surface_output_collect( surf_def_h(0)%r_a,              &
1910                                               surf_def_h(1)%r_a,              &
1911                                               surf_lsm_h%r_a,                 &
1912                                               surf_usm_h%r_a,                 &
1913                                               surf_def_v(0)%r_a,              &
1914                                               surf_lsm_v(0)%r_a,              &
1915                                               surf_usm_v(0)%r_a,              &
1916                                               surf_def_v(1)%r_a,              &
1917                                               surf_lsm_v(1)%r_a,              &
1918                                               surf_usm_v(1)%r_a,              &
1919                                               surf_def_v(2)%r_a,              &
1920                                               surf_lsm_v(2)%r_a,              &
1921                                               surf_usm_v(2)%r_a,              &
1922                                               surf_def_v(3)%r_a,              &
1923                                               surf_lsm_v(3)%r_a,              &
1924                                               surf_usm_v(3)%r_a )     
1925                                                                      ELSE
1926!
1927!--               Output of averaged data
1928                  surfaces%var_out(:) = surfaces%var_av(:,n_out) /             &
1929                                        REAL( average_count_surf, KIND=wp )
1930                  surfaces%var_av(:,n_out) = 0.0_wp
1931                                                       
1932               ENDIF
1933                       
1934            CASE ( 'r_soil' )                                                 
1935!
1936!--            Output of instantaneous data
1937               IF ( av == 0 )  THEN
1938                  CALL surface_output_collect( surf_def_h(0)%r_soil,           &
1939                                               surf_def_h(1)%r_soil,           &
1940                                               surf_lsm_h%r_soil,              &
1941                                               surf_usm_h%r_soil,              &
1942                                               surf_def_v(0)%r_soil,           &
1943                                               surf_lsm_v(0)%r_soil,           &
1944                                               surf_usm_v(0)%r_soil,           &
1945                                               surf_def_v(1)%r_soil,           &
1946                                               surf_lsm_v(1)%r_soil,           &
1947                                               surf_usm_v(1)%r_soil,           &
1948                                               surf_def_v(2)%r_soil,           &
1949                                               surf_lsm_v(2)%r_soil,           &
1950                                               surf_usm_v(2)%r_soil,           &
1951                                               surf_def_v(3)%r_soil,           &
1952                                               surf_lsm_v(3)%r_soil,           &
1953                                               surf_usm_v(3)%r_soil ) 
1954               ELSE
1955!
1956!--               Output of averaged data
1957                  surfaces%var_out(:) = surfaces%var_av(:,n_out) /             &
1958                                        REAL( average_count_surf, KIND=wp )
1959                  surfaces%var_av(:,n_out) = 0.0_wp
1960                                                       
1961               ENDIF
1962
1963            CASE ( 'r_canopy' )
1964!
1965!--            Output of instantaneous data
1966               IF ( av == 0 )  THEN
1967                  CALL surface_output_collect( surf_def_h(0)%r_canopy,         &
1968                                               surf_def_h(1)%r_canopy,         &
1969                                               surf_lsm_h%r_canopy,            &
1970                                               surf_usm_h%r_canopy,            &
1971                                               surf_def_v(0)%r_canopy,         &
1972                                               surf_lsm_v(0)%r_canopy,         &
1973                                               surf_usm_v(0)%r_canopy,         &
1974                                               surf_def_v(1)%r_canopy,         &
1975                                               surf_lsm_v(1)%r_canopy,         &
1976                                               surf_usm_v(1)%r_canopy,         &
1977                                               surf_def_v(2)%r_canopy,         &
1978                                               surf_lsm_v(2)%r_canopy,         &
1979                                               surf_usm_v(2)%r_canopy,         &
1980                                               surf_def_v(3)%r_canopy,         &
1981                                               surf_lsm_v(3)%r_canopy,         &
1982                                               surf_usm_v(3)%r_canopy ) 
1983               ELSE
1984!
1985!--               Output of averaged data
1986                  surfaces%var_out(:) = surfaces%var_av(:,n_out) /             &
1987                                        REAL( average_count_surf, KIND=wp )
1988                  surfaces%var_av(:,n_out) = 0.0_wp
1989                                                       
1990               ENDIF
1991
1992            CASE ( 'r_s' )
1993!
1994!--            Output of instantaneous data
1995               IF ( av == 0 )  THEN
1996                  CALL surface_output_collect( surf_def_h(0)%r_s,              &
1997                                               surf_def_h(1)%r_s,              &
1998                                               surf_lsm_h%r_s,                 &
1999                                               surf_usm_h%r_s,                 &
2000                                               surf_def_v(0)%r_s,              &
2001                                               surf_lsm_v(0)%r_s,              &
2002                                               surf_usm_v(0)%r_s,              &
2003                                               surf_def_v(1)%r_s,              &
2004                                               surf_lsm_v(1)%r_s,              &
2005                                               surf_usm_v(1)%r_s,              &
2006                                               surf_def_v(2)%r_s,              &
2007                                               surf_lsm_v(2)%r_s,              &
2008                                               surf_usm_v(2)%r_s,              &
2009                                               surf_def_v(3)%r_s,              &
2010                                               surf_lsm_v(3)%r_s,              &
2011                                               surf_usm_v(3)%r_s ) 
2012               ELSE
2013!
2014!--               Output of averaged data
2015                  surfaces%var_out(:) = surfaces%var_av(:,n_out) /             &
2016                                        REAL( average_count_surf, KIND=wp )
2017                  surfaces%var_av(:,n_out) = 0.0_wp
2018                                                       
2019               ENDIF
2020
2021            CASE ( 'rad_sw_dir' )
2022!
2023!--            Output of instantaneous data
2024               IF ( av == 0 )  THEN
2025                  CALL surface_output_collect( surf_def_h(0)%rad_sw_dir,       &
2026                                               surf_def_h(1)%rad_sw_dir,       &
2027                                               surf_lsm_h%rad_sw_dir,          &
2028                                               surf_usm_h%rad_sw_dir,          &
2029                                               surf_def_v(0)%rad_sw_dir,       &
2030                                               surf_lsm_v(0)%rad_sw_dir,       &
2031                                               surf_usm_v(0)%rad_sw_dir,       &
2032                                               surf_def_v(1)%rad_sw_dir,       &
2033                                               surf_lsm_v(1)%rad_sw_dir,       &
2034                                               surf_usm_v(1)%rad_sw_dir,       &
2035                                               surf_def_v(2)%rad_sw_dir,       &
2036                                               surf_lsm_v(2)%rad_sw_dir,       &
2037                                               surf_usm_v(2)%rad_sw_dir,       &
2038                                               surf_def_v(3)%rad_sw_dir,       &
2039                                               surf_lsm_v(3)%rad_sw_dir,       &
2040                                               surf_usm_v(3)%rad_sw_dir )
2041               ELSE
2042!
2043!--               Output of averaged data
2044                  surfaces%var_out(:) = surfaces%var_av(:,n_out) /             &
2045                                        REAL( average_count_surf, KIND=wp )
2046                  surfaces%var_av(:,n_out) = 0.0_wp
2047                                                       
2048               ENDIF
2049
2050            CASE ( 'rad_sw_dif' )
2051!
2052!--            Output of instantaneous data
2053               IF ( av == 0 )  THEN
2054                  CALL surface_output_collect( surf_def_h(0)%rad_sw_dif,       &
2055                                               surf_def_h(1)%rad_sw_dif,       &
2056                                               surf_lsm_h%rad_sw_dif,          &
2057                                               surf_usm_h%rad_sw_dif,          &
2058                                               surf_def_v(0)%rad_sw_dif,       &
2059                                               surf_lsm_v(0)%rad_sw_dif,       &
2060                                               surf_usm_v(0)%rad_sw_dif,       &
2061                                               surf_def_v(1)%rad_sw_dif,       &
2062                                               surf_lsm_v(1)%rad_sw_dif,       &
2063                                               surf_usm_v(1)%rad_sw_dif,       &
2064                                               surf_def_v(2)%rad_sw_dif,       &
2065                                               surf_lsm_v(2)%rad_sw_dif,       &
2066                                               surf_usm_v(2)%rad_sw_dif,       &
2067                                               surf_def_v(3)%rad_sw_dif,       &
2068                                               surf_lsm_v(3)%rad_sw_dif,       &
2069                                               surf_usm_v(3)%rad_sw_dif )
2070               ELSE
2071!
2072!--               Output of averaged data
2073                  surfaces%var_out(:) = surfaces%var_av(:,n_out) /             &
2074                                        REAL( average_count_surf, KIND=wp )
2075                  surfaces%var_av(:,n_out) = 0.0_wp
2076                                                       
2077               ENDIF
2078
2079            CASE ( 'rad_sw_ref' )
2080!
2081!--            Output of instantaneous data
2082               IF ( av == 0 )  THEN
2083                  CALL surface_output_collect( surf_def_h(0)%rad_sw_ref,       &
2084                                               surf_def_h(1)%rad_sw_ref,       &
2085                                               surf_lsm_h%rad_sw_ref,          &
2086                                               surf_usm_h%rad_sw_ref,          &
2087                                               surf_def_v(0)%rad_sw_ref,       &
2088                                               surf_lsm_v(0)%rad_sw_ref,       &
2089                                               surf_usm_v(0)%rad_sw_ref,       &
2090                                               surf_def_v(1)%rad_sw_ref,       &
2091                                               surf_lsm_v(1)%rad_sw_ref,       &
2092                                               surf_usm_v(1)%rad_sw_ref,       &
2093                                               surf_def_v(2)%rad_sw_ref,       &
2094                                               surf_lsm_v(2)%rad_sw_ref,       &
2095                                               surf_usm_v(2)%rad_sw_ref,       &
2096                                               surf_def_v(3)%rad_sw_ref,       &
2097                                               surf_lsm_v(3)%rad_sw_ref,       &
2098                                               surf_usm_v(3)%rad_sw_ref )
2099               ELSE
2100!
2101!--               Output of averaged data
2102                  surfaces%var_out(:) = surfaces%var_av(:,n_out) /             &
2103                                        REAL( average_count_surf, KIND=wp )
2104                  surfaces%var_av(:,n_out) = 0.0_wp
2105                                                       
2106               ENDIF
2107
2108            CASE ( 'rad_sw_res' )
2109!
2110!--            Output of instantaneous data
2111               IF ( av == 0 )  THEN
2112                  CALL surface_output_collect( surf_def_h(0)%rad_sw_res,       &
2113                                               surf_def_h(1)%rad_sw_res,       &
2114                                               surf_lsm_h%rad_sw_res,          &
2115                                               surf_usm_h%rad_sw_res,          &
2116                                               surf_def_v(0)%rad_sw_res,       &
2117                                               surf_lsm_v(0)%rad_sw_res,       &
2118                                               surf_usm_v(0)%rad_sw_res,       &
2119                                               surf_def_v(1)%rad_sw_res,       &
2120                                               surf_lsm_v(1)%rad_sw_res,       &
2121                                               surf_usm_v(1)%rad_sw_res,       &
2122                                               surf_def_v(2)%rad_sw_res,       &
2123                                               surf_lsm_v(2)%rad_sw_res,       &
2124                                               surf_usm_v(2)%rad_sw_res,       &
2125                                               surf_def_v(3)%rad_sw_res,       &
2126                                               surf_lsm_v(3)%rad_sw_res,       &
2127                                               surf_usm_v(3)%rad_sw_res )
2128               ELSE
2129!
2130!--               Output of averaged data
2131                  surfaces%var_out(:) = surfaces%var_av(:,n_out) /             &
2132                                        REAL( average_count_surf, KIND=wp )
2133                  surfaces%var_av(:,n_out) = 0.0_wp
2134                                                       
2135               ENDIF
2136
2137            CASE ( 'rad_lw_dif' )
2138!
2139!--            Output of instantaneous data
2140               IF ( av == 0 )  THEN
2141                  CALL surface_output_collect( surf_def_h(0)%rad_lw_dif,       &
2142                                               surf_def_h(1)%rad_lw_dif,       &
2143                                               surf_lsm_h%rad_lw_dif,          &
2144                                               surf_usm_h%rad_lw_dif,          &
2145                                               surf_def_v(0)%rad_lw_dif,       &
2146                                               surf_lsm_v(0)%rad_lw_dif,       &
2147                                               surf_usm_v(0)%rad_lw_dif,       &
2148                                               surf_def_v(1)%rad_lw_dif,       &
2149                                               surf_lsm_v(1)%rad_lw_dif,       &
2150                                               surf_usm_v(1)%rad_lw_dif,       &
2151                                               surf_def_v(2)%rad_lw_dif,       &
2152                                               surf_lsm_v(2)%rad_lw_dif,       &
2153                                               surf_usm_v(2)%rad_lw_dif,       &
2154                                               surf_def_v(3)%rad_lw_dif,       &
2155                                               surf_lsm_v(3)%rad_lw_dif,       &
2156                                               surf_usm_v(3)%rad_lw_dif )
2157               ELSE
2158!
2159!--               Output of averaged data
2160                  surfaces%var_out(:) = surfaces%var_av(:,n_out) /             &
2161                                        REAL( average_count_surf, KIND=wp )
2162                  surfaces%var_av(:,n_out) = 0.0_wp
2163                                                       
2164               ENDIF
2165
2166            CASE ( 'rad_lw_ref' )
2167!
2168!--            Output of instantaneous data
2169               IF ( av == 0 )  THEN
2170                  CALL surface_output_collect( surf_def_h(0)%rad_lw_ref,       &
2171                                               surf_def_h(1)%rad_lw_ref,       &
2172                                               surf_lsm_h%rad_lw_ref,          &
2173                                               surf_usm_h%rad_lw_ref,          &
2174                                               surf_def_v(0)%rad_lw_ref,       &
2175                                               surf_lsm_v(0)%rad_lw_ref,       &
2176                                               surf_usm_v(0)%rad_lw_ref,       &
2177                                               surf_def_v(1)%rad_lw_ref,       &
2178                                               surf_lsm_v(1)%rad_lw_ref,       &
2179                                               surf_usm_v(1)%rad_lw_ref,       &
2180                                               surf_def_v(2)%rad_lw_ref,       &
2181                                               surf_lsm_v(2)%rad_lw_ref,       &
2182                                               surf_usm_v(2)%rad_lw_ref,       &
2183                                               surf_def_v(3)%rad_lw_ref,       &
2184                                               surf_lsm_v(3)%rad_lw_ref,       &
2185                                               surf_usm_v(3)%rad_lw_ref )
2186               ELSE
2187!
2188!--               Output of averaged data
2189                  surfaces%var_out(:) = surfaces%var_av(:,n_out) /             &
2190                                        REAL( average_count_surf, KIND=wp )
2191                  surfaces%var_av(:,n_out) = 0.0_wp
2192                                                       
2193               ENDIF
2194
2195            CASE ( 'rad_lw_res' )
2196!
2197!--            Output of instantaneous data
2198               IF ( av == 0 )  THEN
2199                  CALL surface_output_collect( surf_def_h(0)%rad_lw_res,       &
2200                                               surf_def_h(1)%rad_lw_res,       &
2201                                               surf_lsm_h%rad_lw_res,          &
2202                                               surf_usm_h%rad_lw_res,          &
2203                                               surf_def_v(0)%rad_lw_res,       &
2204                                               surf_lsm_v(0)%rad_lw_res,       &
2205                                               surf_usm_v(0)%rad_lw_res,       &
2206                                               surf_def_v(1)%rad_lw_res,       &
2207                                               surf_lsm_v(1)%rad_lw_res,       &
2208                                               surf_usm_v(1)%rad_lw_res,       &
2209                                               surf_def_v(2)%rad_lw_res,       &
2210                                               surf_lsm_v(2)%rad_lw_res,       &
2211                                               surf_usm_v(2)%rad_lw_res,       &
2212                                               surf_def_v(3)%rad_lw_res,       &
2213                                               surf_lsm_v(3)%rad_lw_res,       &
2214                                               surf_usm_v(3)%rad_lw_res )
2215               ELSE
2216!
2217!--               Output of averaged data
2218                  surfaces%var_out(:) = surfaces%var_av(:,n_out) /             &
2219                                        REAL( average_count_surf, KIND=wp )
2220                  surfaces%var_av(:,n_out) = 0.0_wp
2221                                                       
2222               ENDIF
2223
2224!
2225!--            Add further variables:
2226!--            'css', 'cssws', 'qsws_liq', 'qsws_soil', 'qsws_veg'
2227
2228         END SELECT
2229!
2230!--      Write to binary file:
2231!--      - surfaces%points ( 3, 1-npoints )
2232!--      - surfaces%polygons ( 5, 1-ns )
2233!--      - surfaces%var_out ( 1-ns, time )
2234!--      - Dimension: 1-nsurfaces, 1-npoints - can be ordered consecutively
2235!--      - Distinguish between average and non-average data
2236         DO  i = 0, io_blocks-1
2237            IF ( i == io_group )  THEN
2238               WRITE ( 25+av )  LEN_TRIM( 'time' )
2239               WRITE ( 25+av )  'time'
2240               WRITE ( 25+av )  time_since_reference_point
2241               WRITE ( 25+av )  LEN_TRIM( trimvar )
2242               WRITE ( 25+av )  TRIM( trimvar )
2243               WRITE ( 25+av )  surfaces%var_out
2244            ENDIF
2245#if defined( __parallel )
2246            CALL MPI_BARRIER( comm2d, ierr )
2247#endif
2248         ENDDO
2249
2250      ENDDO
2251     
2252!
2253!--   If averaged output was written to NetCDF file, set the counter to zero
2254      IF ( av == 1 )  average_count_surf = 0
2255             
2256   END SUBROUTINE surface_output
2257   
2258!------------------------------------------------------------------------------!
2259! Description:
2260! ------------
2261!> Routine for controlling the data averaging.
2262!------------------------------------------------------------------------------!     
2263   SUBROUTINE surface_output_averaging
2264   
2265      IMPLICIT NONE
2266     
2267      CHARACTER(LEN=100) ::  trimvar !< dummy variable for current output variable
2268       
2269      INTEGER(iwp) ::  n_out  !< counter variables for surface output
2270     
2271      n_out = 0
2272      DO  WHILE ( dosurf(1,n_out+1)(1:1) /= ' ' )
2273         
2274         n_out   = n_out + 1
2275         trimvar = TRIM( dosurf(1,n_out) )
2276
2277         SELECT CASE ( trimvar )
2278
2279            CASE ( 'us' )
2280               CALL surface_output_sum_up( surf_def_h(0)%us,                   &
2281                                           surf_def_h(1)%us,                   &
2282                                           surf_lsm_h%us,                      &
2283                                           surf_usm_h%us,                      &
2284                                           surf_def_v(0)%us,                   &
2285                                           surf_lsm_v(0)%us,                   &
2286                                           surf_usm_v(0)%us,                   &
2287                                           surf_def_v(1)%us,                   &
2288                                           surf_lsm_v(1)%us,                   &
2289                                           surf_usm_v(1)%us,                   &
2290                                           surf_def_v(2)%us,                   &
2291                                           surf_lsm_v(2)%us,                   &
2292                                           surf_usm_v(2)%us,                   &
2293                                           surf_def_v(3)%us,                   &
2294                                           surf_lsm_v(3)%us,                   &
2295                                           surf_usm_v(3)%us, n_out ) 
2296
2297            CASE ( 'ts' )
2298               CALL surface_output_sum_up( surf_def_h(0)%ts,                   &
2299                                           surf_def_h(1)%ts,                   &
2300                                           surf_lsm_h%ts,                      &
2301                                           surf_usm_h%ts,                      &
2302                                           surf_def_v(0)%ts,                   &
2303                                           surf_lsm_v(0)%ts,                   &
2304                                           surf_usm_v(0)%ts,                   &
2305                                           surf_def_v(1)%ts,                   &
2306                                           surf_lsm_v(1)%ts,                   &
2307                                           surf_usm_v(1)%ts,                   &
2308                                           surf_def_v(2)%ts,                   &
2309                                           surf_lsm_v(2)%ts,                   &
2310                                           surf_usm_v(2)%ts,                   &
2311                                           surf_def_v(3)%ts,                   &
2312                                           surf_lsm_v(3)%ts,                   &
2313                                           surf_usm_v(3)%ts, n_out ) 
2314
2315            CASE ( 'qs' )
2316               CALL surface_output_sum_up( surf_def_h(0)%qs,                   &
2317                                           surf_def_h(1)%qs,                   &
2318                                           surf_lsm_h%qs,                      &
2319                                           surf_usm_h%qs,                      &
2320                                           surf_def_v(0)%qs,                   &
2321                                           surf_lsm_v(0)%qs,                   &
2322                                           surf_usm_v(0)%qs,                   &
2323                                           surf_def_v(1)%qs,                   &
2324                                           surf_lsm_v(1)%qs,                   &
2325                                           surf_usm_v(1)%qs,                   &
2326                                           surf_def_v(2)%qs,                   &
2327                                           surf_lsm_v(2)%qs,                   &
2328                                           surf_usm_v(2)%qs,                   &
2329                                           surf_def_v(3)%qs,                   &
2330                                           surf_lsm_v(3)%qs,                   &
2331                                           surf_usm_v(3)%qs, n_out ) 
2332
2333            CASE ( 'ss' )
2334               CALL surface_output_sum_up( surf_def_h(0)%ss,                   &
2335                                           surf_def_h(1)%ss,                   &
2336                                           surf_lsm_h%ss,                      &
2337                                           surf_usm_h%ss,                      &
2338                                           surf_def_v(0)%ss,                   &
2339                                           surf_lsm_v(0)%ss,                   &
2340                                           surf_usm_v(0)%ss,                   &
2341                                           surf_def_v(1)%ss,                   &
2342                                           surf_lsm_v(1)%ss,                   &
2343                                           surf_usm_v(1)%ss,                   &
2344                                           surf_def_v(2)%ss,                   &
2345                                           surf_lsm_v(2)%ss,                   &
2346                                           surf_usm_v(2)%ss,                   &
2347                                           surf_def_v(3)%ss,                   &
2348                                           surf_lsm_v(3)%ss,                   &
2349                                           surf_usm_v(3)%ss, n_out ) 
2350
2351            CASE ( 'qcs' )
2352               CALL surface_output_sum_up( surf_def_h(0)%qcs,                  &
2353                                           surf_def_h(1)%qcs,                  &
2354                                           surf_lsm_h%qcs,                     &
2355                                           surf_usm_h%qcs,                     &
2356                                           surf_def_v(0)%qcs,                  &
2357                                           surf_lsm_v(0)%qcs,                  &
2358                                           surf_usm_v(0)%qcs,                  &
2359                                           surf_def_v(1)%qcs,                  &
2360                                           surf_lsm_v(1)%qcs,                  &
2361                                           surf_usm_v(1)%qcs,                  &
2362                                           surf_def_v(2)%qcs,                  &
2363                                           surf_lsm_v(2)%qcs,                  &
2364                                           surf_usm_v(2)%qcs,                  &
2365                                           surf_def_v(3)%qcs,                  &
2366                                           surf_lsm_v(3)%qcs,                  &
2367                                           surf_usm_v(3)%qcs, n_out ) 
2368
2369            CASE ( 'ncs' )
2370               CALL surface_output_sum_up( surf_def_h(0)%ncs,                  &
2371                                           surf_def_h(1)%ncs,                  &
2372                                           surf_lsm_h%ncs,                     &
2373                                           surf_usm_h%ncs,                     &
2374                                           surf_def_v(0)%ncs,                  &
2375                                           surf_lsm_v(0)%ncs,                  &
2376                                           surf_usm_v(0)%ncs,                  &
2377                                           surf_def_v(1)%ncs,                  &
2378                                           surf_lsm_v(1)%ncs,                  &
2379                                           surf_usm_v(1)%ncs,                  &
2380                                           surf_def_v(2)%ncs,                  &
2381                                           surf_lsm_v(2)%ncs,                  &
2382                                           surf_usm_v(2)%ncs,                  &
2383                                           surf_def_v(3)%ncs,                  &
2384                                           surf_lsm_v(3)%ncs,                  &
2385                                           surf_usm_v(3)%ncs, n_out ) 
2386
2387            CASE ( 'qrs' )
2388               CALL surface_output_sum_up( surf_def_h(0)%qrs,                  &
2389                                           surf_def_h(1)%qrs,                  &
2390                                           surf_lsm_h%qrs,                     &
2391                                           surf_usm_h%qrs,                     &
2392                                           surf_def_v(0)%qrs,                  &
2393                                           surf_lsm_v(0)%qrs,                  &
2394                                           surf_usm_v(0)%qrs,                  &
2395                                           surf_def_v(1)%qrs,                  &
2396                                           surf_lsm_v(1)%qrs,                  &
2397                                           surf_usm_v(1)%qrs,                  &
2398                                           surf_def_v(2)%qrs,                  &
2399                                           surf_lsm_v(2)%qrs,                  &
2400                                           surf_usm_v(2)%qrs,                  &
2401                                           surf_def_v(3)%qrs,                  &
2402                                           surf_lsm_v(3)%qrs,                  &
2403                                           surf_usm_v(3)%qrs, n_out ) 
2404
2405            CASE ( 'nrs' )
2406               CALL surface_output_sum_up( surf_def_h(0)%nrs,                  &
2407                                           surf_def_h(1)%nrs,                  &
2408                                           surf_lsm_h%nrs,                     &
2409                                           surf_usm_h%nrs,                     &
2410                                           surf_def_v(0)%nrs,                  &
2411                                           surf_lsm_v(0)%nrs,                  &
2412                                           surf_usm_v(0)%nrs,                  &
2413                                           surf_def_v(1)%nrs,                  &
2414                                           surf_lsm_v(1)%nrs,                  &
2415                                           surf_usm_v(1)%nrs,                  &
2416                                           surf_def_v(2)%nrs,                  &
2417                                           surf_lsm_v(2)%nrs,                  &
2418                                           surf_usm_v(2)%nrs,                  &
2419                                           surf_def_v(3)%nrs,                  &
2420                                           surf_lsm_v(3)%nrs,                  &
2421                                           surf_usm_v(3)%nrs, n_out ) 
2422
2423            CASE ( 'ol' )
2424               CALL surface_output_sum_up( surf_def_h(0)%ol,                   &
2425                                           surf_def_h(1)%ol,                   &
2426                                           surf_lsm_h%ol,                      &
2427                                           surf_usm_h%ol,                      &
2428                                           surf_def_v(0)%ol,                   &
2429                                           surf_lsm_v(0)%ol,                   &
2430                                           surf_usm_v(0)%ol,                   &
2431                                           surf_def_v(1)%ol,                   &
2432                                           surf_lsm_v(1)%ol,                   &
2433                                           surf_usm_v(1)%ol,                   &
2434                                           surf_def_v(2)%ol,                   &
2435                                           surf_lsm_v(2)%ol,                   &
2436                                           surf_usm_v(2)%ol,                   &
2437                                           surf_def_v(3)%ol,                   &
2438                                           surf_lsm_v(3)%ol,                   &
2439                                           surf_usm_v(3)%ol, n_out ) 
2440
2441            CASE ( 'z0' )
2442               CALL surface_output_sum_up( surf_def_h(0)%z0,                   &
2443                                           surf_def_h(1)%z0,                   &
2444                                           surf_lsm_h%z0,                      &
2445                                           surf_usm_h%z0,                      &
2446                                           surf_def_v(0)%z0,                   &
2447                                           surf_lsm_v(0)%z0,                   &
2448                                           surf_usm_v(0)%z0,                   &
2449                                           surf_def_v(1)%z0,                   &
2450                                           surf_lsm_v(1)%z0,                   &
2451                                           surf_usm_v(1)%z0,                   &
2452                                           surf_def_v(2)%z0,                   &
2453                                           surf_lsm_v(2)%z0,                   &
2454                                           surf_usm_v(2)%z0,                   &
2455                                           surf_def_v(3)%z0,                   &
2456                                           surf_lsm_v(3)%z0,                   &
2457                                           surf_usm_v(3)%z0, n_out ) 
2458
2459            CASE ( 'z0h' )
2460               CALL surface_output_sum_up( surf_def_h(0)%z0h,                  &
2461                                           surf_def_h(1)%z0h,                  &
2462                                           surf_lsm_h%z0h,                     &
2463                                           surf_usm_h%z0h,                     &
2464                                           surf_def_v(0)%z0h,                  &
2465                                           surf_lsm_v(0)%z0h,                  &
2466                                           surf_usm_v(0)%z0h,                  &
2467                                           surf_def_v(1)%z0h,                  &
2468                                           surf_lsm_v(1)%z0h,                  &
2469                                           surf_usm_v(1)%z0h,                  &
2470                                           surf_def_v(2)%z0h,                  &
2471                                           surf_lsm_v(2)%z0h,                  &
2472                                           surf_usm_v(2)%z0h,                  &
2473                                           surf_def_v(3)%z0h,                  &
2474                                           surf_lsm_v(3)%z0h,                  &
2475                                           surf_usm_v(3)%z0h, n_out )         
2476
2477            CASE ( 'z0q' )
2478               CALL surface_output_sum_up( surf_def_h(0)%z0q,                  &
2479                                           surf_def_h(1)%z0q,                  &
2480                                           surf_lsm_h%z0q,                     &
2481                                           surf_usm_h%z0q,                     &
2482                                           surf_def_v(0)%z0q,                  &
2483                                           surf_lsm_v(0)%z0q,                  &
2484                                           surf_usm_v(0)%z0q,                  &
2485                                           surf_def_v(1)%z0q,                  &
2486                                           surf_lsm_v(1)%z0q,                  &
2487                                           surf_usm_v(1)%z0q,                  &
2488                                           surf_def_v(2)%z0q,                  &
2489                                           surf_lsm_v(2)%z0q,                  &
2490                                           surf_usm_v(2)%z0q,                  &
2491                                           surf_def_v(3)%z0q,                  &
2492                                           surf_lsm_v(3)%z0q,                  &
2493                                           surf_usm_v(3)%z0q, n_out ) 
2494
2495            CASE ( 'theta1' )                                                 
2496               CALL surface_output_sum_up( surf_def_h(0)%pt1,                  &
2497                                           surf_def_h(1)%pt1,                  &
2498                                           surf_lsm_h%pt1,                     &
2499                                           surf_usm_h%pt1,                     &
2500                                           surf_def_v(0)%pt1,                  &
2501                                           surf_lsm_v(0)%pt1,                  &
2502                                           surf_usm_v(0)%pt1,                  &
2503                                           surf_def_v(1)%pt1,                  &
2504                                           surf_lsm_v(1)%pt1,                  &
2505                                           surf_usm_v(1)%pt1,                  &
2506                                           surf_def_v(2)%pt1,                  &
2507                                           surf_lsm_v(2)%pt1,                  &
2508                                           surf_usm_v(2)%pt1,                  &
2509                                           surf_def_v(3)%pt1,                  &
2510                                           surf_lsm_v(3)%pt1,                  &
2511                                           surf_usm_v(3)%pt1, n_out )         
2512                                                                               
2513            CASE ( 'qv1' )                                                     
2514               CALL surface_output_sum_up( surf_def_h(0)%qv1,                  &
2515                                           surf_def_h(1)%qv1,                  &
2516                                           surf_lsm_h%qv1,                     &
2517                                           surf_usm_h%qv1,                     &
2518                                           surf_def_v(0)%qv1,                  &
2519                                           surf_lsm_v(0)%qv1,                  &
2520                                           surf_usm_v(0)%qv1,                  &
2521                                           surf_def_v(1)%qv1,                  &
2522                                           surf_lsm_v(1)%qv1,                  &
2523                                           surf_usm_v(1)%qv1,                  &
2524                                           surf_def_v(2)%qv1,                  &
2525                                           surf_lsm_v(2)%qv1,                  &
2526                                           surf_usm_v(2)%qv1,                  &
2527                                           surf_def_v(3)%qv1,                  &
2528                                           surf_lsm_v(3)%qv1,                  &
2529                                           surf_usm_v(3)%qv1, n_out ) 
2530
2531            CASE ( 'thetav1' )
2532               CALL surface_output_sum_up( surf_def_h(0)%vpt1,                 &
2533                                           surf_def_h(1)%vpt1,                 &
2534                                           surf_lsm_h%vpt1,                    &
2535                                           surf_usm_h%vpt1,                    &
2536                                           surf_def_v(0)%vpt1,                 &
2537                                           surf_lsm_v(0)%vpt1,                 &
2538                                           surf_usm_v(0)%vpt1,                 &
2539                                           surf_def_v(1)%vpt1,                 &
2540                                           surf_lsm_v(1)%vpt1,                 &
2541                                           surf_usm_v(1)%vpt1,                 &
2542                                           surf_def_v(2)%vpt1,                 &
2543                                           surf_lsm_v(2)%vpt1,                 &
2544                                           surf_usm_v(2)%vpt1,                 &
2545                                           surf_def_v(3)%vpt1,                 &
2546                                           surf_lsm_v(3)%vpt1,                 &
2547                                           surf_usm_v(3)%vpt1, n_out ) 
2548
2549            CASE ( 'usws' )
2550               CALL surface_output_sum_up( surf_def_h(0)%usws,                 &
2551                                           surf_def_h(1)%usws,                 &
2552                                           surf_lsm_h%usws,                    &
2553                                           surf_usm_h%usws,                    &
2554                                           surf_def_v(0)%usws,                 &
2555                                           surf_lsm_v(0)%usws,                 &
2556                                           surf_usm_v(0)%usws,                 &
2557                                           surf_def_v(1)%usws,                 &
2558                                           surf_lsm_v(1)%usws,                 &
2559                                           surf_usm_v(1)%usws,                 &
2560                                           surf_def_v(2)%usws,                 &
2561                                           surf_lsm_v(2)%usws,                 &
2562                                           surf_usm_v(2)%usws,                 &
2563                                           surf_def_v(3)%usws,                 &
2564                                           surf_lsm_v(3)%usws,                 &
2565                                           surf_usm_v(3)%usws, n_out ) 
2566
2567            CASE ( 'vsws' )
2568               CALL surface_output_sum_up( surf_def_h(0)%vsws,                 &
2569                                           surf_def_h(1)%vsws,                 &
2570                                           surf_lsm_h%vsws,                    &
2571                                           surf_usm_h%vsws,                    &
2572                                           surf_def_v(0)%vsws,                 &
2573                                           surf_lsm_v(0)%vsws,                 &
2574                                           surf_usm_v(0)%vsws,                 &
2575                                           surf_def_v(1)%vsws,                 &
2576                                           surf_lsm_v(1)%vsws,                 &
2577                                           surf_usm_v(1)%vsws,                 &
2578                                           surf_def_v(2)%vsws,                 &
2579                                           surf_lsm_v(2)%vsws,                 &
2580                                           surf_usm_v(2)%vsws,                 &
2581                                           surf_def_v(3)%vsws,                 &
2582                                           surf_lsm_v(3)%vsws,                 &
2583                                           surf_usm_v(3)%vsws, n_out ) 
2584
2585            CASE ( 'shf' )
2586               CALL surface_output_sum_up( surf_def_h(0)%shf,                  &
2587                                           surf_def_h(1)%shf,                  &
2588                                           surf_lsm_h%shf,                     &
2589                                           surf_usm_h%shf,                     & 
2590                                           surf_def_v(0)%shf,                  &
2591                                           surf_lsm_v(0)%shf,                  &
2592                                           surf_usm_v(0)%shf,                  &
2593                                           surf_def_v(1)%shf,                  &
2594                                           surf_lsm_v(1)%shf,                  &
2595                                           surf_usm_v(1)%shf,                  &
2596                                           surf_def_v(2)%shf,                  &
2597                                           surf_lsm_v(2)%shf,                  &
2598                                           surf_usm_v(2)%shf,                  &
2599                                           surf_def_v(3)%shf,                  &
2600                                           surf_lsm_v(3)%shf,                  &
2601                                           surf_usm_v(3)%shf, n_out )
2602
2603            CASE ( 'qsws' )
2604               CALL surface_output_sum_up( surf_def_h(0)%qsws,                 &
2605                                           surf_def_h(1)%qsws,                 &
2606                                           surf_lsm_h%qsws,                    &
2607                                           surf_usm_h%qsws,                    &
2608                                           surf_def_v(0)%qsws,                 &
2609                                           surf_lsm_v(0)%qsws,                 &
2610                                           surf_usm_v(0)%qsws,                 &
2611                                           surf_def_v(1)%qsws,                 &
2612                                           surf_lsm_v(1)%qsws,                 &
2613                                           surf_usm_v(1)%qsws,                 &
2614                                           surf_def_v(2)%qsws,                 &
2615                                           surf_lsm_v(2)%qsws,                 &
2616                                           surf_usm_v(2)%qsws,                 &
2617                                           surf_def_v(3)%qsws,                 &
2618                                           surf_lsm_v(3)%qsws,                 &
2619                                           surf_usm_v(3)%qsws, n_out ) 
2620
2621            CASE ( 'ssws' )
2622               CALL surface_output_sum_up( surf_def_h(0)%ssws,                 &
2623                                           surf_def_h(1)%ssws,                 &
2624                                           surf_lsm_h%ssws,                    &
2625                                           surf_usm_h%ssws,                    &
2626                                           surf_def_v(0)%ssws,                 &
2627                                           surf_lsm_v(0)%ssws,                 &
2628                                           surf_usm_v(0)%ssws,                 &
2629                                           surf_def_v(1)%ssws,                 &
2630                                           surf_lsm_v(1)%ssws,                 &
2631                                           surf_usm_v(1)%ssws,                 &
2632                                           surf_def_v(2)%ssws,                 &
2633                                           surf_lsm_v(2)%ssws,                 &
2634                                           surf_usm_v(2)%ssws,                 &
2635                                           surf_def_v(3)%ssws,                 &
2636                                           surf_lsm_v(3)%ssws,                 &
2637                                           surf_usm_v(3)%ssws, n_out ) 
2638
2639            CASE ( 'qcsws' )
2640               CALL surface_output_sum_up( surf_def_h(0)%qcsws,                &
2641                                           surf_def_h(1)%qcsws,                &
2642                                           surf_lsm_h%qcsws,                   &
2643                                           surf_usm_h%qcsws,                   &
2644                                           surf_def_v(0)%qcsws,                &
2645                                           surf_lsm_v(0)%qcsws,                &
2646                                           surf_usm_v(0)%qcsws,                &
2647                                           surf_def_v(1)%qcsws,                &
2648                                           surf_lsm_v(1)%qcsws,                &
2649                                           surf_usm_v(1)%qcsws,                &
2650                                           surf_def_v(2)%qcsws,                &
2651                                           surf_lsm_v(2)%qcsws,                &
2652                                           surf_usm_v(2)%qcsws,                &
2653                                           surf_def_v(3)%qcsws,                &
2654                                           surf_lsm_v(3)%qcsws,                &
2655                                           surf_usm_v(3)%qcsws, n_out ) 
2656
2657            CASE ( 'ncsws' )
2658               CALL surface_output_sum_up( surf_def_h(0)%ncsws,                &
2659                                           surf_def_h(1)%ncsws,                &
2660                                           surf_lsm_h%ncsws,                   &
2661                                           surf_usm_h%ncsws,                   &
2662                                           surf_def_v(0)%ncsws,                &
2663                                           surf_lsm_v(0)%ncsws,                &
2664                                           surf_usm_v(0)%ncsws,                &
2665                                           surf_def_v(1)%ncsws,                &
2666                                           surf_lsm_v(1)%ncsws,                &
2667                                           surf_usm_v(1)%ncsws,                &
2668                                           surf_def_v(2)%ncsws,                &
2669                                           surf_lsm_v(2)%ncsws,                &
2670                                           surf_usm_v(2)%ncsws,                &
2671                                           surf_def_v(3)%ncsws,                &
2672                                           surf_lsm_v(3)%ncsws,                &
2673                                           surf_usm_v(3)%ncsws, n_out ) 
2674
2675            CASE ( 'qrsws' )
2676               CALL surface_output_sum_up( surf_def_h(0)%qrsws,                &
2677                                           surf_def_h(1)%qrsws,                &
2678                                           surf_lsm_h%qrsws,                   &
2679                                           surf_usm_h%qrsws,                   &
2680                                           surf_def_v(0)%qrsws,                &
2681                                           surf_lsm_v(0)%qrsws,                &
2682                                           surf_usm_v(0)%qrsws,                &
2683                                           surf_def_v(1)%qrsws,                &
2684                                           surf_lsm_v(1)%qrsws,                &
2685                                           surf_usm_v(1)%qrsws,                &
2686                                           surf_def_v(2)%qrsws,                &
2687                                           surf_lsm_v(2)%qrsws,                &
2688                                           surf_usm_v(2)%qrsws,                &
2689                                           surf_def_v(3)%qrsws,                &
2690                                           surf_lsm_v(3)%qrsws,                &
2691                                           surf_usm_v(3)%qrsws, n_out ) 
2692
2693            CASE ( 'nrsws' )
2694               CALL surface_output_sum_up( surf_def_h(0)%nrsws,                &
2695                                           surf_def_h(1)%nrsws,                &
2696                                           surf_lsm_h%nrsws,                   &
2697                                           surf_usm_h%nrsws,                   &
2698                                           surf_def_v(0)%nrsws,                &
2699                                           surf_lsm_v(0)%nrsws,                &
2700                                           surf_usm_v(0)%nrsws,                &
2701                                           surf_def_v(1)%nrsws,                &
2702                                           surf_lsm_v(1)%nrsws,                &
2703                                           surf_usm_v(1)%nrsws,                &
2704                                           surf_def_v(2)%nrsws,                &
2705                                           surf_lsm_v(2)%nrsws,                &
2706                                           surf_usm_v(2)%nrsws,                &
2707                                           surf_def_v(3)%nrsws,                &
2708                                           surf_lsm_v(3)%nrsws,                &
2709                                           surf_usm_v(3)%nrsws, n_out ) 
2710
2711            CASE ( 'sasws' )
2712               CALL surface_output_sum_up( surf_def_h(0)%sasws,                &
2713                                           surf_def_h(1)%sasws,                &
2714                                           surf_lsm_h%sasws,                   &
2715                                           surf_usm_h%sasws,                   &
2716                                           surf_def_v(0)%sasws,                &
2717                                           surf_lsm_v(0)%sasws,                &
2718                                           surf_usm_v(0)%sasws,                &
2719                                           surf_def_v(1)%sasws,                &
2720                                           surf_lsm_v(1)%sasws,                &
2721                                           surf_usm_v(1)%sasws,                &
2722                                           surf_def_v(2)%sasws,                &
2723                                           surf_lsm_v(2)%sasws,                &
2724                                           surf_usm_v(2)%sasws,                &
2725                                           surf_def_v(3)%sasws,                &
2726                                           surf_lsm_v(3)%sasws,                &
2727                                           surf_usm_v(3)%sasws, n_out ) 
2728
2729            CASE ( 'q_surface' )
2730               CALL surface_output_sum_up( surf_def_h(0)%q_surface,            &
2731                                           surf_def_h(1)%q_surface,            &
2732                                           surf_lsm_h%q_surface,               &
2733                                           surf_usm_h%q_surface,               &
2734                                           surf_def_v(0)%q_surface,            &
2735                                           surf_lsm_v(0)%q_surface,            &
2736                                           surf_usm_v(0)%q_surface,            &
2737                                           surf_def_v(1)%q_surface,            &
2738                                           surf_lsm_v(1)%q_surface,            &
2739                                           surf_usm_v(1)%q_surface,            &
2740                                           surf_def_v(2)%q_surface,            &
2741                                           surf_lsm_v(2)%q_surface,            &
2742                                           surf_usm_v(2)%q_surface,            &
2743                                           surf_def_v(3)%q_surface,            &
2744                                           surf_lsm_v(3)%q_surface,            &
2745                                           surf_usm_v(3)%q_surface, n_out ) 
2746
2747            CASE ( 'theta_surface' )
2748               CALL surface_output_sum_up( surf_def_h(0)%pt_surface,           &
2749                                           surf_def_h(1)%pt_surface,           &
2750                                           surf_lsm_h%pt_surface,              &
2751                                           surf_usm_h%pt_surface,              &
2752                                           surf_def_v(0)%pt_surface,           &
2753                                           surf_lsm_v(0)%pt_surface,           &
2754                                           surf_usm_v(0)%pt_surface,           &
2755                                           surf_def_v(1)%pt_surface,           &
2756                                           surf_lsm_v(1)%pt_surface,           &
2757                                           surf_usm_v(1)%pt_surface,           &
2758                                           surf_def_v(2)%pt_surface,           &
2759                                           surf_lsm_v(2)%pt_surface,           &
2760                                           surf_usm_v(2)%pt_surface,           &
2761                                           surf_def_v(3)%pt_surface,           &
2762                                           surf_lsm_v(3)%pt_surface,           &
2763                                           surf_usm_v(3)%pt_surface, n_out ) 
2764
2765            CASE ( 'thetav_surface' )
2766               CALL surface_output_sum_up( surf_def_h(0)%vpt_surface,          &
2767                                           surf_def_h(1)%vpt_surface,          &
2768                                           surf_lsm_h%vpt_surface,             &
2769                                           surf_usm_h%vpt_surface,             &
2770                                           surf_def_v(0)%vpt_surface,          &
2771                                           surf_lsm_v(0)%vpt_surface,          &
2772                                           surf_usm_v(0)%vpt_surface,          &
2773                                           surf_def_v(1)%vpt_surface,          &
2774                                           surf_lsm_v(1)%vpt_surface,          &
2775                                           surf_usm_v(1)%vpt_surface,          &
2776                                           surf_def_v(2)%vpt_surface,          &
2777                                           surf_lsm_v(2)%vpt_surface,          &
2778                                           surf_usm_v(2)%vpt_surface,          &
2779                                           surf_def_v(3)%vpt_surface,          &
2780                                           surf_lsm_v(3)%vpt_surface,          &
2781                                           surf_usm_v(3)%vpt_surface, n_out ) 
2782
2783            CASE ( 'rad_net' )
2784               CALL surface_output_sum_up( surf_def_h(0)%rad_net,              &
2785                                           surf_def_h(1)%rad_net,              &
2786                                           surf_lsm_h%rad_net,                 &
2787                                           surf_usm_h%rad_net,                 &
2788                                           surf_def_v(0)%rad_net,              &
2789                                           surf_lsm_v(0)%rad_net,              &
2790                                           surf_usm_v(0)%rad_net,              &
2791                                           surf_def_v(1)%rad_net,              &
2792                                           surf_lsm_v(1)%rad_net,              &
2793                                           surf_usm_v(1)%rad_net,              &
2794                                           surf_def_v(2)%rad_net,              &
2795                                           surf_lsm_v(2)%rad_net,              &
2796                                           surf_usm_v(2)%rad_net,              &
2797                                           surf_def_v(3)%rad_net,              &
2798                                           surf_lsm_v(3)%rad_net,              &
2799                                           surf_usm_v(3)%rad_net, n_out ) 
2800
2801            CASE ( 'rad_lw_in' )
2802               CALL surface_output_sum_up( surf_def_h(0)%rad_lw_in,            &
2803                                           surf_def_h(1)%rad_lw_in,            &
2804                                           surf_lsm_h%rad_lw_in,               &
2805                                           surf_usm_h%rad_lw_in,               &
2806                                           surf_def_v(0)%rad_lw_in,            &
2807                                           surf_lsm_v(0)%rad_lw_in,            &
2808                                           surf_usm_v(0)%rad_lw_in,            &
2809                                           surf_def_v(1)%rad_lw_in,            &
2810                                           surf_lsm_v(1)%rad_lw_in,            &
2811                                           surf_usm_v(1)%rad_lw_in,            &
2812                                           surf_def_v(2)%rad_lw_in,            &
2813                                           surf_lsm_v(2)%rad_lw_in,            &
2814                                           surf_usm_v(2)%rad_lw_in,            &
2815                                           surf_def_v(3)%rad_lw_in,            &
2816                                           surf_lsm_v(3)%rad_lw_in,            &
2817                                           surf_usm_v(3)%rad_lw_in, n_out ) 
2818
2819            CASE ( 'rad_lw_out' )
2820               CALL surface_output_sum_up( surf_def_h(0)%rad_lw_out,           &
2821                                           surf_def_h(1)%rad_lw_out,           &
2822                                           surf_lsm_h%rad_lw_out,              &
2823                                           surf_usm_h%rad_lw_out,              &
2824                                           surf_def_v(0)%rad_lw_out,           &
2825                                           surf_lsm_v(0)%rad_lw_out,           &
2826                                           surf_usm_v(0)%rad_lw_out,           &
2827                                           surf_def_v(1)%rad_lw_out,           &
2828                                           surf_lsm_v(1)%rad_lw_out,           &
2829                                           surf_usm_v(1)%rad_lw_out,           &
2830                                           surf_def_v(2)%rad_lw_out,           &
2831                                           surf_lsm_v(2)%rad_lw_out,           &
2832                                           surf_usm_v(2)%rad_lw_out,           &
2833                                           surf_def_v(3)%rad_lw_out,           &
2834                                           surf_lsm_v(3)%rad_lw_out,           &
2835                                           surf_usm_v(3)%rad_lw_out, n_out ) 
2836
2837            CASE ( 'rad_sw_in' )
2838               CALL surface_output_sum_up( surf_def_h(0)%rad_sw_in,            &
2839                                           surf_def_h(1)%rad_sw_in,            &
2840                                           surf_lsm_h%rad_sw_in,               &
2841                                           surf_usm_h%rad_sw_in,               &
2842                                           surf_def_v(0)%rad_sw_in,            &
2843                                           surf_lsm_v(0)%rad_sw_in,            &
2844                                           surf_usm_v(0)%rad_sw_in,            &
2845                                           surf_def_v(1)%rad_sw_in,            &
2846                                           surf_lsm_v(1)%rad_sw_in,            &
2847                                           surf_usm_v(1)%rad_sw_in,            &
2848                                           surf_def_v(2)%rad_sw_in,            &
2849                                           surf_lsm_v(2)%rad_sw_in,            &
2850                                           surf_usm_v(2)%rad_sw_in,            &
2851                                           surf_def_v(3)%rad_sw_in,            &
2852                                           surf_lsm_v(3)%rad_sw_in,            &
2853                                           surf_usm_v(3)%rad_sw_in, n_out ) 
2854
2855            CASE ( 'rad_sw_out' )
2856               CALL surface_output_sum_up( surf_def_h(0)%rad_sw_out,           &
2857                                           surf_def_h(1)%rad_sw_out,           &
2858                                           surf_lsm_h%rad_sw_out,              &
2859                                           surf_usm_h%rad_sw_out,              &
2860                                           surf_def_v(0)%rad_sw_out,           &
2861                                           surf_lsm_v(0)%rad_sw_out,           &
2862                                           surf_usm_v(0)%rad_sw_out,           &
2863                                           surf_def_v(1)%rad_sw_out,           &
2864                                           surf_lsm_v(1)%rad_sw_out,           &
2865                                           surf_usm_v(1)%rad_sw_out,           &
2866                                           surf_def_v(2)%rad_sw_out,           &
2867                                           surf_lsm_v(2)%rad_sw_out,           &
2868                                           surf_usm_v(2)%rad_sw_out,           &
2869                                           surf_def_v(3)%rad_sw_out,           &
2870                                           surf_lsm_v(3)%rad_sw_out,           &
2871                                           surf_usm_v(3)%rad_sw_out, n_out ) 
2872
2873            CASE ( 'ghf' )
2874               CALL surface_output_sum_up( surf_def_h(0)%ghf,                  &
2875                                           surf_def_h(1)%ghf,                  &
2876                                           surf_lsm_h%ghf,                     &
2877                                           surf_usm_h%ghf,                     &
2878                                           surf_def_v(0)%ghf,                  &
2879                                           surf_lsm_v(0)%ghf,                  &
2880                                           surf_usm_v(0)%ghf,                  &
2881                                           surf_def_v(1)%ghf,                  &
2882                                           surf_lsm_v(1)%ghf,                  &
2883                                           surf_usm_v(1)%ghf,                  &
2884                                           surf_def_v(2)%ghf,                  &
2885                                           surf_lsm_v(2)%ghf,                  &
2886                                           surf_usm_v(2)%ghf,                  &
2887                                           surf_def_v(3)%ghf,                  &
2888                                           surf_lsm_v(3)%ghf,                  &
2889                                           surf_usm_v(3)%ghf, n_out )         
2890                                                                               
2891            CASE ( 'r_a' )                                                     
2892               CALL surface_output_sum_up( surf_def_h(0)%r_a,                  &
2893                                           surf_def_h(1)%r_a,                  &
2894                                           surf_lsm_h%r_a,                     &
2895                                           surf_usm_h%r_a,                     &
2896                                           surf_def_v(0)%r_a,                  &
2897                                           surf_lsm_v(0)%r_a,                  &
2898                                           surf_usm_v(0)%r_a,                  &
2899                                           surf_def_v(1)%r_a,                  &
2900                                           surf_lsm_v(1)%r_a,                  &
2901                                           surf_usm_v(1)%r_a,                  &
2902                                           surf_def_v(2)%r_a,                  &
2903                                           surf_lsm_v(2)%r_a,                  &
2904                                           surf_usm_v(2)%r_a,                  &
2905                                           surf_def_v(3)%r_a,                  &
2906                                           surf_lsm_v(3)%r_a,                  &
2907                                           surf_usm_v(3)%r_a, n_out )         
2908                                                                               
2909            CASE ( 'r_soil' )                                                 
2910               CALL surface_output_sum_up( surf_def_h(0)%r_soil,               &
2911                                           surf_def_h(1)%r_soil,               &
2912                                           surf_lsm_h%r_soil,                  &
2913                                           surf_usm_h%r_soil,                  &
2914                                           surf_def_v(0)%r_soil,               &
2915                                           surf_lsm_v(0)%r_soil,               &
2916                                           surf_usm_v(0)%r_soil,               &
2917                                           surf_def_v(1)%r_soil,               &
2918                                           surf_lsm_v(1)%r_soil,               &
2919                                           surf_usm_v(1)%r_soil,               &
2920                                           surf_def_v(2)%r_soil,               &
2921                                           surf_lsm_v(2)%r_soil,               &
2922                                           surf_usm_v(2)%r_soil,               &
2923                                           surf_def_v(3)%r_soil,               &
2924                                           surf_lsm_v(3)%r_soil,               &
2925                                           surf_usm_v(3)%r_soil, n_out ) 
2926
2927            CASE ( 'r_canopy' )
2928               CALL surface_output_sum_up( surf_def_h(0)%r_canopy,             &
2929                                           surf_def_h(1)%r_canopy,             &
2930                                           surf_lsm_h%r_canopy,                &
2931                                           surf_usm_h%r_canopy,                &
2932                                           surf_def_v(0)%r_canopy,             &
2933                                           surf_lsm_v(0)%r_canopy,             &
2934                                           surf_usm_v(0)%r_canopy,             &
2935                                           surf_def_v(1)%r_canopy,             &
2936                                           surf_lsm_v(1)%r_canopy,             &
2937                                           surf_usm_v(1)%r_canopy,             &
2938                                           surf_def_v(2)%r_canopy,             &
2939                                           surf_lsm_v(2)%r_canopy,             &
2940                                           surf_usm_v(2)%r_canopy,             &
2941                                           surf_def_v(3)%r_canopy,             &
2942                                           surf_lsm_v(3)%r_canopy,             &
2943                                           surf_usm_v(3)%r_canopy, n_out ) 
2944
2945            CASE ( 'r_s' )
2946               CALL surface_output_sum_up( surf_def_h(0)%r_s,                  &
2947                                           surf_def_h(1)%r_s,                  &
2948                                           surf_lsm_h%r_s,                     &
2949                                           surf_usm_h%r_s,                     &
2950                                           surf_def_v(0)%r_s,                  &
2951                                           surf_lsm_v(0)%r_s,                  &
2952                                           surf_usm_v(0)%r_s,                  &
2953                                           surf_def_v(1)%r_s,                  &
2954                                           surf_lsm_v(1)%r_s,                  &
2955                                           surf_usm_v(1)%r_s,                  &
2956                                           surf_def_v(2)%r_s,                  &
2957                                           surf_lsm_v(2)%r_s,                  &
2958                                           surf_usm_v(2)%r_s,                  &
2959                                           surf_def_v(3)%r_s,                  &
2960                                           surf_lsm_v(3)%r_s,                  &
2961                                           surf_usm_v(3)%r_s, n_out ) 
2962
2963
2964            CASE ( 'rad_sw_dir' )
2965               CALL surface_output_sum_up( surf_def_h(0)%rad_sw_dir,           &
2966                                           surf_def_h(1)%rad_sw_dir,           &
2967                                           surf_lsm_h%rad_sw_dir,              &
2968                                           surf_usm_h%rad_sw_dir,              &
2969                                           surf_def_v(0)%rad_sw_dir,           &
2970                                           surf_lsm_v(0)%rad_sw_dir,           &
2971                                           surf_usm_v(0)%rad_sw_dir,           &
2972                                           surf_def_v(1)%rad_sw_dir,           &
2973                                           surf_lsm_v(1)%rad_sw_dir,           &
2974                                           surf_usm_v(1)%rad_sw_dir,           &
2975                                           surf_def_v(2)%rad_sw_dir,           &
2976                                           surf_lsm_v(2)%rad_sw_dir,           &
2977                                           surf_usm_v(2)%rad_sw_dir,           &
2978                                           surf_def_v(3)%rad_sw_dir,           &
2979                                           surf_lsm_v(3)%rad_sw_dir,           &
2980                                           surf_usm_v(3)%rad_sw_dir, n_out )
2981            CASE ( 'rad_sw_dif' )
2982               CALL surface_output_sum_up( surf_def_h(0)%rad_sw_dif,           &
2983                                           surf_def_h(1)%rad_sw_dif,           &
2984                                           surf_lsm_h%rad_sw_dif,              &
2985                                           surf_usm_h%rad_sw_dif,              &
2986                                           surf_def_v(0)%rad_sw_dif,           &
2987                                           surf_lsm_v(0)%rad_sw_dif,           &
2988                                           surf_usm_v(0)%rad_sw_dif,           &
2989                                           surf_def_v(1)%rad_sw_dif,           &
2990                                           surf_lsm_v(1)%rad_sw_dif,           &
2991                                           surf_usm_v(1)%rad_sw_dif,           &
2992                                           surf_def_v(2)%rad_sw_dif,           &
2993                                           surf_lsm_v(2)%rad_sw_dif,           &
2994                                           surf_usm_v(2)%rad_sw_dif,           &
2995                                           surf_def_v(3)%rad_sw_dif,           &
2996                                           surf_lsm_v(3)%rad_sw_dif,           &
2997                                           surf_usm_v(3)%rad_sw_dif, n_out )
2998
2999            CASE ( 'rad_sw_ref' )
3000               CALL surface_output_sum_up( surf_def_h(0)%rad_sw_ref,           &
3001                                           surf_def_h(1)%rad_sw_ref,           &
3002                                           surf_lsm_h%rad_sw_ref,              &
3003                                           surf_usm_h%rad_sw_ref,              &
3004                                           surf_def_v(0)%rad_sw_ref,           &
3005                                           surf_lsm_v(0)%rad_sw_ref,           &
3006                                           surf_usm_v(0)%rad_sw_ref,           &
3007                                           surf_def_v(1)%rad_sw_ref,           &
3008                                           surf_lsm_v(1)%rad_sw_ref,           &
3009                                           surf_usm_v(1)%rad_sw_ref,           &
3010                                           surf_def_v(2)%rad_sw_ref,           &
3011                                           surf_lsm_v(2)%rad_sw_ref,           &
3012                                           surf_usm_v(2)%rad_sw_ref,           &
3013                                           surf_def_v(3)%rad_sw_ref,           &
3014                                           surf_lsm_v(3)%rad_sw_ref,           &
3015                                           surf_usm_v(3)%rad_sw_ref, n_out )
3016               
3017            CASE ( 'rad_sw_res' )
3018               CALL surface_output_sum_up( surf_def_h(0)%rad_sw_res,           &
3019                                           surf_def_h(1)%rad_sw_res,           &
3020                                           surf_lsm_h%rad_sw_res,              &
3021                                           surf_usm_h%rad_sw_res,              &
3022                                           surf_def_v(0)%rad_sw_res,           &
3023                                           surf_lsm_v(0)%rad_sw_res,           &
3024                                           surf_usm_v(0)%rad_sw_res,           &
3025                                           surf_def_v(1)%rad_sw_res,           &
3026                                           surf_lsm_v(1)%rad_sw_res,           &
3027                                           surf_usm_v(1)%rad_sw_res,           &
3028                                           surf_def_v(2)%rad_sw_res,           &
3029                                           surf_lsm_v(2)%rad_sw_res,           &
3030                                           surf_usm_v(2)%rad_sw_res,           &
3031                                           surf_def_v(3)%rad_sw_res,           &
3032                                           surf_lsm_v(3)%rad_sw_res,           &
3033                                           surf_usm_v(3)%rad_sw_res, n_out )
3034
3035            CASE ( 'rad_lw_dif' )
3036               CALL surface_output_sum_up( surf_def_h(0)%rad_lw_dif,           &
3037                                           surf_def_h(1)%rad_lw_dif,           &
3038                                           surf_lsm_h%rad_lw_dif,              &
3039                                           surf_usm_h%rad_lw_dif,              &
3040                                           surf_def_v(0)%rad_lw_dif,           &
3041                                           surf_lsm_v(0)%rad_lw_dif,           &
3042                                           surf_usm_v(0)%rad_lw_dif,           &
3043                                           surf_def_v(1)%rad_lw_dif,           &
3044                                           surf_lsm_v(1)%rad_lw_dif,           &
3045                                           surf_usm_v(1)%rad_lw_dif,           &
3046                                           surf_def_v(2)%rad_lw_dif,           &
3047                                           surf_lsm_v(2)%rad_lw_dif,           &
3048                                           surf_usm_v(2)%rad_lw_dif,           &
3049                                           surf_def_v(3)%rad_lw_dif,           &
3050                                           surf_lsm_v(3)%rad_lw_dif,           &
3051                                           surf_usm_v(3)%rad_lw_dif, n_out )
3052
3053            CASE ( 'rad_lw_ref' )
3054               CALL surface_output_sum_up( surf_def_h(0)%rad_lw_ref,           &
3055                                           surf_def_h(1)%rad_lw_ref,           &
3056                                           surf_lsm_h%rad_lw_ref,              &
3057                                           surf_usm_h%rad_lw_ref,              &
3058                                           surf_def_v(0)%rad_lw_ref,           &
3059                                           surf_lsm_v(0)%rad_lw_ref,           &
3060                                           surf_usm_v(0)%rad_lw_ref,           &
3061                                           surf_def_v(1)%rad_lw_ref,           &
3062                                           surf_lsm_v(1)%rad_lw_ref,           &
3063                                           surf_usm_v(1)%rad_lw_ref,           &
3064                                           surf_def_v(2)%rad_lw_ref,           &
3065                                           surf_lsm_v(2)%rad_lw_ref,           &
3066                                           surf_usm_v(2)%rad_lw_ref,           &
3067                                           surf_def_v(3)%rad_lw_ref,           &
3068                                           surf_lsm_v(3)%rad_lw_ref,           &
3069                                           surf_usm_v(3)%rad_lw_ref, n_out )
3070
3071            CASE ( 'rad_lw_res' )
3072               CALL surface_output_sum_up( surf_def_h(0)%rad_lw_res,           &
3073                                           surf_def_h(1)%rad_lw_res,           &
3074                                           surf_lsm_h%rad_lw_res,              &
3075                                           surf_usm_h%rad_lw_res,              &
3076                                           surf_def_v(0)%rad_lw_res,           &
3077                                           surf_lsm_v(0)%rad_lw_res,           &
3078                                           surf_usm_v(0)%rad_lw_res,           &
3079                                           surf_def_v(1)%rad_lw_res,           &
3080                                           surf_lsm_v(1)%rad_lw_res,           &
3081                                           surf_usm_v(1)%rad_lw_res,           &
3082                                           surf_def_v(2)%rad_lw_res,           &
3083                                           surf_lsm_v(2)%rad_lw_res,           &
3084                                           surf_usm_v(2)%rad_lw_res,           &
3085                                           surf_def_v(3)%rad_lw_res,           &
3086                                           surf_lsm_v(3)%rad_lw_res,           &
3087                                           surf_usm_v(3)%rad_lw_res, n_out )
3088
3089         END SELECT
3090      ENDDO
3091     
3092   
3093   END SUBROUTINE surface_output_averaging
3094   
3095!------------------------------------------------------------------------------!
3096! Description:
3097! ------------
3098!> Sum-up the surface data for average output variables. 
3099!------------------------------------------------------------------------------!   
3100   SUBROUTINE surface_output_sum_up( var_def_h0, var_def_h1,                   &
3101                                     var_lsm_h,  var_usm_h,                    &
3102                                     var_def_v0, var_lsm_v0, var_usm_v0,       &
3103                                     var_def_v1, var_lsm_v1, var_usm_v1,       &
3104                                     var_def_v2, var_lsm_v2, var_usm_v2,       &
3105                                     var_def_v3, var_lsm_v3, var_usm_v3, n_out )
3106   
3107      IMPLICIT NONE
3108
3109      INTEGER(iwp) ::  m          !< running index for surface elements
3110      INTEGER(iwp) ::  n_out      !< index for output variable
3111      INTEGER(iwp) ::  n_surf     !< running index for surface elements
3112     
3113      REAL(wp), DIMENSION(:), ALLOCATABLE, INTENT(IN) ::  var_def_h0 !< output variable at upward-facing default-type surfaces
3114      REAL(wp), DIMENSION(:), ALLOCATABLE, INTENT(IN) ::  var_def_h1 !< output variable at downward-facing default-type surfaces
3115      REAL(wp), DIMENSION(:), ALLOCATABLE, INTENT(IN) ::  var_lsm_h  !< output variable at upward-facing natural-type surfaces
3116      REAL(wp), DIMENSION(:), ALLOCATABLE, INTENT(IN) ::  var_usm_h  !< output variable at upward-facing urban-type surfaces
3117      REAL(wp), DIMENSION(:), ALLOCATABLE, INTENT(IN) ::  var_def_v0 !< output variable at northward-facing default-type surfaces
3118      REAL(wp), DIMENSION(:), ALLOCATABLE, INTENT(IN) ::  var_def_v1 !< output variable at southward-facing default-type surfaces
3119      REAL(wp), DIMENSION(:), ALLOCATABLE, INTENT(IN) ::  var_def_v2 !< output variable at eastward-facing default-type surfaces
3120      REAL(wp), DIMENSION(:), ALLOCATABLE, INTENT(IN) ::  var_def_v3 !< output variable at westward-facing default-type surfaces
3121      REAL(wp), DIMENSION(:), ALLOCATABLE, INTENT(IN) ::  var_lsm_v0 !< output variable at northward-facing natural-type surfaces
3122      REAL(wp), DIMENSION(:), ALLOCATABLE, INTENT(IN) ::  var_lsm_v1 !< output variable at southward-facing natural-type surfaces
3123      REAL(wp), DIMENSION(:), ALLOCATABLE, INTENT(IN) ::  var_lsm_v2 !< output variable at eastward-facing natural-type surfaces
3124      REAL(wp), DIMENSION(:), ALLOCATABLE, INTENT(IN) ::  var_lsm_v3 !< output variable at westward-facing natural-type surfaces
3125      REAL(wp), DIMENSION(:), ALLOCATABLE, INTENT(IN) ::  var_usm_v0 !< output variable at northward-facing urban-type surfaces
3126      REAL(wp), DIMENSION(:), ALLOCATABLE, INTENT(IN) ::  var_usm_v1 !< output variable at southward-facing urban-type surfaces
3127      REAL(wp), DIMENSION(:), ALLOCATABLE, INTENT(IN) ::  var_usm_v2 !< output variable at eastward-facing urban-type surfaces
3128      REAL(wp), DIMENSION(:), ALLOCATABLE, INTENT(IN) ::  var_usm_v3 !< output variable at westward-facing urban-type surfaces
3129     
3130!     
3131!--   Set counter variable to zero before the variable is written to
3132!--   the output array.
3133      n_surf = 0
3134     
3135!
3136!--   Write the horizontal surfaces.
3137!--   Before each the variable is written to the output data structure, first
3138!--   check if the variable for the respective surface type is defined.
3139!--   If a variable is not defined, skip the block and increment the counter
3140!--   variable by the number of surface elements of this type. Usually this
3141!--   is zere, however, there might be the situation that e.g. urban surfaces
3142!--   are defined but the respective variable is not allocated for this surface
3143!--   type. To write the data on the exact position, increment the counter.
3144      IF ( ALLOCATED( var_def_h0 ) )  THEN
3145         DO  m = 1, surf_def_h(0)%ns
3146            n_surf                        = n_surf + 1
3147            surfaces%var_av(n_surf,n_out) = surfaces%var_av(n_surf,n_out)      &
3148                                          + var_def_h0(m)
3149         ENDDO
3150      ELSE
3151         n_surf = n_surf + surf_def_h(0)%ns 
3152      ENDIF
3153      IF ( ALLOCATED( var_def_h1 ) )  THEN
3154         DO  m = 1, surf_def_h(1)%ns
3155            n_surf                   = n_surf + 1
3156            surfaces%var_av(n_surf,n_out) = surfaces%var_av(n_surf,n_out)      &
3157                                          + var_def_h1(m)
3158         ENDDO
3159      ELSE
3160         n_surf = n_surf + surf_def_h(1)%ns
3161      ENDIF
3162      IF ( ALLOCATED( var_lsm_h ) )  THEN
3163         DO  m = 1, surf_lsm_h%ns
3164            n_surf                        = n_surf + 1
3165            surfaces%var_av(n_surf,n_out) = surfaces%var_av(n_surf,n_out)      &
3166                                          + var_lsm_h(m)
3167         ENDDO
3168      ELSE
3169         n_surf = n_surf + surf_lsm_h%ns
3170      ENDIF
3171      IF ( ALLOCATED( var_usm_h ) )  THEN
3172         DO  m = 1, surf_usm_h%ns
3173            n_surf                        = n_surf + 1
3174            surfaces%var_av(n_surf,n_out) = surfaces%var_av(n_surf,n_out)      &
3175                                          + var_usm_h(m)
3176         ENDDO
3177      ELSE
3178         n_surf = n_surf + surf_usm_h%ns
3179      ENDIF
3180!
3181!--   Write northward-facing
3182      IF ( ALLOCATED( var_def_v0 ) )  THEN
3183         DO  m = 1, surf_def_v(0)%ns
3184            n_surf                        = n_surf + 1
3185            surfaces%var_av(n_surf,n_out) = surfaces%var_av(n_surf,n_out)      &
3186                                          + var_def_v0(m)
3187         ENDDO
3188      ELSE
3189         n_surf = n_surf + surf_def_v(0)%ns
3190      ENDIF
3191      IF ( ALLOCATED( var_lsm_v0 ) )  THEN
3192         DO  m = 1, surf_lsm_v(0)%ns
3193            n_surf                        = n_surf + 1
3194            surfaces%var_av(n_surf,n_out) = surfaces%var_av(n_surf,n_out)      &
3195                                          + var_lsm_v0(m)
3196         ENDDO
3197      ELSE
3198         n_surf = n_surf + surf_lsm_v(0)%ns
3199      ENDIF
3200      IF ( ALLOCATED( var_usm_v0 ) )  THEN
3201         DO  m = 1, surf_usm_v(0)%ns
3202            n_surf                        = n_surf + 1
3203            surfaces%var_av(n_surf,n_out) = surfaces%var_av(n_surf,n_out)      &
3204                                          + var_usm_v0(m)
3205         ENDDO
3206      ELSE
3207         n_surf = n_surf + surf_usm_v(0)%ns
3208      ENDIF
3209!
3210!--   Write southward-facing
3211      IF ( ALLOCATED( var_def_v1 ) )  THEN
3212         DO  m = 1, surf_def_v(1)%ns
3213            n_surf                        = n_surf + 1
3214            surfaces%var_av(n_surf,n_out) = surfaces%var_av(n_surf,n_out)      &
3215                                          + var_def_v1(m)
3216         ENDDO
3217      ELSE
3218         n_surf = n_surf + surf_def_v(1)%ns
3219      ENDIF
3220      IF ( ALLOCATED( var_lsm_v1 ) )  THEN
3221         DO  m = 1, surf_lsm_v(1)%ns
3222            n_surf                        = n_surf + 1
3223            surfaces%var_av(n_surf,n_out) = surfaces%var_av(n_surf,n_out)      &
3224                                          + var_lsm_v1(m)
3225         ENDDO
3226      ELSE
3227         n_surf = n_surf + surf_lsm_v(1)%ns
3228      ENDIF
3229      IF ( ALLOCATED( var_usm_v1 ) )  THEN
3230         DO  m = 1, surf_usm_v(1)%ns
3231            n_surf                        = n_surf + 1
3232            surfaces%var_av(n_surf,n_out) = surfaces%var_av(n_surf,n_out)      &
3233                                          + var_usm_v1(m)
3234         ENDDO
3235      ELSE
3236         n_surf = n_surf + surf_usm_v(1)%ns
3237      ENDIF
3238!
3239!--   Write eastward-facing
3240      IF ( ALLOCATED( var_def_v2 ) )  THEN
3241         DO  m = 1, surf_def_v(2)%ns
3242            n_surf                        = n_surf + 1
3243            surfaces%var_av(n_surf,n_out) = surfaces%var_av(n_surf,n_out)      &
3244                                          + var_def_v2(m)
3245         ENDDO
3246      ELSE
3247         n_surf = n_surf + surf_def_v(2)%ns
3248      ENDIF
3249      IF ( ALLOCATED( var_lsm_v2 ) )  THEN
3250         DO  m = 1, surf_lsm_v(2)%ns
3251            n_surf                        = n_surf + 1
3252            surfaces%var_av(n_surf,n_out) = surfaces%var_av(n_surf,n_out)      &
3253                                          + var_lsm_v2(m)
3254         ENDDO
3255      ELSE
3256         n_surf = n_surf + surf_lsm_v(2)%ns
3257      ENDIF
3258      IF ( ALLOCATED( var_usm_v2 ) )  THEN
3259         DO  m = 1, surf_usm_v(2)%ns
3260            n_surf                        = n_surf + 1
3261            surfaces%var_av(n_surf,n_out) = surfaces%var_av(n_surf,n_out)      &
3262                                          + var_usm_v2(m)
3263         ENDDO
3264      ELSE
3265         n_surf = n_surf + surf_usm_v(2)%ns
3266      ENDIF
3267!
3268!--   Write westward-facing
3269      IF ( ALLOCATED( var_def_v3 ) )  THEN
3270         DO  m = 1, surf_def_v(3)%ns
3271            n_surf                        = n_surf + 1
3272            surfaces%var_av(n_surf,n_out) = surfaces%var_av(n_surf,n_out)      &
3273                                          + var_def_v3(m)
3274         ENDDO
3275      ELSE
3276         n_surf = n_surf + surf_def_v(3)%ns
3277      ENDIF
3278      IF ( ALLOCATED( var_lsm_v3 ) )  THEN
3279         DO  m = 1, surf_lsm_v(3)%ns
3280            n_surf                        = n_surf + 1
3281            surfaces%var_av(n_surf,n_out) = surfaces%var_av(n_surf,n_out)      &
3282                                          + var_lsm_v3(m)
3283         ENDDO
3284      ELSE
3285         n_surf = n_surf + surf_lsm_v(3)%ns
3286      ENDIF
3287      IF ( ALLOCATED( var_usm_v3 ) )  THEN
3288         DO  m = 1, surf_usm_v(3)%ns
3289            n_surf                        = n_surf + 1
3290            surfaces%var_av(n_surf,n_out) = surfaces%var_av(n_surf,n_out)      &
3291                                          + var_usm_v3(m)
3292         ENDDO
3293      ELSE
3294         n_surf = n_surf + surf_usm_v(3)%ns
3295      ENDIF
3296   
3297   END SUBROUTINE surface_output_sum_up
3298   
3299!------------------------------------------------------------------------------!
3300! Description:
3301! ------------
3302!> Collect the surface data from different types and different orientation.
3303!------------------------------------------------------------------------------!
3304   SUBROUTINE surface_output_collect( var_def_h0, var_def_h1,                  &
3305                                      var_lsm_h,  var_usm_h,                   &
3306                                      var_def_v0, var_lsm_v0, var_usm_v0,      &
3307                                      var_def_v1, var_lsm_v1, var_usm_v1,      &
3308                                      var_def_v2, var_lsm_v2, var_usm_v2,      &
3309                                      var_def_v3, var_lsm_v3, var_usm_v3 )                                               
3310   
3311      IMPLICIT NONE
3312
3313      INTEGER(iwp) ::  m      !< running index for surface elements
3314      INTEGER(iwp) ::  n_surf !< running index for surface elements
3315     
3316      REAL(wp), DIMENSION(:), ALLOCATABLE, INTENT(IN) ::  var_def_h0 !< output variable at upward-facing default-type surfaces
3317      REAL(wp), DIMENSION(:), ALLOCATABLE, INTENT(IN) ::  var_def_h1 !< output variable at downward-facing default-type surfaces
3318      REAL(wp), DIMENSION(:), ALLOCATABLE, INTENT(IN) ::  var_lsm_h  !< output variable at upward-facing natural-type surfaces
3319      REAL(wp), DIMENSION(:), ALLOCATABLE, INTENT(IN) ::  var_usm_h  !< output variable at upward-facing urban-type surfaces
3320      REAL(wp), DIMENSION(:), ALLOCATABLE, INTENT(IN) ::  var_def_v0 !< output variable at northward-facing default-type surfaces
3321      REAL(wp), DIMENSION(:), ALLOCATABLE, INTENT(IN) ::  var_def_v1 !< output variable at southward-facing default-type surfaces
3322      REAL(wp), DIMENSION(:), ALLOCATABLE, INTENT(IN) ::  var_def_v2 !< output variable at eastward-facing default-type surfaces
3323      REAL(wp), DIMENSION(:), ALLOCATABLE, INTENT(IN) ::  var_def_v3 !< output variable at westward-facing default-type surfaces
3324      REAL(wp), DIMENSION(:), ALLOCATABLE, INTENT(IN) ::  var_lsm_v0 !< output variable at northward-facing natural-type surfaces
3325      REAL(wp), DIMENSION(:), ALLOCATABLE, INTENT(IN) ::  var_lsm_v1 !< output variable at southward-facing natural-type surfaces
3326      REAL(wp), DIMENSION(:), ALLOCATABLE, INTENT(IN) ::  var_lsm_v2 !< output variable at eastward-facing natural-type surfaces
3327      REAL(wp), DIMENSION(:), ALLOCATABLE, INTENT(IN) ::  var_lsm_v3 !< output variable at westward-facing natural-type surfaces
3328      REAL(wp), DIMENSION(:), ALLOCATABLE, INTENT(IN) ::  var_usm_v0 !< output variable at northward-facing urban-type surfaces
3329      REAL(wp), DIMENSION(:), ALLOCATABLE, INTENT(IN) ::  var_usm_v1 !< output variable at southward-facing urban-type surfaces
3330      REAL(wp), DIMENSION(:), ALLOCATABLE, INTENT(IN) ::  var_usm_v2 !< output variable at eastward-facing urban-type surfaces
3331      REAL(wp), DIMENSION(:), ALLOCATABLE, INTENT(IN) ::  var_usm_v3 !< output variable at westward-facing urban-type surfaces
3332     
3333!     
3334!--   Set counter variable to zero before the variable is written to
3335!--   the output array.
3336      n_surf = 0
3337     
3338!
3339!--   Write the horizontal surfaces.
3340!--   Before each the variable is written to the output data structure, first
3341!--   check if the variable for the respective surface type is defined.
3342!--   If a variable is not defined, skip the block and increment the counter
3343!--   variable by the number of surface elements of this type. Usually this
3344!--   is zere, however, there might be the situation that e.g. urban surfaces
3345!--   are defined but the respective variable is not allocated for this surface
3346!--   type. To write the data on the exact position, increment the counter.
3347      IF ( ALLOCATED( var_def_h0 ) )  THEN
3348         DO  m = 1, surf_def_h(0)%ns
3349            n_surf                   = n_surf + 1
3350            surfaces%var_out(n_surf) = var_def_h0(m)
3351         ENDDO
3352      ELSE
3353         n_surf = n_surf + surf_def_h(0)%ns 
3354      ENDIF
3355      IF ( ALLOCATED( var_def_h1 ) )  THEN
3356         DO  m = 1, surf_def_h(1)%ns
3357            n_surf                   = n_surf + 1
3358            surfaces%var_out(n_surf) = var_def_h1(m)
3359         ENDDO
3360      ELSE
3361         n_surf = n_surf + surf_def_h(1)%ns
3362      ENDIF
3363      IF ( ALLOCATED( var_lsm_h ) )  THEN
3364         DO  m = 1, surf_lsm_h%ns
3365            n_surf                   = n_surf + 1
3366            surfaces%var_out(n_surf) = var_lsm_h(m)
3367         ENDDO
3368      ELSE
3369         n_surf = n_surf + surf_lsm_h%ns
3370      ENDIF
3371      IF ( ALLOCATED( var_usm_h ) )  THEN
3372         DO  m = 1, surf_usm_h%ns
3373            n_surf                   = n_surf + 1
3374            surfaces%var_out(n_surf) = var_usm_h(m)
3375         ENDDO
3376      ELSE
3377         n_surf = n_surf + surf_usm_h%ns
3378      ENDIF
3379!
3380!--   Write northward-facing
3381      IF ( ALLOCATED( var_def_v0 ) )  THEN
3382         DO  m = 1, surf_def_v(0)%ns
3383            n_surf                   = n_surf + 1
3384            surfaces%var_out(n_surf) = var_def_v0(m)
3385         ENDDO
3386      ELSE
3387         n_surf = n_surf + surf_def_v(0)%ns
3388      ENDIF
3389      IF ( ALLOCATED( var_lsm_v0 ) )  THEN
3390         DO  m = 1, surf_lsm_v(0)%ns
3391            n_surf                   = n_surf + 1
3392            surfaces%var_out(n_surf) = var_lsm_v0(m)
3393         ENDDO
3394      ELSE
3395         n_surf = n_surf + surf_lsm_v(0)%ns
3396      ENDIF
3397      IF ( ALLOCATED( var_usm_v0 ) )  THEN
3398         DO  m = 1, surf_usm_v(0)%ns
3399            n_surf                   = n_surf + 1
3400            surfaces%var_out(n_surf) = var_usm_v0(m)
3401         ENDDO
3402      ELSE
3403         n_surf = n_surf + surf_usm_v(0)%ns
3404      ENDIF
3405!
3406!--   Write southward-facing
3407      IF ( ALLOCATED( var_def_v1 ) )  THEN
3408         DO  m = 1, surf_def_v(1)%ns
3409            n_surf                   = n_surf + 1
3410            surfaces%var_out(n_surf) = var_def_v1(m)
3411         ENDDO
3412      ELSE
3413         n_surf = n_surf + surf_def_v(1)%ns
3414      ENDIF
3415      IF ( ALLOCATED( var_lsm_v1 ) )  THEN
3416         DO  m = 1, surf_lsm_v(1)%ns
3417            n_surf                   = n_surf + 1
3418            surfaces%var_out(n_surf) = var_lsm_v1(m)
3419         ENDDO
3420      ELSE
3421         n_surf = n_surf + surf_lsm_v(1)%ns
3422      ENDIF
3423      IF ( ALLOCATED( var_usm_v1 ) )  THEN
3424         DO  m = 1, surf_usm_v(1)%ns
3425            n_surf                   = n_surf + 1
3426            surfaces%var_out(n_surf) = var_usm_v1(m)
3427         ENDDO
3428      ELSE
3429         n_surf = n_surf + surf_usm_v(1)%ns
3430      ENDIF
3431!
3432!--   Write eastward-facing
3433      IF ( ALLOCATED( var_def_v2 ) )  THEN
3434         DO  m = 1, surf_def_v(2)%ns
3435            n_surf                   = n_surf + 1
3436            surfaces%var_out(n_surf) = var_def_v2(m)
3437         ENDDO
3438      ELSE
3439         n_surf = n_surf + surf_def_v(2)%ns
3440      ENDIF
3441      IF ( ALLOCATED( var_lsm_v2 ) )  THEN
3442         DO  m = 1, surf_lsm_v(2)%ns
3443            n_surf                   = n_surf + 1
3444            surfaces%var_out(n_surf) = var_lsm_v2(m)
3445         ENDDO
3446      ELSE
3447         n_surf = n_surf + surf_lsm_v(2)%ns
3448      ENDIF
3449      IF ( ALLOCATED( var_usm_v2 ) )  THEN
3450         DO  m = 1, surf_usm_v(2)%ns
3451            n_surf                   = n_surf + 1
3452            surfaces%var_out(n_surf) = var_usm_v2(m)
3453         ENDDO
3454      ELSE
3455         n_surf = n_surf + surf_usm_v(2)%ns
3456      ENDIF
3457!
3458!--   Write westward-facing
3459      IF ( ALLOCATED( var_def_v3 ) )  THEN
3460         DO  m = 1, surf_def_v(3)%ns
3461            n_surf                   = n_surf + 1
3462            surfaces%var_out(n_surf) = var_def_v3(m)
3463         ENDDO
3464      ELSE
3465         n_surf = n_surf + surf_def_v(3)%ns
3466      ENDIF
3467      IF ( ALLOCATED( var_lsm_v3 ) )  THEN
3468         DO  m = 1, surf_lsm_v(3)%ns
3469            n_surf                   = n_surf + 1
3470            surfaces%var_out(n_surf) = var_lsm_v3(m)
3471         ENDDO
3472      ELSE
3473         n_surf = n_surf + surf_lsm_v(3)%ns
3474      ENDIF
3475      IF ( ALLOCATED( var_usm_v3 ) )  THEN
3476         DO  m = 1, surf_usm_v(3)%ns
3477            n_surf                   = n_surf + 1
3478            surfaces%var_out(n_surf) = var_usm_v3(m)
3479         ENDDO
3480      ELSE
3481         n_surf = n_surf + surf_usm_v(3)%ns
3482      ENDIF
3483   
3484   END SUBROUTINE surface_output_collect
3485   
3486   
3487   
3488!    SUBROUTINE data_output_surf_driver (time)
3489!       IMPLICIT NONE
3490!
3491!       REAL(kind=wp),INTENT(IN)    :: time
3492!       CHARACTER(LEN=64)           :: filename
3493!       INTEGER,SAVE                :: file_number=1
3494!
3495!       if(output_mode == "legacy_VTK")   then
3496!           CALL prepare_vtk_data
3497!
3498!           write(filename,'(a,i5.5,a)') 'surface_output_',file_number,'.vtk'
3499!           if(myid == surf_io_pe)   write(9,*) 'Legacy VTK surface output to file: ',trim(filename)
3500!           file_number = file_number+1
3501!
3502!           CALL write_ascii_vtk (filename, time)
3503!       END IF
3504!
3505!       RETURN
3506!    END SUBROUTINE data_output_surf_driver
3507   
3508   
3509!------------------------------------------------------------------------------!
3510! Description:
3511! ------------
3512!> Parin for output of surface parameters
3513!------------------------------------------------------------------------------!
3514    SUBROUTINE surface_output_parin
3515
3516       IMPLICIT NONE
3517
3518       CHARACTER (LEN=80) ::  line  !< dummy string that contains the current line of the parameter file
3519       
3520
3521       NAMELIST /surface_output_parameters/                                    &
3522                                  averaging_interval_surf, data_output_surf,   &
3523                                  dt_dosurf, dt_dosurf_av,                     &
3524                                  skip_time_dosurf, skip_time_dosurf_av
3525                                 
3526       line = ' '
3527 
3528!
3529!--    Try to find the namelist
3530       REWIND ( 11 )
3531       line = ' '
3532       DO WHILE ( INDEX( line, '&surface_output_parameters' ) == 0 )
3533          READ ( 11, '(A)', END=14 )  line
3534       ENDDO
3535       BACKSPACE ( 11 )
3536
3537!
3538!--    Read namelist
3539       READ ( 11, surface_output_parameters, ERR = 10 )
3540!
3541!--    Set flag that indicates that surface data output is switched on
3542       surface_data_output = .TRUE.
3543       GOTO 14
3544
3545 10    BACKSPACE( 11 )
3546       READ( 11 , '(A)') line
3547       CALL parin_fail_message( 'surface_output_parameters', line )     
3548       
3549 14    CONTINUE
3550       
3551
3552    END SUBROUTINE surface_output_parin
3553   
3554   
3555!------------------------------------------------------------------------------!
3556! Description:
3557! ------------
3558!> Check the input parameters for consistency. Further pre-process the given
3559!> output variables, i.e. separate them into average and non-average output
3560!> variables and map them onto internal output array.
3561!------------------------------------------------------------------------------!
3562    SUBROUTINE surface_output_check_parameters
3563
3564       USE control_parameters,                                                 &
3565           ONLY:  averaging_interval, dt_data_output, message_string
3566
3567       IMPLICIT NONE
3568
3569       CHARACTER(LEN=100) ::  trimvar !< dummy for single output variable
3570
3571       INTEGER(iwp) ::  av    !< id indicating average or non-average data output
3572       INTEGER(iwp) ::  ilen  !< string length
3573       INTEGER(iwp) ::  n_out !< running index for number of output variables
3574
3575!
3576!--    Check the average interval
3577       IF ( averaging_interval_surf == 9999999.9_wp )  THEN
3578          averaging_interval_surf = averaging_interval
3579       ENDIF
3580!
3581!--    Set the default data-output interval dt_data_output if necessary
3582       IF ( dt_dosurf    == 9999999.9_wp )  dt_dosurf    = dt_data_output
3583       IF ( dt_dosurf_av == 9999999.9_wp )  dt_dosurf_av = dt_data_output
3584
3585       IF ( averaging_interval_surf > dt_dosurf_av )  THEN
3586          WRITE( message_string, * )  'averaging_interval_surf = ',            &
3587                averaging_interval_surf, ' must be <= dt_dosurf_av = ',        &
3588                dt_dosurf_av
3589          CALL message( 'surface_output_check_parameters',                     &
3590                        'PA0087', 1, 2, 0, 6, 0 )
3591       ENDIF
3592
3593!
3594!--   Count number of output variables and separate output strings for
3595!--   average and non-average output variables.
3596      n_out = 0
3597      DO WHILE ( data_output_surf(n_out+1)(1:1) /= ' ' )
3598
3599         n_out = n_out + 1
3600         ilen = LEN_TRIM( data_output_surf(n_out) )
3601         trimvar = TRIM( data_output_surf(n_out) )
3602
3603!
3604!--      Check for data averaging
3605         av = 0
3606         IF ( ilen > 3 )  THEN
3607            IF ( data_output_surf(n_out)(ilen-2:ilen) == '_av' )  THEN
3608               trimvar = data_output_surf(n_out)(1:ilen-3)
3609               av      = 1
3610            ENDIF
3611         ENDIF
3612
3613         dosurf_no(av) = dosurf_no(av) + 1
3614         dosurf(av,dosurf_no(av)) = TRIM( trimvar )
3615
3616!
3617!--      Check if all output variables are known
3618         SELECT CASE ( TRIM( trimvar ) )
3619
3620            CASE ( 'css', 'cssws', 'qsws_liq', 'qsws_soil', 'qsws_veg' )
3621               message_string = TRIM( trimvar ) //                             &
3622                             ' is not yet implemented in the surface output'
3623               CALL message( 'surface_output_check_parameters',                &
3624                             'PA0087', 1, 2, 0, 6, 0 )
3625
3626            CASE ( 'us', 'ts', 'qs', 'ss', 'qcs', 'ncs', 'qrs', 'nrs', 'ol' )
3627
3628            CASE ( 'z0', 'z0h', 'z0q' )
3629
3630            CASE ( 'theta1', 'qv1', 'thetav1' )
3631
3632            CASE ( 'usws', 'vsws' )
3633
3634            CASE ( 'qcsws', 'ncsws', 'qrsws', 'nrsws', 'sasws' )
3635
3636            CASE ( 'shf', 'qsws', 'ssws' )
3637
3638            CASE ( 'q_surface', 'theta_surface', 'thetav_surface' )
3639
3640            CASE ( 'rad_net' )
3641
3642            CASE ( 'rad_lw_in', 'rad_lw_out', 'rad_lw_dif', 'rad_lw_ref',     &
3643                   'rad_lw_res' )
3644
3645            CASE ( 'rad_sw_in', 'rad_sw_out', 'rad_sw_dif', 'rad_sw_ref',     &
3646                   'rad_sw_res', 'rad_sw_dir' )
3647
3648            CASE ( 'ghf' )
3649
3650            CASE ( 'r_a', 'r_canopy', 'r_soil', 'r_s' )
3651
3652            CASE DEFAULT
3653               message_string = TRIM( trimvar ) //                             &
3654                             ' is not part of the surface output'
3655               CALL message( 'surface_output_check_parameters',                &
3656                             'PA0087', 1, 2, 0, 6, 0 )
3657         END SELECT
3658
3659       ENDDO
3660
3661    END SUBROUTINE surface_output_check_parameters
3662   
3663   
3664!------------------------------------------------------------------------------!
3665! Description:
3666! ------------
3667!> Last action.
3668!------------------------------------------------------------------------------!
3669    SUBROUTINE surface_output_last_action( av )
3670 
3671      USE control_parameters,                                                  &
3672          ONLY:  io_blocks, io_group
3673
3674      USE pegrid,                                                              &
3675          ONLY:  comm2d, ierr
3676
3677      IMPLICIT NONE
3678     
3679      INTEGER(iwp) ::  av     !< id indicating average or non-average data output
3680      INTEGER(iwp) ::  i      !< loop index
3681
3682!
3683!--   Return, if nothing to output
3684      IF ( dosurf_no(av) == 0 )  RETURN
3685!
3686!--   Open files
3687      CALL check_open( 25+av )
3688!
3689!--   Write time coordinate
3690      DO  i = 0, io_blocks-1
3691         IF ( i == io_group )  THEN
3692            WRITE ( 25+av )  LEN_TRIM( 'END' )
3693            WRITE ( 25+av )  'END'
3694         ENDIF
3695#if defined( __parallel )
3696         CALL MPI_BARRIER( comm2d, ierr )
3697#endif
3698      ENDDO   
3699
3700    END SUBROUTINE surface_output_last_action   
3701
3702!--Private Subroutines (Only called from tinside his module)
3703
3704
3705
3706!    SUBROUTINE write_ascii_vtk (filename,time)
3707!       IMPLICIT NONE
3708!       CHARACTER(LEN=*),INTENT(IN)   :: filename
3709!       REAL(kind=wp),INTENT(IN)      :: time
3710!
3711!       INTEGER                       :: file_id=251
3712!       INTEGER                       :: n
3713!
3714!       IF(myid == surf_io_pe)  then
3715!          open(file_id,file=TRIM(filename))                                 ! Please use check_open in the final version
3716!
3717!          write(file_id,'(a)') "# vtk DataFile Version 3.0"
3718!          write(file_id,'(a,f8.2,a)') "legacy vtk File generated by PALM,  simulation time = ",time," sec"
3719!          write(file_id,'(a)') "ASCII"
3720!
3721!          write(file_id,'(a)') "DATASET POLYDATA"
3722!          write(file_id,'(a,i5,a)') "POINTS ",npo," float"
3723!          do n=1,npo
3724!             write (file_id,'(8f10.1)') points(1:3,n)
3725!          end do
3726!
3727!          write(file_id,'(a,8i10)') "POLYGONS ",npg, 5*npg
3728!          do n=1,npg
3729!             write(file_id,'(8i10)') polygons(:,n)
3730!          end do
3731!
3732!          write(file_id,'(a,i10)') "CELL_DATA ",npg
3733!          write(file_id,'(a,i10)') "SCALARS cell_scalars float 1 "
3734!          write(file_id,'(a,i10)') "LOOKUP_TABLE default "
3735!
3736!          do n=1,npg
3737!             write(file_id,'(f10.2)') cell_scalars(n)
3738!          end do
3739!
3740!          close (file_id)
3741!
3742!          DEALLOCATE (points,polygons,cell_scalars)
3743!       ENDIF
3744!
3745!       RETURN
3746!    END SUBROUTINE write_ascii_vtk
3747
3748END MODULE surface_output_mod
Note: See TracBrowser for help on using the repository browser.