Index: /palm/trunk/SOURCE/close_file.f90
===================================================================
--- /palm/trunk/SOURCE/close_file.f90	(revision 2276)
+++ /palm/trunk/SOURCE/close_file.f90	(revision 2277)
@@ -25,4 +25,7 @@
 ! -----------------
 ! $Id$
+! Removed unused variables do2d_xy_n, do2d_xz_n, do2d_yz_n, do3d_avs_n
+! 
+! 2101 2017-01-05 16:42:31Z suehring
 !
 ! 2000 2016-08-20 18:09:15Z knoop
@@ -76,5 +79,5 @@
 
     USE control_parameters,                                                    &
-        ONLY:  do2d_xz_n, do2d_xy_n, do2d_yz_n, do3d_avs_n, host, max_masks,   &
+        ONLY:  host, max_masks,                                                &
                mid, nz_do3d, openfile, run_description_header, z_max_do2d
                 
Index: /palm/trunk/SOURCE/data_output_2d.f90
===================================================================
--- /palm/trunk/SOURCE/data_output_2d.f90	(revision 2276)
+++ /palm/trunk/SOURCE/data_output_2d.f90	(revision 2277)
@@ -25,4 +25,7 @@
 ! -----------------
 ! $Id$
+! Removed unused variables do2d_xy_n, do2d_xz_n, do2d_yz_n
+! 
+! 2233 2017-05-30 18:08:54Z suehring
 !
 ! 2232 2017-05-30 17:47:52Z suehring
@@ -178,7 +181,7 @@
         ONLY:  cloud_physics, data_output_2d_on_each_pe, data_output_xy,       &
                data_output_xz, data_output_yz, do2d,                           &
-               do2d_xy_last_time, do2d_xy_n, do2d_xy_time_count,               &
-               do2d_xz_last_time, do2d_xz_n, do2d_xz_time_count,               &
-               do2d_yz_last_time, do2d_yz_n, do2d_yz_time_count,               &
+               do2d_xy_last_time, do2d_xy_time_count,                          &
+               do2d_xz_last_time, do2d_xz_time_count,                          &
+               do2d_yz_last_time, do2d_yz_time_count,                          &
                ibc_uv_b, io_blocks, io_group, land_surface, message_string,    &
                ntdim_2d_xy, ntdim_2d_xz, ntdim_2d_yz,                          &
@@ -1402,5 +1405,5 @@
 #endif
 #endif
-                   do2d_xy_n = do2d_xy_n + 1
+
 !
 !--                For 2D-arrays (e.g. u*) only one cross-section is available.
@@ -1628,5 +1631,4 @@
 #endif
 #endif
-                   do2d_xz_n = do2d_xz_n + 1
 
                 CASE ( 'yz' )
@@ -1847,5 +1849,4 @@
 #endif
 #endif
-                   do2d_yz_n = do2d_yz_n + 1
 
              END SELECT
Index: /palm/trunk/SOURCE/init_3d_model.f90
===================================================================
--- /palm/trunk/SOURCE/init_3d_model.f90	(revision 2276)
+++ /palm/trunk/SOURCE/init_3d_model.f90	(revision 2277)
@@ -25,4 +25,7 @@
 ! -----------------
 ! $Id$
+! Removed unused variable sums_up_fraction_l
+! 
+! 2270 2017-06-09 12:18:47Z maronga
 ! dots_num must be increased when LSM and/or radiation is used
 ! 
@@ -394,5 +397,5 @@
         ONLY:  hom, hom_sum, mean_surface_level_height, pr_palm, rmask,        &
                statistic_regions, sums, sums_divnew_l, sums_divold_l, sums_l,  &
-               sums_l_l, sums_up_fraction_l, sums_wsts_bc_l, ts_value,         &
+               sums_l_l, sums_wsts_bc_l, ts_value,                             &
                weight_pres, weight_substep
 
@@ -468,5 +471,4 @@
               sums_l(nzb:nzt+1,pr_palm+max_pr_user,0:threads_per_task-1),      &
               sums_l_l(nzb:nzt+1,0:statistic_regions,0:threads_per_task-1),    &
-              sums_up_fraction_l(10,3,0:statistic_regions),                    &
               sums_wsts_bc_l(nzb:nzt+1,0:statistic_regions),                   &
               ts_value(dots_max,0:statistic_regions) )
@@ -942,5 +944,4 @@
     sums_divold_l      = 0.0_wp
     sums_l_l           = 0.0_wp
-    sums_up_fraction_l = 0.0_wp
     sums_wsts_bc_l     = 0.0_wp
 
Index: /palm/trunk/SOURCE/modules.f90
===================================================================
--- /palm/trunk/SOURCE/modules.f90	(revision 2276)
+++ /palm/trunk/SOURCE/modules.f90	(revision 2277)
@@ -25,4 +25,10 @@
 ! -----------------
 ! $Id$
+! Added doxygen comments for variables/parameters,
+! removed unused variables dissipation_control, do2d_xy_n, do2d_xz_n, do2d_yz_n, 
+! do3d_avs_n, lptnudge, lqnudge, lunudge, lvnudge, lwnudge, skip_do_avs, 
+! sums_up_fraction_l.
+! 
+! 2259 2017-06-08 09:09:11Z gronemeier
 ! Implemented synthetic turbulence generator
 !
@@ -458,5 +464,5 @@
 !> Definition of all variables
 !>
-!> @todo Add description for each variable
+!> @todo Add missing variable descriptions (Siggi)
 !------------------------------------------------------------------------------!
 
@@ -471,8 +477,8 @@
     USE kinds
 
-    REAL(wp), DIMENSION(:), ALLOCATABLE ::  aex  !< 
-    REAL(wp), DIMENSION(:), ALLOCATABLE ::  bex  !< 
-    REAL(wp), DIMENSION(:), ALLOCATABLE ::  dex  !< 
-    REAL(wp), DIMENSION(:), ALLOCATABLE ::  eex  !< 
+    REAL(wp), DIMENSION(:), ALLOCATABLE ::  aex  !< Siggi 
+    REAL(wp), DIMENSION(:), ALLOCATABLE ::  bex  !< Siggi 
+    REAL(wp), DIMENSION(:), ALLOCATABLE ::  dex  !< Siggi 
+    REAL(wp), DIMENSION(:), ALLOCATABLE ::  eex  !< Siggi 
     
     SAVE
@@ -490,261 +496,264 @@
     USE kinds
 
-    REAL(wp), DIMENSION(:), ALLOCATABLE ::  c_u_m                  !< 
-    REAL(wp), DIMENSION(:), ALLOCATABLE ::  c_u_m_l                !< 
-    REAL(wp), DIMENSION(:), ALLOCATABLE ::  c_v_m                  !< 
-    REAL(wp), DIMENSION(:), ALLOCATABLE ::  c_v_m_l                !< 
-    REAL(wp), DIMENSION(:), ALLOCATABLE ::  c_w_m                  !< 
-    REAL(wp), DIMENSION(:), ALLOCATABLE ::  c_w_m_l                !<    
-    REAL(wp), DIMENSION(:), ALLOCATABLE ::  ddzu                   !< 
-    REAL(wp), DIMENSION(:), ALLOCATABLE ::  ddzu_pres              !< 
-    REAL(wp), DIMENSION(:), ALLOCATABLE ::  dd2zu                  !< 
-    REAL(wp), DIMENSION(:), ALLOCATABLE ::  dzu                    !< 
-    REAL(wp), DIMENSION(:), ALLOCATABLE ::  ddzw                   !< 
-    REAL(wp), DIMENSION(:), ALLOCATABLE ::  dzw                    !< 
-    REAL(wp), DIMENSION(:), ALLOCATABLE ::  hyp                    !< 
-    REAL(wp), DIMENSION(:), ALLOCATABLE ::  inflow_damping_factor  !< 
-    REAL(wp), DIMENSION(:), ALLOCATABLE ::  l_grid                 !< 
-    REAL(wp), DIMENSION(:), ALLOCATABLE ::  ptdf_x                 !< 
-    REAL(wp), DIMENSION(:), ALLOCATABLE ::  ptdf_y                 !< 
-    REAL(wp), DIMENSION(:), ALLOCATABLE ::  p_surf                 !< 
-    REAL(wp), DIMENSION(:), ALLOCATABLE ::  pt_surf                !< 
-    REAL(wp), DIMENSION(:), ALLOCATABLE ::  pt_init                !< 
-    REAL(wp), DIMENSION(:), ALLOCATABLE ::  qsws_surf              !< 
-    REAL(wp), DIMENSION(:), ALLOCATABLE ::  q_init                 !< 
-    REAL(wp), DIMENSION(:), ALLOCATABLE ::  q_surf                 !< 
-    REAL(wp), DIMENSION(:), ALLOCATABLE ::  rdf                    !< 
-    REAL(wp), DIMENSION(:), ALLOCATABLE ::  rdf_sc                 !< 
-    REAL(wp), DIMENSION(:), ALLOCATABLE ::  ref_state              !< 
-    REAL(wp), DIMENSION(:), ALLOCATABLE ::  s_init                 !< 
-    REAL(wp), DIMENSION(:), ALLOCATABLE ::  s_surf                 !< 
-    REAL(wp), DIMENSION(:), ALLOCATABLE ::  sa_init                !< 
-    REAL(wp), DIMENSION(:), ALLOCATABLE ::  shf_surf               !< 
-    REAL(wp), DIMENSION(:), ALLOCATABLE ::  timenudge              !< 
-    REAL(wp), DIMENSION(:), ALLOCATABLE ::  time_surf              !< 
-    REAL(wp), DIMENSION(:), ALLOCATABLE ::  time_vert              !< 
-    REAL(wp), DIMENSION(:), ALLOCATABLE ::  tmp_tnudge             !<
-    REAL(wp), DIMENSION(:), ALLOCATABLE ::  ug                     !< 
-    REAL(wp), DIMENSION(:), ALLOCATABLE ::  u_init                 !< 
-    REAL(wp), DIMENSION(:), ALLOCATABLE ::  u_nzb_p1_for_vfc       !< 
-    REAL(wp), DIMENSION(:), ALLOCATABLE ::  vg                     !< 
-    REAL(wp), DIMENSION(:), ALLOCATABLE ::  v_init                 !< 
-    REAL(wp), DIMENSION(:), ALLOCATABLE ::  v_nzb_p1_for_vfc       !< 
-    REAL(wp), DIMENSION(:), ALLOCATABLE ::  w_subs                 !< 
-    REAL(wp), DIMENSION(:), ALLOCATABLE ::  zu                     !< 
-    REAL(wp), DIMENSION(:), ALLOCATABLE ::  zw                     !< 
-
-    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  c_u                   !<
-    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  c_v                   !<
-    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  c_w                   !<
-    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  diss_s_e              !<
-    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  diss_s_nr             !<     
-    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  diss_s_pt             !< 
-    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  diss_s_q              !<
-    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  diss_s_qr             !< 
-    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  diss_s_s              !<
-    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  diss_s_sa             !< 
-    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  diss_s_u              !<
-    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  diss_s_v              !<
-    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  diss_s_w              !< 
-    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  dzu_mg                !<
-    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  dzw_mg                !<
-    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  flux_s_e              !<
-    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  flux_s_nr             !< 
-    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  flux_s_pt             !<
-    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  flux_s_q              !<
-    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  flux_s_qr             !<
-    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  flux_s_s              !<
-    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  flux_s_sa             !<
-    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  flux_s_u              !< 
-    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  flux_s_v              !<
-    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  flux_s_w              !<
-    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  f1_mg                 !< 
-    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  f2_mg                 !< 
-    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  f3_mg                 !< 
-    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  mean_inflow_profiles  !< 
-    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  precipitation_amount  !< 
-    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  precipitation_rate    !< 
-    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  ptnudge               !< 
-    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  pt_slope_ref          !< 
-    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  qnudge                !< 
-    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  tnudge                !< 
-    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  td_lsa_lpt            !< 
-    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  td_lsa_q              !< 
-    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  td_sub_lpt            !< 
-    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  td_sub_q              !< 
-    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  total_2d_a            !< 
-    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  total_2d_o            !< 
-    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  ug_vert               !< 
-    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  unudge                !< 
-    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  vnudge                !< 
-    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  vg_vert               !< 
-    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  wnudge                !< 
-    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  wsubs_vert            !< 
+    REAL(wp), DIMENSION(:), ALLOCATABLE ::  c_u_m                  !< Siggi 
+    REAL(wp), DIMENSION(:), ALLOCATABLE ::  c_u_m_l                !< Siggi 
+    REAL(wp), DIMENSION(:), ALLOCATABLE ::  c_v_m                  !< Siggi 
+    REAL(wp), DIMENSION(:), ALLOCATABLE ::  c_v_m_l                !< Siggi 
+    REAL(wp), DIMENSION(:), ALLOCATABLE ::  c_w_m                  !< Siggi 
+    REAL(wp), DIMENSION(:), ALLOCATABLE ::  c_w_m_l                !< Siggi    
+    REAL(wp), DIMENSION(:), ALLOCATABLE ::  ddzu                   !< 1/dzu 
+    REAL(wp), DIMENSION(:), ALLOCATABLE ::  ddzu_pres              !< modified ddzu for pressure solver 
+    REAL(wp), DIMENSION(:), ALLOCATABLE ::  dd2zu                  !< 1/(dzu(k)+dzu(k+1)) 
+    REAL(wp), DIMENSION(:), ALLOCATABLE ::  dzu                    !< vertical grid size (u-grid) 
+    REAL(wp), DIMENSION(:), ALLOCATABLE ::  ddzw                   !< 1/dzw 
+    REAL(wp), DIMENSION(:), ALLOCATABLE ::  dzw                    !< vertical grid size (w-grid) 
+    REAL(wp), DIMENSION(:), ALLOCATABLE ::  hyp                    !< hydrostatic pressure 
+    REAL(wp), DIMENSION(:), ALLOCATABLE ::  inflow_damping_factor  !< used for turbulent inflow (non-cyclic boundary conditions) 
+    REAL(wp), DIMENSION(:), ALLOCATABLE ::  l_grid                 !< geometric mean of grid sizes dx, dy, dz 
+    REAL(wp), DIMENSION(:), ALLOCATABLE ::  ptdf_x                 !< damping factor for potential temperature in x-direction 
+    REAL(wp), DIMENSION(:), ALLOCATABLE ::  ptdf_y                 !< damping factor for potential temperature in y-direction 
+    REAL(wp), DIMENSION(:), ALLOCATABLE ::  p_surf                 !< time-dependent surface pressure (large scale forcing)
+    REAL(wp), DIMENSION(:), ALLOCATABLE ::  pt_surf                !< time-dependent surface temperature (large scale forcing)
+    REAL(wp), DIMENSION(:), ALLOCATABLE ::  pt_init                !< initial profile of potential temperature 
+    REAL(wp), DIMENSION(:), ALLOCATABLE ::  qsws_surf              !< time-dependent surface latent heat flux (large scale forcing)
+    REAL(wp), DIMENSION(:), ALLOCATABLE ::  q_init                 !< initial profile of specific humidity 
+                                                                   !< (or total water content with active cloud physics) 
+    REAL(wp), DIMENSION(:), ALLOCATABLE ::  q_surf                 !< time-dependent surface specific humidity (large scale forcing)
+    REAL(wp), DIMENSION(:), ALLOCATABLE ::  rdf                    !< rayleigh damping factor for velocity components 
+    REAL(wp), DIMENSION(:), ALLOCATABLE ::  rdf_sc                 !< rayleigh damping factor for scalar quantities 
+    REAL(wp), DIMENSION(:), ALLOCATABLE ::  ref_state              !< reference state of potential temperature 
+                                                                   !< (and density in case of ocean simulation)
+    REAL(wp), DIMENSION(:), ALLOCATABLE ::  s_init                 !< initial profile of passive scalar concentration
+    REAL(wp), DIMENSION(:), ALLOCATABLE ::  sa_init                !< initial profile of salinity (ocean)
+    REAL(wp), DIMENSION(:), ALLOCATABLE ::  shf_surf               !< time-dependent surface sensible heat flux (large scale forcing)
+    REAL(wp), DIMENSION(:), ALLOCATABLE ::  timenudge              !< times at which vertical profiles are defined in NUDGING_DATA (nudging)
+    REAL(wp), DIMENSION(:), ALLOCATABLE ::  time_surf              !< times at which surface values/fluxes are defined in LSF_DATA (large scale forcing)
+    REAL(wp), DIMENSION(:), ALLOCATABLE ::  time_vert              !< times at which vertical profiles are defined in LSF_DATA (large scale forcing)
+    REAL(wp), DIMENSION(:), ALLOCATABLE ::  tmp_tnudge             !< current nudging time scale
+    REAL(wp), DIMENSION(:), ALLOCATABLE ::  ug                     !< geostrophic wind component in x-direction
+    REAL(wp), DIMENSION(:), ALLOCATABLE ::  u_init                 !< initial profile of horizontal velocity component u
+    REAL(wp), DIMENSION(:), ALLOCATABLE ::  vg                     !< geostrophic wind component in y-direction
+    REAL(wp), DIMENSION(:), ALLOCATABLE ::  v_init                 !< initial profile of horizontal velocity component v
+    REAL(wp), DIMENSION(:), ALLOCATABLE ::  w_subs                 !< subsidence/ascent velocity
+    REAL(wp), DIMENSION(:), ALLOCATABLE ::  zu                     !< vertical grid coordinate of u-grid (in m)
+    REAL(wp), DIMENSION(:), ALLOCATABLE ::  zw                     !< vertical grid coordinate of w-grid (in m)
+
+    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  c_u                   !< phase speed of u-velocity component
+    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  c_v                   !< phase speed of v-velocity component
+    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  c_w                   !< phase speed of w-velocity component
+    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  diss_s_e              !< artificial numerical dissipation flux at south face of grid box - subgrid-scale TKE
+    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  diss_s_nr             !< artificial numerical dissipation flux at south face of grid box - raindrop-number concentration    
+    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  diss_s_pt             !< artificial numerical dissipation flux at south face of grid box - potential temperature 
+    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  diss_s_q              !< artificial numerical dissipation flux at south face of grid box - mixing ratio 
+    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  diss_s_qr             !< artificial numerical dissipation flux at south face of grid box - rainwater 
+    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  diss_s_s              !< artificial numerical dissipation flux at south face of grid box - passive scalar
+    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  diss_s_sa             !< artificial numerical dissipation flux at south face of grid box - salinity
+    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  diss_s_u              !< artificial numerical dissipation flux at south face of grid box - u-component
+    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  diss_s_v              !< artificial numerical dissipation flux at south face of grid box - v-component
+    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  diss_s_w              !< artificial numerical dissipation flux at south face of grid box - w-component
+    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  dzu_mg                !< vertical grid size (u-grid) for multigrid pressure solver
+    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  dzw_mg                !< vertical grid size (w-grid) for multigrid pressure solver
+    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  flux_s_e              !< 6th-order advective flux at south face of grid box - subgrid-scale TKE
+    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  flux_s_nr             !< 6th-order advective flux at south face of grid box - raindrop-number concentration 
+    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  flux_s_pt             !< 6th-order advective flux at south face of grid box - potential temperature 
+    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  flux_s_q              !< 6th-order advective flux at south face of grid box - mixing ratio 
+    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  flux_s_qr             !< 6th-order advective flux at south face of grid box - rainwater
+    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  flux_s_s              !< 6th-order advective flux at south face of grid box - passive scalar
+    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  flux_s_sa             !< 6th-order advective flux at south face of grid box - salinity
+    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  flux_s_u              !< 6th-order advective flux at south face of grid box - u-component
+    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  flux_s_v              !< 6th-order advective flux at south face of grid box - v-component
+    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  flux_s_w              !< 6th-order advective flux at south face of grid box - w-component
+    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  f1_mg                 !< Siggi
+    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  f2_mg                 !< Siggi
+    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  f3_mg                 !< Siggi
+    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  mean_inflow_profiles  !< used for turbulent inflow (non-cyclic boundary conditions)
+    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  precipitation_amount  !< precipitation amount due to gravitational settling (bulk microphysics)
+    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  precipitation_rate    !< precipitation rate (bulk microphysics)
+    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  ptnudge               !< vertical profile of pot. temperature interpolated to vertical grid (nudging)
+    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  pt_slope_ref          !< potential temperature in rotated coordinate system 
+                                                                    !< (in case of sloped surface) 
+    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  qnudge                !< vertical profile of specific humidity interpolated to vertical grid (nudging) 
+    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  tnudge                !< vertical profile of nudging time scale interpolated to vertical grid (nudging)  
+    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  td_lsa_lpt            !< temperature tendency due to large scale advection (large scale forcing)
+    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  td_lsa_q              !< specific humidity tendency due to large scale advection (large scale forcing)
+    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  td_sub_lpt            !< temperature tendency due to subsidence/ascent (large scale forcing)
+    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  td_sub_q              !< specific humidity tendency due to subsidence/ascent (large scale forcing)
+    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  total_2d_a            !< Siggi 
+    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  total_2d_o            !< Siggi
+    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  ug_vert               !< vertical profile of geostrophic wind component in x-direction interpolated to vertical grid (large scale forcing)
+    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  unudge                !< vertical profile of wind component in x-direction interpolated to vertical grid (nudging) 
+    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  vnudge                !< vertical profile of wind component in y-direction interpolated to vertical grid (nudging) 
+    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  vg_vert               !< vertical profile of geostrophic wind component in y-direction interpolated to vertical grid (large scale forcing)
+    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  wnudge                !< vertical profile of subsidence/ascent velocity interpolated to vertical grid (nudging) ???
+    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  wsubs_vert            !< vertical profile of wind component in z-direction interpolated to vertical grid (nudging) ???
     
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  d          !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  de_dx      !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  de_dy      !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  de_dz      !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  diss       !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  diss_l_e   !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  diss_l_nr  !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  diss_l_pt  !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  diss_l_q   !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  diss_l_qr  !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  diss_l_s   !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  diss_l_sa  !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  diss_l_u   !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  diss_l_v   !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  diss_l_w   !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  flux_l_e   !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  flux_l_nr  !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  flux_l_pt  !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  flux_l_q   !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  flux_l_qr  !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  flux_l_s   !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  flux_l_sa  !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  flux_l_u   !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  flux_l_v   !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  flux_l_w   !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  kh         !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  km         !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  l_wall     !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  prr        !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  p_loc      !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  tend       !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  tric       !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  u_m_l      !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  u_m_n      !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  u_m_r      !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  u_m_s      !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  v_m_l      !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  v_m_n      !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  v_m_r      !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  v_m_s      !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  w_m_l      !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  w_m_n      !<  
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  w_m_r      !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  w_m_s      !< 
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  d          !< divergence
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  de_dx      !< gradient of sgs tke in x-direction (lpm)
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  de_dy      !< gradient of sgs tke in y-direction (lpm)
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  de_dz      !< gradient of sgs tke in z-direction (lpm)
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  diss       !< TKE dissipation rate
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  diss_l_e   !< artificial numerical dissipation flux at left face of grid box - subgrid-scale TKE
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  diss_l_nr  !< artificial numerical dissipation flux at left face of grid box - raindrop-number concentration
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  diss_l_pt  !< artificial numerical dissipation flux at left face of grid box - potential temperature
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  diss_l_q   !< artificial numerical dissipation flux at left face of grid box - mixing ratio
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  diss_l_qr  !< artificial numerical dissipation flux at left face of grid box - rainwater
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  diss_l_s   !< artificial numerical dissipation flux at left face of grid box - passive scalar
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  diss_l_sa  !< artificial numerical dissipation flux at left face of grid box - salinity
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  diss_l_u   !< artificial numerical dissipation flux at left face of grid box - u-component
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  diss_l_v   !< artificial numerical dissipation flux at left face of grid box - v-component
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  diss_l_w   !< artificial numerical dissipation flux at left face of grid box - w-component
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  flux_l_e   !< 6th-order advective flux at south face of grid box - subgrid-scale TKE
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  flux_l_nr  !< 6th-order advective flux at south face of grid box - raindrop-number concentration
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  flux_l_pt  !< 6th-order advective flux at south face of grid box - potential temperature
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  flux_l_q   !< 6th-order advective flux at south face of grid box - mixing ratio
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  flux_l_qr  !< 6th-order advective flux at south face of grid box - rainwater
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  flux_l_s   !< 6th-order advective flux at south face of grid box - passive scalar
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  flux_l_sa  !< 6th-order advective flux at south face of grid box - salinity
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  flux_l_u   !< 6th-order advective flux at south face of grid box - u-component
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  flux_l_v   !< 6th-order advective flux at south face of grid box - v-component
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  flux_l_w   !< 6th-order advective flux at south face of grid box - w-component
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  kh         !< eddy diffusivity for heat 
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  km         !< eddy diffusivity for momentum
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  l_wall     !< near-wall mixing length
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  prr        !< rain rate
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  p_loc      !< Siggi
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  tend       !< tendency field (time integration)
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  tric       !< Siggi
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  u_m_l      !< Siggi
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  u_m_n      !< Siggi
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  u_m_r      !< Siggi
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  u_m_s      !< Siggi
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  v_m_l      !< Siggi
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  v_m_n      !< Siggi
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  v_m_r      !< Siggi
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  v_m_s      !< Siggi
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  w_m_l      !< Siggi
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  w_m_n      !< Siggi 
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  w_m_r      !< Siggi
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  w_m_s      !< Siggi
 
 #if defined( __nopointer )
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  e          !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  e_p        !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  nr         !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  nr_p       !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  p          !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  prho       !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  pt         !<
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  pt_p       !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  q          !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  q_p        !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  qc         !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  ql         !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  ql_c       !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  ql_v       !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  ql_vp      !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  qr         !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  qr_p       !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  rho_ocean  !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  s          !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  s_p        !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  sa         !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  sa_p       !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  te_m       !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  tnr_m      !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  tpt_m      !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  tq_m       !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  tqr_m      !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  ts_m       !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  tsa_m      !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  tu_m       !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  tv_m       !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  tw_m       !<  
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  u          !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  u_p        !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  v          !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  v_p        !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  vpt        !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  w          !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  w_p        !< 
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  e          !< subgrid-scale turbulence kinetic energy (sgs tke)
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  e_p        !< prognostic value of sgs tke
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  nr         !< rain drop number density
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  nr_p       !< prognostic value of rain drop number density
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  p          !< perturbation pressure
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  prho       !< potential density
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  pt         !< potential temperature
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  pt_p       !< prognostic value of potential temperature
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  q          !< specific humidity
+                                                                   !< (or total water content with active cloud physics)
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  q_p        !< prognostic value of specific humidity 
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  qc         !< cloud water content
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  ql         !< liquid water content
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  ql_c       !< change in liquid water content due to 
+                                                                   !< condensation/evaporation during last time step
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  ql_v       !< volume of liquid water
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  ql_vp      !< liquid water weighting factor
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  qr         !< rain water content
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  qr_p       !< prognostic value of rain water content 
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  rho_ocean  !< density of ocean
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  s          !< passive scalar
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  s_p        !< prognostic value of passive scalar
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  sa         !< ocean salinity
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  sa_p       !< prognostic value of ocean salinity
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  te_m       !< weighted tendency of e for previous sub-timestep (Runge-Kutta)
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  tnr_m      !< weighted tendency of nr for previous sub-timestep (Runge-Kutta)
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  tpt_m      !< weighted tendency of pt for previous sub-timestep (Runge-Kutta)
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  tq_m       !< weighted tendency of q for previous sub-timestep (Runge-Kutta)
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  tqr_m      !< weighted tendency of qr for previous sub-timestep (Runge-Kutta)
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  ts_m       !< weighted tendency of s for previous sub-timestep (Runge-Kutta)
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  tsa_m      !< weighted tendency of sa for previous sub-timestep (Runge-Kutta)
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  tu_m       !< weighted tendency of u for previous sub-timestep (Runge-Kutta)
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  tv_m       !< weighted tendency of v for previous sub-timestep (Runge-Kutta)
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  tw_m       !< weighted tendency of w for previous sub-timestep (Runge-Kutta)
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  u          !< horizontal velocity component u (x-direction)
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  u_p        !< prognostic value of u
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  v          !< horizontal velocity component v (y-direction)
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  v_p        !< prognostic value of v
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  vpt        !< virtual potential temperature
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  w          !< vertical velocity component w (z-direction)
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  w_p        !< prognostic value of w
 #else
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  e_1     !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  e_2     !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  e_3     !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  p       !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  prho_1  !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  nr_1    !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  nr_2    !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  nr_3    !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  pt_1    !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  pt_2    !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  pt_3    !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  q_1     !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  q_2     !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  q_3     !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  qc_1    !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  ql_v    !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  ql_vp   !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  ql_1    !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  ql_2    !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  qr_1    !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  qr_2    !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  qr_3    !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  rho_1   !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  s_1     !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  s_2     !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  s_3     !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  sa_1    !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  sa_2    !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  sa_3    !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  u_1     !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  u_2     !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  u_3     !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  v_1     !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  v_2     !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  v_3     !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  vpt_1   !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  w_1     !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  w_2     !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  w_3     !< 
-
-    REAL(wp), DIMENSION(:,:,:), POINTER ::  e          !< 
-    REAL(wp), DIMENSION(:,:,:), POINTER ::  e_p        !< 
-    REAL(wp), DIMENSION(:,:,:), POINTER ::  nr         !< 
-    REAL(wp), DIMENSION(:,:,:), POINTER ::  nr_p       !< 
-    REAL(wp), DIMENSION(:,:,:), POINTER ::  prho       !< 
-    REAL(wp), DIMENSION(:,:,:), POINTER ::  pt         !< 
-    REAL(wp), DIMENSION(:,:,:), POINTER ::  pt_p       !< 
-    REAL(wp), DIMENSION(:,:,:), POINTER ::  q          !< 
-    REAL(wp), DIMENSION(:,:,:), POINTER ::  q_p        !< 
-    REAL(wp), DIMENSION(:,:,:), POINTER ::  qc         !< 
-    REAL(wp), DIMENSION(:,:,:), POINTER ::  ql         !< 
-    REAL(wp), DIMENSION(:,:,:), POINTER ::  ql_c       !< 
-    REAL(wp), DIMENSION(:,:,:), POINTER ::  qr         !< 
-    REAL(wp), DIMENSION(:,:,:), POINTER ::  qr_p       !< 
-    REAL(wp), DIMENSION(:,:,:), POINTER ::  rho_ocean  !< 
-    REAL(wp), DIMENSION(:,:,:), POINTER ::  s          !< 
-    REAL(wp), DIMENSION(:,:,:), POINTER ::  s_p        !< 
-    REAL(wp), DIMENSION(:,:,:), POINTER ::  sa         !< 
-    REAL(wp), DIMENSION(:,:,:), POINTER ::  sa_p       !< 
-    REAL(wp), DIMENSION(:,:,:), POINTER ::  te_m       !< 
-    REAL(wp), DIMENSION(:,:,:), POINTER ::  tnr_m      !< 
-    REAL(wp), DIMENSION(:,:,:), POINTER ::  tpt_m      !< 
-    REAL(wp), DIMENSION(:,:,:), POINTER ::  tq_m       !< 
-    REAL(wp), DIMENSION(:,:,:), POINTER ::  tqr_m      !< 
-    REAL(wp), DIMENSION(:,:,:), POINTER ::  ts_m       !< 
-    REAL(wp), DIMENSION(:,:,:), POINTER ::  tsa_m      !< 
-    REAL(wp), DIMENSION(:,:,:), POINTER ::  tu_m       !< 
-    REAL(wp), DIMENSION(:,:,:), POINTER ::  tv_m       !< 
-    REAL(wp), DIMENSION(:,:,:), POINTER ::  tw_m       !< 
-    REAL(wp), DIMENSION(:,:,:), POINTER ::  u          !< 
-    REAL(wp), DIMENSION(:,:,:), POINTER ::  u_p        !< 
-    REAL(wp), DIMENSION(:,:,:), POINTER ::  v          !< 
-    REAL(wp), DIMENSION(:,:,:), POINTER ::  v_p        !< 
-    REAL(wp), DIMENSION(:,:,:), POINTER ::  vpt        !< 
-    REAL(wp), DIMENSION(:,:,:), POINTER ::  w          !< 
-    REAL(wp), DIMENSION(:,:,:), POINTER ::  w_p        !< 
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  e_1     !< pointer for swapping of timelevels for respective quantity
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  e_2     !< pointer for swapping of timelevels for respective quantity
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  e_3     !< pointer for swapping of timelevels for respective quantity
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  p       !< pointer: perturbation pressure
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  prho_1  !< pointer for swapping of timelevels for respective quantity
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  nr_1    !< pointer for swapping of timelevels for respective quantity
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  nr_2    !< pointer for swapping of timelevels for respective quantity 
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  nr_3    !< pointer for swapping of timelevels for respective quantity
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  pt_1    !< pointer for swapping of timelevels for respective quantity
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  pt_2    !< pointer for swapping of timelevels for respective quantity
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  pt_3    !< pointer for swapping of timelevels for respective quantity
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  q_1     !< pointer for swapping of timelevels for respective quantity
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  q_2     !< pointer for swapping of timelevels for respective quantity
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  q_3     !< pointer for swapping of timelevels for respective quantity
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  qc_1    !< pointer for swapping of timelevels for respective quantity
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  ql_v    !< pointer: volume of liquid water
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  ql_vp   !< pointer: liquid water weighting factor
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  ql_1    !< pointer for swapping of timelevels for respective quantity
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  ql_2    !< pointer for swapping of timelevels for respective quantity
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  qr_1    !< pointer for swapping of timelevels for respective quantity
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  qr_2    !< pointer for swapping of timelevels for respective quantity
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  qr_3    !< pointer for swapping of timelevels for respective quantity
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  rho_1   !< pointer for swapping of timelevels for respective quantity
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  s_1     !< pointer for swapping of timelevels for respective quantity
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  s_2     !< pointer for swapping of timelevels for respective quantity
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  s_3     !< pointer for swapping of timelevels for respective quantity
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  sa_1    !< pointer for swapping of timelevels for respective quantity
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  sa_2    !< pointer for swapping of timelevels for respective quantity
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  sa_3    !< pointer for swapping of timelevels for respective quantity
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  u_1     !< pointer for swapping of timelevels for respective quantity
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  u_2     !< pointer for swapping of timelevels for respective quantity
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  u_3     !< pointer for swapping of timelevels for respective quantity
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  v_1     !< pointer for swapping of timelevels for respective quantity
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  v_2     !< pointer for swapping of timelevels for respective quantity
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  v_3     !< pointer for swapping of timelevels for respective quantity
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  vpt_1   !< pointer for swapping of timelevels for respective quantity
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  w_1     !< pointer for swapping of timelevels for respective quantity
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  w_2     !< pointer for swapping of timelevels for respective quantity
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  w_3     !< pointer for swapping of timelevels for respective quantity
+
+    REAL(wp), DIMENSION(:,:,:), POINTER ::  e          !< pointer: subgrid-scale turbulence kinetic energy (sgs tke)
+    REAL(wp), DIMENSION(:,:,:), POINTER ::  e_p        !< pointer: prognostic value of sgs tke
+    REAL(wp), DIMENSION(:,:,:), POINTER ::  nr         !< pointer: rain drop number density
+    REAL(wp), DIMENSION(:,:,:), POINTER ::  nr_p       !< pointer: prognostic value of rain drop number density
+    REAL(wp), DIMENSION(:,:,:), POINTER ::  prho       !< pointer: potential density
+    REAL(wp), DIMENSION(:,:,:), POINTER ::  pt         !< pointer: potential temperature
+    REAL(wp), DIMENSION(:,:,:), POINTER ::  pt_p       !< pointer: prognostic value of potential temperature
+    REAL(wp), DIMENSION(:,:,:), POINTER ::  q          !< pointer: specific humidity
+    REAL(wp), DIMENSION(:,:,:), POINTER ::  q_p        !< pointer: prognostic value of specific humidity
+    REAL(wp), DIMENSION(:,:,:), POINTER ::  qc         !< pointer: cloud water content
+    REAL(wp), DIMENSION(:,:,:), POINTER ::  ql         !< pointer: liquid water content
+    REAL(wp), DIMENSION(:,:,:), POINTER ::  ql_c       !< pointer: change in liquid water content due to 
+                                                       !< condensation/evaporation during last time step
+    REAL(wp), DIMENSION(:,:,:), POINTER ::  qr         !< pointer: rain water content
+    REAL(wp), DIMENSION(:,:,:), POINTER ::  qr_p       !< pointer: prognostic value of rain water content
+    REAL(wp), DIMENSION(:,:,:), POINTER ::  rho_ocean  !< pointer: density of ocean
+    REAL(wp), DIMENSION(:,:,:), POINTER ::  s          !< pointer: passive scalar
+    REAL(wp), DIMENSION(:,:,:), POINTER ::  s_p        !< pointer: prognostic value of passive scalar
+    REAL(wp), DIMENSION(:,:,:), POINTER ::  sa         !< pointer: ocean salinity
+    REAL(wp), DIMENSION(:,:,:), POINTER ::  sa_p       !< pointer: prognostic value of ocean salinity
+    REAL(wp), DIMENSION(:,:,:), POINTER ::  te_m       !< pointer: weighted tendency of e for previous sub-timestep (Runge-Kutta)
+    REAL(wp), DIMENSION(:,:,:), POINTER ::  tnr_m      !< pointer: weighted tendency of nr for previous sub-timestep (Runge-Kutta)
+    REAL(wp), DIMENSION(:,:,:), POINTER ::  tpt_m      !< pointer: weighted tendency of pt for previous sub-timestep (Runge-Kutta)
+    REAL(wp), DIMENSION(:,:,:), POINTER ::  tq_m       !< pointer: weighted tendency of q for previous sub-timestep (Runge-Kutta)
+    REAL(wp), DIMENSION(:,:,:), POINTER ::  tqr_m      !< pointer: weighted tendency of qr for previous sub-timestep (Runge-Kutta)
+    REAL(wp), DIMENSION(:,:,:), POINTER ::  ts_m       !< pointer: weighted tendency of s for previous sub-timestep (Runge-Kutta)
+    REAL(wp), DIMENSION(:,:,:), POINTER ::  tsa_m      !< pointer: weighted tendency of sa for previous sub-timestep (Runge-Kutta)
+    REAL(wp), DIMENSION(:,:,:), POINTER ::  tu_m       !< pointer: weighted tendency of u for previous sub-timestep (Runge-Kutta)
+    REAL(wp), DIMENSION(:,:,:), POINTER ::  tv_m       !< pointer: weighted tendency of v for previous sub-timestep (Runge-Kutta)
+    REAL(wp), DIMENSION(:,:,:), POINTER ::  tw_m       !< pointer: weighted tendency of w for previous sub-timestep (Runge-Kutta)
+    REAL(wp), DIMENSION(:,:,:), POINTER ::  u          !< pointer: horizontal velocity component u (x-direction)
+    REAL(wp), DIMENSION(:,:,:), POINTER ::  u_p        !< pointer: prognostic value of u
+    REAL(wp), DIMENSION(:,:,:), POINTER ::  v          !< pointer: horizontal velocity component v (y-direction)
+    REAL(wp), DIMENSION(:,:,:), POINTER ::  v_p        !< pointer: prognostic value of v
+    REAL(wp), DIMENSION(:,:,:), POINTER ::  vpt        !< pointer: virtual potential temperature
+    REAL(wp), DIMENSION(:,:,:), POINTER ::  w          !< pointer: vertical velocity component w (z-direction)
+    REAL(wp), DIMENSION(:,:,:), POINTER ::  w_p        !< pointer: prognostic value of w
 #endif
 
-    REAL(wp), DIMENSION(:,:,:,:), ALLOCATABLE ::  tri      !< 
+    REAL(wp), DIMENSION(:,:,:,:), ALLOCATABLE ::  tri      !< Siggi 
 
     REAL(wp), DIMENSION(:), ALLOCATABLE ::  rho_air      !< air density profile on the uv grid
@@ -777,39 +786,41 @@
     USE kinds
 
-    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  lwp_av                 !< Avg. liquid water path
-    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  precipitation_rate_av  !< Avg. of precipitation rate
-    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  ol_av                  !< Avg. of Obukhov length
-    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  qsws_av                !< Avg. of surface moisture flux
-    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  ssws_av                !< Avg. of surface scalar flux
-    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  shf_av                 !< Avg. of surface heat flux
-    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  ts_av                  !< Avg. of characteristic temperature scale
-    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  us_av                  !< Avg. of friction velocity
-    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  z0_av                  !< Avg. of roughness length for momentum
-    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  z0h_av                 !< Avg. of roughness length for heat
-    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  z0q_av                 !< Avg. of roughness length for moisture
-
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  e_av          !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  lpt_av        !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  nr_av         !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  p_av          !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  pc_av         !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  pr_av         !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  prr_av        !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  pt_av         !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  q_av          !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  qc_av         !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  ql_av         !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  ql_c_av       !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  ql_v_av       !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  ql_vp_av      !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  qr_av         !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  qv_av         !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  rho_ocean_av  !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  s_av          !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  sa_av         !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  u_av          !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  v_av          !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  vpt_av        !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  w_av          !< 
+    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  lwp_av                 !< avg. liquid water path
+    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  precipitation_rate_av  !< avg. precipitation rate
+    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  ol_av                  !< avg. Obukhov length
+    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  qsws_av                !< avg. surface moisture flux
+    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  ssws_av                !< avg. surface scalar flux
+    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  shf_av                 !< avg. surface heat flux
+    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  ts_av                  !< avg. characteristic temperature scale
+    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  us_av                  !< avg. friction velocity
+    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  z0_av                  !< avg. roughness length for momentum
+    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  z0h_av                 !< avg. roughness length for heat
+    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  z0q_av                 !< avg. roughness length for moisture
+
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  e_av          !< avg. subgrid-scale tke
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  lpt_av        !< avg. liquid water potential temperature
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  nr_av         !< avg. rain drop number density
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  p_av          !< avg. perturbation pressure
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  pc_av         !< avg. particle/droplet concentration
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  pr_av         !< avg. particle/droplet radius
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  prr_av        !< avg. precipitation rate
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  pt_av         !< avg. potential temperature
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  q_av          !< avg. specific humidity
+                                                                      !< (or total water content with active cloud physics)
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  qc_av         !< avg. cloud water content
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  ql_av         !< avg. liquid water content 
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  ql_c_av       !< avg. change in liquid water content due to 
+                                                                      !< condensation/evaporation during last time step
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  ql_v_av       !< avg. volume of liquid water
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  ql_vp_av      !< avg. liquid water weighting factor
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  qr_av         !< avg. rain water content
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  qv_av         !< avg. water vapor content (specific humidity)
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  rho_ocean_av  !< avg. ocean density
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  s_av          !< avg. passive scalar
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  sa_av         !< avg. salinity
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  u_av          !< avg. horizontal velocity component u 
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  v_av          !< avg. horizontal velocity component v
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  vpt_av        !< avg. virtual potential temperature
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE, TARGET ::  w_av          !< avg. vertical velocity component
   
  END MODULE averaging
@@ -835,7 +846,7 @@
 
 
-    REAL(wp), DIMENSION(:), ALLOCATABLE ::  hyrho   !<
-    REAL(wp), DIMENSION(:), ALLOCATABLE ::  pt_d_t  !<
-    REAL(wp), DIMENSION(:), ALLOCATABLE ::  t_d_pt  !<
+    REAL(wp), DIMENSION(:), ALLOCATABLE ::  hyrho   !< density of air calculated with hydrostatic pressure 
+    REAL(wp), DIMENSION(:), ALLOCATABLE ::  pt_d_t  !< ratio of potential and actual temperature
+    REAL(wp), DIMENSION(:), ALLOCATABLE ::  t_d_pt  !< ratio of actual and potential temperature
 
     SAVE
@@ -853,11 +864,11 @@
     USE kinds
 
-    REAL(wp) ::  pi = 3.141592654_wp  !< 
-    REAL(wp) ::  adv_mom_1            !< 
-    REAL(wp) ::  adv_mom_3            !< 
-    REAL(wp) ::  adv_mom_5            !< 
-    REAL(wp) ::  adv_sca_1            !< 
-    REAL(wp) ::  adv_sca_3            !< 
-    REAL(wp) ::  adv_sca_5            !< 
+    REAL(wp) ::  pi = 3.141592654_wp  !< PI
+    REAL(wp) ::  adv_mom_1            !< 1/4 - constant used in 5th-order advection scheme for momentum advection (1st-order part)
+    REAL(wp) ::  adv_mom_3            !< 1/24 - constant used in 5th-order advection scheme for momentum advection (3rd-order part)
+    REAL(wp) ::  adv_mom_5            !< 1/120 - constant used in 5th-order advection scheme for momentum advection (5th-order part)
+    REAL(wp) ::  adv_sca_1            !< 1/2 - constant used in 5th-order advection scheme for scalar advection (1st-order part)
+    REAL(wp) ::  adv_sca_3            !< 1/12 - constant used in 5th-order advection scheme for scalar advection (3rd-order part)
+    REAL(wp) ::  adv_sca_5            !< 1/60 - constant used in 5th-order advection scheme for scalar advection (5th-order part)
     
     SAVE
@@ -876,9 +887,9 @@
 
     TYPE plot_precision
-       CHARACTER (LEN=8) ::  variable   !< 
-       INTEGER(iwp)      ::  precision  !< 
+       CHARACTER (LEN=8) ::  variable   !< Siggi
+       INTEGER(iwp)      ::  precision  !< Siggi
     END TYPE plot_precision
 
-    TYPE(plot_precision), DIMENSION(100) ::  plot_3d_precision =               &  !< 
+    TYPE(plot_precision), DIMENSION(100) ::  plot_3d_precision =               &  !< Siggi
                         (/ plot_precision( 'u', 2 ), plot_precision( 'v', 2 ), & 
                            plot_precision( 'w', 2 ), plot_precision( 'p', 5 ), & 
@@ -887,510 +898,505 @@
 
     TYPE file_status
-       LOGICAL ::  opened         !< 
-       LOGICAL ::  opened_before  !< 
+       LOGICAL ::  opened         !< Siggi
+       LOGICAL ::  opened_before  !< Siggi
     END TYPE file_status
     
-    INTEGER, PARAMETER      ::  mask_xyz_dimension = 100  !< 
-    INTEGER, PARAMETER      ::  max_masks = 50            !< 
+    INTEGER, PARAMETER      ::  mask_xyz_dimension = 100  !< limit of mask dimensions (100 points in each direction)
+    INTEGER, PARAMETER      ::  max_masks = 50            !< maximum number of masks
     INTEGER(iwp), PARAMETER ::  varnamelength = 30        !< length of output variable names
 
-    TYPE(file_status), DIMENSION(200+2*max_masks) ::                &  !< 
+    TYPE(file_status), DIMENSION(200+2*max_masks) ::                &  !< Siggi
                              openfile = file_status(.FALSE.,.FALSE.)
 
-    CHARACTER (LEN=1)    ::  cycle_mg = 'w'                               !< 
-    CHARACTER (LEN=1)    ::  timestep_reason = ' '                        !< 
-    CHARACTER (LEN=3)    ::  coupling_char = ''                           !< 
-    CHARACTER (LEN=5)    ::  write_binary = 'false'                       !< 
-    CHARACTER (LEN=8)    ::  most_method = 'newton'                       !< NAMELIST parameter defining method to be used to calculate Okukhov length, 
-    CHARACTER (LEN=8)    ::  run_date                                     !< 
-    CHARACTER (LEN=8)    ::  run_time                                     !< 
-    CHARACTER (LEN=9)    ::  simulated_time_chr                           !< 
-    CHARACTER (LEN=11)   ::  topography_grid_convention = ' '             !< 
-    CHARACTER (LEN=12)   ::  version = ' '                                !< 
-    CHARACTER (LEN=12)   ::  revision = ' '                               !< 
-    CHARACTER (LEN=12)   ::  user_interface_current_revision = ' '        !< 
-    CHARACTER (LEN=12)   ::  user_interface_required_revision = ' '       !< 
-    CHARACTER (LEN=16)   ::  conserve_volume_flow_mode = 'default'        !< 
-    CHARACTER (LEN=16)   ::  loop_optimization = 'default'                !< 
-    CHARACTER (LEN=16)   ::  momentum_advec = 'ws-scheme'                 !< 
-    CHARACTER (LEN=16)   ::  psolver = 'poisfft'                          !<  
-    CHARACTER (LEN=16)   ::  scalar_advec = 'ws-scheme'                   !< 
-    CHARACTER (LEN=20)   ::  approximation = 'boussinesq'                 !<  
-    CHARACTER (LEN=40)   ::  flux_input_mode = 'approximation-specific'   !< 
-    CHARACTER (LEN=40)   ::  flux_output_mode = 'approximation-specific'  !< 
-    CHARACTER (LEN=20)   ::  bc_e_b = 'neumann'                           !< 
-    CHARACTER (LEN=20)   ::  bc_lr = 'cyclic'                             !< 
-    CHARACTER (LEN=20)   ::  bc_ns = 'cyclic'                             !< 
-    CHARACTER (LEN=20)   ::  bc_p_b = 'neumann'                           !< 
-    CHARACTER (LEN=20)   ::  bc_p_t = 'dirichlet'                         !< 
-    CHARACTER (LEN=20)   ::  bc_pt_b = 'dirichlet'                        !< 
-    CHARACTER (LEN=20)   ::  bc_pt_t = 'initial_gradient'                 !< 
-    CHARACTER (LEN=20)   ::  bc_q_b = 'dirichlet'                         !< 
-    CHARACTER (LEN=20)   ::  bc_q_t = 'neumann'                           !< 
-    CHARACTER (LEN=20)   ::  bc_s_b = 'dirichlet'                         !< 
-    CHARACTER (LEN=20)   ::  bc_s_t = 'initial_gradient'                  !< 
-    CHARACTER (LEN=20)   ::  bc_sa_t = 'neumann'                          !< 
-    CHARACTER (LEN=20)   ::  bc_uv_b = 'dirichlet'                        !< 
-    CHARACTER (LEN=20)   ::  bc_uv_t = 'dirichlet'                        !< 
-    CHARACTER (LEN=20)   ::  cloud_scheme = 'saturation_adjust'           !< 
-    CHARACTER (LEN=20)   ::  coupling_mode = 'uncoupled'                  !<    
-    CHARACTER (LEN=20)   ::  coupling_mode_remote = 'uncoupled'           !< 
-    CHARACTER (LEN=20)   ::  dissipation_1d = 'detering'                  !< 
-    CHARACTER (LEN=20)   ::  fft_method = 'system-specific'               !< 
-    CHARACTER (LEN=20)   ::  mixing_length_1d = 'blackadar'               !< 
-    CHARACTER (LEN=20)   ::  random_generator = 'random-parallel'         !< 
-    CHARACTER (LEN=20)   ::  reference_state = 'initial_profile'          !<   
-    CHARACTER (LEN=20)   ::  return_addres                                !< 
-    CHARACTER (LEN=20)   ::  return_username                              !< 
-    CHARACTER (LEN=20)   ::  timestep_scheme = 'runge-kutta-3'            !<        
-    CHARACTER (LEN=40)   ::  avs_data_file                                !< 
-    CHARACTER (LEN=40)   ::  topography = 'flat'                          !<  
-    CHARACTER (LEN=64)   ::  host = ' '                                   !< 
-    CHARACTER (LEN=80)   ::  log_message                                  !< 
-    CHARACTER (LEN=80)   ::  run_identifier                               !<  
-    CHARACTER (LEN=100)  ::  initializing_actions = ' '                   !< 
-    CHARACTER (LEN=210)  ::  run_description_header                       !< 
-    CHARACTER (LEN=1000) ::  message_string = ' '                         !< 
-
-    CHARACTER (LEN=varnamelength), DIMENSION(500) ::  data_output = ' '       !< 
-    CHARACTER (LEN=varnamelength), DIMENSION(500) ::  data_output_user = ' '  !< 
-    CHARACTER (LEN=varnamelength), DIMENSION(500) ::  doav = ' '              !<
+    CHARACTER (LEN=1)    ::  cycle_mg = 'w'                               !< namelist parameter (see documentation)
+    CHARACTER (LEN=1)    ::  timestep_reason = ' '                        !< 'A'dvection or 'D'iffusion criterion, written to RUN_CONTROL file
+    CHARACTER (LEN=3)    ::  coupling_char = ''                           !< Siggi
+    CHARACTER (LEN=5)    ::  write_binary = 'false'                       !< internal namelist parameter Siggi--> Why is this not a flag?
+    CHARACTER (LEN=8)    ::  most_method = 'newton'                       !< namelist parameter
+    CHARACTER (LEN=8)    ::  run_date                                     !< date of simulation run, printed to HEADER file
+    CHARACTER (LEN=8)    ::  run_time                                     !< time of simulation run, printed to HEADER file
+    CHARACTER (LEN=9)    ::  simulated_time_chr                           !< simulated time, printed to RUN_CONTROL file
+    CHARACTER (LEN=11)   ::  topography_grid_convention = ' '             !< namelist parameter
+    CHARACTER (LEN=12)   ::  version = ' '                                !< PALM version number
+    CHARACTER (LEN=12)   ::  revision = ' '                               !< PALM revision number
+    CHARACTER (LEN=12)   ::  user_interface_current_revision = ' '        !< Siggi
+    CHARACTER (LEN=12)   ::  user_interface_required_revision = ' '       !< Siggi
+    CHARACTER (LEN=16)   ::  conserve_volume_flow_mode = 'default'        !< namelist parameter
+    CHARACTER (LEN=16)   ::  loop_optimization = 'default'                !< namelist parameter
+    CHARACTER (LEN=16)   ::  momentum_advec = 'ws-scheme'                 !< namelist parameter
+    CHARACTER (LEN=16)   ::  psolver = 'poisfft'                          !< namelist parameter
+    CHARACTER (LEN=16)   ::  scalar_advec = 'ws-scheme'                   !< namelist parameter
+    CHARACTER (LEN=20)   ::  approximation = 'boussinesq'                 !< namelist parameter
+    CHARACTER (LEN=40)   ::  flux_input_mode = 'approximation-specific'   !< type of flux input: dynamic or kinematic
+    CHARACTER (LEN=40)   ::  flux_output_mode = 'approximation-specific'  !< type of flux output: dynamic or kinematic
+    CHARACTER (LEN=20)   ::  bc_e_b = 'neumann'                           !< namelist parameter
+    CHARACTER (LEN=20)   ::  bc_lr = 'cyclic'                             !< namelist parameter
+    CHARACTER (LEN=20)   ::  bc_ns = 'cyclic'                             !< namelist parameter
+    CHARACTER (LEN=20)   ::  bc_p_b = 'neumann'                           !< namelist parameter
+    CHARACTER (LEN=20)   ::  bc_p_t = 'dirichlet'                         !< namelist parameter
+    CHARACTER (LEN=20)   ::  bc_pt_b = 'dirichlet'                        !< namelist parameter
+    CHARACTER (LEN=20)   ::  bc_pt_t = 'initial_gradient'                 !< namelist parameter
+    CHARACTER (LEN=20)   ::  bc_q_b = 'dirichlet'                         !< namelist parameter
+    CHARACTER (LEN=20)   ::  bc_q_t = 'neumann'                           !< namelist parameter
+    CHARACTER (LEN=20)   ::  bc_s_b = 'dirichlet'                         !< namelist parameter
+    CHARACTER (LEN=20)   ::  bc_s_t = 'initial_gradient'                  !< namelist parameter
+    CHARACTER (LEN=20)   ::  bc_sa_t = 'neumann'                          !< namelist parameter
+    CHARACTER (LEN=20)   ::  bc_uv_b = 'dirichlet'                        !< namelist parameter
+    CHARACTER (LEN=20)   ::  bc_uv_t = 'dirichlet'                        !< namelist parameter
+    CHARACTER (LEN=20)   ::  cloud_scheme = 'saturation_adjust'           !< namelist parameter
+    CHARACTER (LEN=20)   ::  coupling_mode = 'uncoupled'                  !< coupling mode for atmosphere-ocean coupling  
+    CHARACTER (LEN=20)   ::  coupling_mode_remote = 'uncoupled'           !< Siggi
+    CHARACTER (LEN=20)   ::  dissipation_1d = 'detering'                  !< namelist parameter
+    CHARACTER (LEN=20)   ::  fft_method = 'system-specific'               !< namelist parameter
+    CHARACTER (LEN=20)   ::  mixing_length_1d = 'blackadar'               !< namelist parameter
+    CHARACTER (LEN=20)   ::  random_generator = 'random-parallel'         !< namelist parameter
+    CHARACTER (LEN=20)   ::  reference_state = 'initial_profile'          !< namelist parameter  
+    CHARACTER (LEN=20)   ::  return_addres                                !< Siggi
+    CHARACTER (LEN=20)   ::  return_username                              !< Siggi
+    CHARACTER (LEN=20)   ::  timestep_scheme = 'runge-kutta-3'            !< namelist parameter       
+    CHARACTER (LEN=40)   ::  avs_data_file                                !< Siggi
+    CHARACTER (LEN=40)   ::  topography = 'flat'                          !< namelist parameter 
+    CHARACTER (LEN=64)   ::  host = ' '                                   !< Siggi
+    CHARACTER (LEN=80)   ::  log_message                                  !< Siggi
+    CHARACTER (LEN=80)   ::  run_identifier                               !< Siggi
+    CHARACTER (LEN=100)  ::  initializing_actions = ' '                   !< namelist parameter
+    CHARACTER (LEN=210)  ::  run_description_header                       !< Siggi
+    CHARACTER (LEN=1000) ::  message_string = ' '                         !< dynamic string for error message output
+
+    CHARACTER (LEN=varnamelength), DIMENSION(500) ::  data_output = ' '       !< namelist parameter
+    CHARACTER (LEN=varnamelength), DIMENSION(500) ::  data_output_user = ' '  !< namelist parameter
+    CHARACTER (LEN=varnamelength), DIMENSION(500) ::  doav = ' '              !< label array for multi-dimensional, 
+                                                                              !< averaged output quantities
                                             
-    CHARACTER (LEN=varnamelength), DIMENSION(max_masks,100) ::  data_output_masks = ' '       !< 
-    CHARACTER (LEN=varnamelength), DIMENSION(max_masks,100) ::  data_output_masks_user = ' '  !< 
-
-    CHARACTER (LEN=varnamelength), DIMENSION(300) ::  data_output_pr = ' '  !< 
+    CHARACTER (LEN=varnamelength), DIMENSION(max_masks,100) ::  data_output_masks = ' '       !< namelist parameter
+    CHARACTER (LEN=varnamelength), DIMENSION(max_masks,100) ::  data_output_masks_user = ' '  !< namelist parameter
+
+    CHARACTER (LEN=varnamelength), DIMENSION(300) ::  data_output_pr = ' '  !< namelist parameter
     
-    CHARACTER (LEN=varnamelength), DIMENSION(200) ::  data_output_pr_user = ' '  !< 
+    CHARACTER (LEN=varnamelength), DIMENSION(200) ::  data_output_pr_user = ' '  !< namelist parameter
     
-    CHARACTER (LEN=varnamelength), DIMENSION(max_masks,0:1,100) ::  domask = ' ' !< 
+    CHARACTER (LEN=varnamelength), DIMENSION(max_masks,0:1,100) ::  domask = ' ' !< label array for multi-dimensional, 
+                                                                                 !< masked output quantities
     
-    CHARACTER (LEN=varnamelength), DIMENSION(0:1,500) ::  do2d = ' '  !< 
-    CHARACTER (LEN=varnamelength), DIMENSION(0:1,500) ::  do3d = ' '  !< 
-
-    INTEGER(iwp), PARAMETER ::  fl_max = 100     !< 
-    INTEGER(iwp), PARAMETER ::  var_fl_max = 20  !< 
+    CHARACTER (LEN=varnamelength), DIMENSION(0:1,500) ::  do2d = ' '  !< label array for 2d output quantities
+    CHARACTER (LEN=varnamelength), DIMENSION(0:1,500) ::  do3d = ' '  !< label array for 3d output quantities
+
+    INTEGER(iwp), PARAMETER ::  fl_max = 100     !< maximum number of virtual-flight measurements
+    INTEGER(iwp), PARAMETER ::  var_fl_max = 20  !< maximum number of different sampling variables in virtual flight measurements
     
-    INTEGER(iwp) ::  abort_mode = 1                    !< 
-    INTEGER(iwp) ::  average_count_pr = 0              !< 
-    INTEGER(iwp) ::  average_count_3d = 0              !< 
-    INTEGER(iwp) ::  current_timestep_number = 0       !< 
-    INTEGER(iwp) ::  coupling_topology = 0             !< 
-    INTEGER(iwp) ::  dist_range = 0                    !< 
-    INTEGER(iwp) ::  disturbance_level_ind_b           !< 
-    INTEGER(iwp) ::  disturbance_level_ind_t           !< 
-    INTEGER(iwp) ::  doav_n = 0                        !< 
-    INTEGER(iwp) ::  dopr_n = 0                        !< 
-    INTEGER(iwp) ::  dopr_time_count = 0               !< 
-    INTEGER(iwp) ::  dopts_time_count = 0              !< 
-    INTEGER(iwp) ::  dots_time_count = 0               !< 
-    INTEGER(iwp) ::  do2d_xy_n = 0                     !< 
-    INTEGER(iwp) ::  do2d_xz_n = 0                     !< 
-    INTEGER(iwp) ::  do2d_yz_n = 0                     !< 
-    INTEGER(iwp) ::  do3d_avs_n = 0                    !< 
-    INTEGER(iwp) ::  dp_level_ind_b = 0                !< 
-    INTEGER(iwp) ::  dvrp_filecount = 0                !< 
-    INTEGER(iwp) ::  dz_stretch_level_index            !< 
-    INTEGER(iwp) ::  ensemble_member_nr = 0            !< 
-    INTEGER(iwp) ::  gamma_mg                          !< 
-    INTEGER(iwp) ::  gathered_size                     !< 
-    INTEGER(iwp) ::  grid_level                        !< 
-    INTEGER(iwp) ::  ibc_e_b                           !< 
-    INTEGER(iwp) ::  ibc_p_b                           !< 
-    INTEGER(iwp) ::  ibc_p_t                           !< 
-    INTEGER(iwp) ::  ibc_pt_b                          !< 
-    INTEGER(iwp) ::  ibc_pt_t                          !< 
-    INTEGER(iwp) ::  ibc_q_b                           !< 
-    INTEGER(iwp) ::  ibc_q_t                           !< 
-    INTEGER(iwp) ::  ibc_s_b                           !< 
-    INTEGER(iwp) ::  ibc_s_t                           !< 
-    INTEGER(iwp) ::  ibc_sa_t                          !< 
-    INTEGER(iwp) ::  ibc_uv_b                          !< 
-    INTEGER(iwp) ::  ibc_uv_t                          !< 
-    INTEGER(iwp) ::  inflow_disturbance_begin = -1     !< 
-    INTEGER(iwp) ::  inflow_disturbance_end = -1       !< 
-    INTEGER(iwp) ::  intermediate_timestep_count       !< 
-    INTEGER(iwp) ::  intermediate_timestep_count_max   !< 
-    INTEGER(iwp) ::  io_group = 0                      !< 
-    INTEGER(iwp) ::  io_blocks = 1                     !< 
-    INTEGER(iwp) ::  iran = -1234567                   !< 
+    INTEGER(iwp) ::  abort_mode = 1                    !< abort condition (nested runs)
+    INTEGER(iwp) ::  average_count_pr = 0              !< number of samples in vertical-profile output
+    INTEGER(iwp) ::  average_count_3d = 0              !< number of samples in 3d output
+    INTEGER(iwp) ::  current_timestep_number = 0       !< current timestep number, printed to RUN_CONTROL file
+    INTEGER(iwp) ::  coupling_topology = 0             !< processor topology for atmosphere-ocean coupling  Siggi
+    INTEGER(iwp) ::  dist_range = 0                    !< Siggi
+    INTEGER(iwp) ::  disturbance_level_ind_b           !< lowest grid index where flow disturbance is applied
+    INTEGER(iwp) ::  disturbance_level_ind_t           !< highest grid index where flow disturbance is applied
+    INTEGER(iwp) ::  doav_n = 0                        !< number of 2d/3d output quantities subject to time averaging
+    INTEGER(iwp) ::  dopr_n = 0                        !< number of profile output quantities subject to time averaging
+    INTEGER(iwp) ::  dopr_time_count = 0               !< number of output intervals for profile output
+    INTEGER(iwp) ::  dopts_time_count = 0              !< number of output intervals for particle data timeseries
+    INTEGER(iwp) ::  dots_time_count = 0               !< number of output intervals for timeseries output
+    INTEGER(iwp) ::  dp_level_ind_b = 0                !< lowest grid index for external pressure gradient forcing
+    INTEGER(iwp) ::  dvrp_filecount = 0                !< Siggi
+    INTEGER(iwp) ::  dz_stretch_level_index            !< Siggi
+    INTEGER(iwp) ::  ensemble_member_nr = 0            !< namelist parameter
+    INTEGER(iwp) ::  gamma_mg                          !< Siggi
+    INTEGER(iwp) ::  gathered_size                     !< Siggi
+    INTEGER(iwp) ::  grid_level                        !< Siggi
+    INTEGER(iwp) ::  ibc_e_b                           !< integer flag for bc_e_b
+    INTEGER(iwp) ::  ibc_p_b                           !< integer flag for bc_p_b
+    INTEGER(iwp) ::  ibc_p_t                           !< integer flag for bc_p_t
+    INTEGER(iwp) ::  ibc_pt_b                          !< integer flag for bc_pt_b
+    INTEGER(iwp) ::  ibc_pt_t                          !< integer flag for bc_pt_t
+    INTEGER(iwp) ::  ibc_q_b                           !< integer flag for bc_q_b
+    INTEGER(iwp) ::  ibc_q_t                           !< integer flag for bc_q_t
+    INTEGER(iwp) ::  ibc_s_b                           !< integer flag for bc_s_b
+    INTEGER(iwp) ::  ibc_s_t                           !< integer flag for bc_s_t
+    INTEGER(iwp) ::  ibc_sa_t                          !< integer flag for bc_sa_t
+    INTEGER(iwp) ::  ibc_uv_b                          !< integer flag for bc_uv_b
+    INTEGER(iwp) ::  ibc_uv_t                          !< integer flag for bc_uv_t
+    INTEGER(iwp) ::  inflow_disturbance_begin = -1     !< namelist parameter
+    INTEGER(iwp) ::  inflow_disturbance_end = -1       !< namelist parameter
+    INTEGER(iwp) ::  intermediate_timestep_count       !< number of current Runge-Kutta substep
+    INTEGER(iwp) ::  intermediate_timestep_count_max   !< maximum number of Runge-Kutta substeps
+    INTEGER(iwp) ::  io_group = 0                      !< Siggi
+    INTEGER(iwp) ::  io_blocks = 1                     !< Siggi
+    INTEGER(iwp) ::  iran = -1234567                   !< integer random number used for flow disturbances
     INTEGER(iwp) ::  lod = 1                           !< level of detail, topography input parameter 
-    INTEGER(iwp) ::  masks = 0                         !< 
-    INTEGER(iwp) ::  maximum_grid_level                !< 
-    INTEGER(iwp) ::  maximum_parallel_io_streams = -1  !< 
-    INTEGER(iwp) ::  max_pr_user = 0                   !< 
-    INTEGER(iwp) ::  mgcycles = 0                      !< 
-    INTEGER(iwp) ::  mg_cycles = -1                    !< 
-    INTEGER(iwp) ::  mg_switch_to_pe0_level = -1       !< 
-    INTEGER(iwp) ::  mid                               !< 
-    INTEGER(iwp) ::  nlsf = 1000                       !< 
-    INTEGER(iwp) ::  ntnudge = 1000                    !< 
-    INTEGER(iwp) ::  ngsrb = 2                         !< 
-    INTEGER(iwp) ::  nr_timesteps_this_run = 0         !< 
-    INTEGER(iwp) ::  nsor = 20                         !< 
-    INTEGER(iwp) ::  nsor_ini = 100                    !< 
-    INTEGER(iwp) ::  n_sor                             !< 
-    INTEGER(iwp) ::  normalizing_region = 0            !< 
-    INTEGER(iwp) ::  num_leg=0                         !< 
-    INTEGER(iwp) ::  num_var_fl                        !< 
-    INTEGER(iwp) ::  num_var_fl_user=0                 !< 
-    INTEGER(iwp) ::  nz_do3d = -9999                   !< 
-    INTEGER(iwp) ::  prt_time_count = 0                !< 
-    INTEGER(iwp) ::  recycling_plane                   !< 
-    INTEGER(iwp) ::  runnr = 0                         !< 
-    INTEGER(iwp) ::  skip_do_avs = 0                   !< 
-    INTEGER(iwp) ::  subdomain_size                    !< 
-    INTEGER(iwp) ::  terminate_coupled = 0             !< 
-    INTEGER(iwp) ::  terminate_coupled_remote = 0      !< 
-    INTEGER(iwp) ::  timestep_count = 0                !< 
-
-    INTEGER(iwp) ::  dist_nxl(0:1)                               !< 
-    INTEGER(iwp) ::  dist_nxr(0:1)                               !< 
-    INTEGER(iwp) ::  dist_nyn(0:1)                               !< 
-    INTEGER(iwp) ::  dist_nys(0:1)                               !< 
-    INTEGER(iwp) ::  do2d_no(0:1) = 0                            !< 
-    INTEGER(iwp) ::  do2d_xy_time_count(0:1)                     !< 
-    INTEGER(iwp) ::  do2d_xz_time_count(0:1)                     !< 
-    INTEGER(iwp) ::  do2d_yz_time_count(0:1)                     !< 
-    INTEGER(iwp) ::  do3d_no(0:1) = 0                            !< 
-    INTEGER(iwp) ::  do3d_time_count(0:1)                        !< 
-    INTEGER(iwp) ::  domask_no(max_masks,0:1) = 0                !< 
-    INTEGER(iwp) ::  domask_time_count(max_masks,0:1)            !< 
-    INTEGER(iwp) ::  mask_size(max_masks,3) = -1                 !< 
-    INTEGER(iwp) ::  mask_size_l(max_masks,3) = -1               !< 
-    INTEGER(iwp) ::  mask_start_l(max_masks,3) = -1              !< 
-    INTEGER(iwp) ::  pt_vertical_gradient_level_ind(10) = -9999  !< 
-    INTEGER(iwp) ::  q_vertical_gradient_level_ind(10) = -9999   !< 
-    INTEGER(iwp) ::  s_vertical_gradient_level_ind(10) = -9999   !<                
-    INTEGER(iwp) ::  sa_vertical_gradient_level_ind(10) = -9999  !< 
-    INTEGER(iwp) ::  section(100,3)                              !< 
-    INTEGER(iwp) ::  section_xy(100) = -9999                     !< 
-    INTEGER(iwp) ::  section_xz(100) = -9999                     !< 
-    INTEGER(iwp) ::  section_yz(100) = -9999                     !< 
-    INTEGER(iwp) ::  ug_vertical_gradient_level_ind(10) = -9999  !< 
-    INTEGER(iwp) ::  vg_vertical_gradient_level_ind(10) = -9999  !< 
-    INTEGER(iwp) ::  subs_vertical_gradient_level_i(10) = -9999  !< 
-
-
-    INTEGER(iwp), DIMENSION(0:1) ::  ntdim_2d_xy  !< 
-    INTEGER(iwp), DIMENSION(0:1) ::  ntdim_2d_xz  !< 
-    INTEGER(iwp), DIMENSION(0:1) ::  ntdim_2d_yz  !< 
-    INTEGER(iwp), DIMENSION(0:1) ::  ntdim_3d     !< 
-
-    INTEGER(iwp), DIMENSION(:), ALLOCATABLE ::  grid_level_count  !< 
-
-    INTEGER(iwp), DIMENSION(:,:), ALLOCATABLE ::  mask_i         !< 
-    INTEGER(iwp), DIMENSION(:,:), ALLOCATABLE ::  mask_j         !< 
-    INTEGER(iwp), DIMENSION(:,:), ALLOCATABLE ::  mask_k         !< 
-    INTEGER(iwp), DIMENSION(:,:), ALLOCATABLE ::  mask_i_global  !<   
-    INTEGER(iwp), DIMENSION(:,:), ALLOCATABLE ::  mask_j_global  !< 
-    INTEGER(iwp), DIMENSION(:,:), ALLOCATABLE ::  mask_k_global  !< 
-
-    LOGICAL ::  bc_lr_cyc =.TRUE.                            !< 
-    LOGICAL ::  bc_lr_dirrad = .FALSE.                       !< 
-    LOGICAL ::  bc_lr_raddir = .FALSE.                       !< 
-    LOGICAL ::  bc_ns_cyc = .TRUE.                           !< 
-    LOGICAL ::  bc_ns_dirrad = .FALSE.                       !< 
-    LOGICAL ::  bc_ns_raddir = .FALSE.                       !< 
-    LOGICAL ::  call_microphysics_at_all_substeps = .FALSE.  !< 
-    LOGICAL ::  call_psolver_at_all_substeps = .TRUE.        !< 
-    LOGICAL ::  cloud_droplets = .FALSE.                     !< 
-    LOGICAL ::  cloud_physics = .FALSE.                      !< 
-    LOGICAL ::  cloud_top_radiation = .FALSE.                !< 
-    LOGICAL ::  conserve_volume_flow = .FALSE.               !< 
-    LOGICAL ::  constant_diffusion = .FALSE.                 !< 
-    LOGICAL ::  constant_flux_layer = .TRUE.                 !< 
-    LOGICAL ::  constant_heatflux = .TRUE.                   !<  
-    LOGICAL ::  constant_top_heatflux = .TRUE.               !< 
-    LOGICAL ::  constant_top_momentumflux = .FALSE.          !< 
-    LOGICAL ::  constant_top_salinityflux = .TRUE.           !< 
-    LOGICAL ::  constant_top_scalarflux = .TRUE.             !< 
-    LOGICAL ::  constant_scalarflux = .TRUE.                 !< 
-    LOGICAL ::  constant_waterflux = .TRUE.                  !< 
-    LOGICAL ::  create_disturbances = .TRUE.                 !< 
-    LOGICAL ::  data_output_2d_on_each_pe = .TRUE.           !< 
-    LOGICAL ::  dissipation_control = .FALSE.                !< 
-    LOGICAL ::  disturbance_created = .FALSE.                !< 
-    LOGICAL ::  do2d_at_begin = .FALSE.                      !< 
-    LOGICAL ::  do3d_at_begin = .FALSE.                      !< 
-    LOGICAL ::  do_sum = .FALSE.                             !< 
-    LOGICAL ::  dp_external = .FALSE.                        !< 
-    LOGICAL ::  dp_smooth = .FALSE.                          !< 
-    LOGICAL ::  dt_fixed = .FALSE.                           !< 
-    LOGICAL ::  dt_3d_reached                                !< 
-    LOGICAL ::  dt_3d_reached_l                              !< 
-    LOGICAL ::  exchange_mg = .FALSE.                        !< 
-    LOGICAL ::  first_call_lpm = .TRUE.                      !< 
-    LOGICAL ::  force_print_header = .FALSE.                 !< 
-    LOGICAL ::  galilei_transformation = .FALSE.             !< 
-    LOGICAL ::  humidity = .FALSE.                           !< 
-    LOGICAL ::  humidity_remote = .FALSE.                    !< 
-    LOGICAL ::  inflow_l = .FALSE.                           !< 
-    LOGICAL ::  inflow_n = .FALSE.                           !< 
-    LOGICAL ::  inflow_r = .FALSE.                           !< 
-    LOGICAL ::  inflow_s = .FALSE.                           !< 
-    LOGICAL ::  large_scale_forcing = .FALSE.                !< 
-    LOGICAL ::  large_scale_subsidence = .FALSE.             !< 
-    LOGICAL ::  land_surface = .FALSE.                       !< flag parameter indicating wheather the lsm is used
-    LOGICAL ::  lsf_exception = .FALSE.                      !< temporary flag for use of lsf with buildings on flat terrain
-    LOGICAL ::  lsf_surf = .TRUE.                            !< 
-    LOGICAL ::  lsf_vert = .TRUE.                            !< 
-    LOGICAL ::  lptnudge = .FALSE.                           !< 
-    LOGICAL ::  lqnudge = .FALSE.                            !< 
-    LOGICAL ::  lunudge = .FALSE.                            !< 
-    LOGICAL ::  lvnudge = .FALSE.                            !< 
-    LOGICAL ::  lwnudge = .FALSE.                            !< 
-    LOGICAL ::  masking_method = .FALSE.                     !< 
-    LOGICAL ::  microphysics_sat_adjust = .FALSE.            !< 
-    LOGICAL ::  microphysics_kessler = .FALSE.               !< 
-    LOGICAL ::  microphysics_seifert = .FALSE.               !< 
-    LOGICAL ::  mg_switch_to_pe0 = .FALSE.                   !< 
-    LOGICAL ::  nest_bound_l = .FALSE.                       !< nested boundary on left side
-    LOGICAL ::  nest_bound_n = .FALSE.                       !< nested boundary on north side
-    LOGICAL ::  nest_bound_r = .FALSE.                       !< nested boundary on right side
-    LOGICAL ::  nest_bound_s = .FALSE.                       !< nested boundary on south side
-    LOGICAL ::  nest_domain  = .FALSE.                       !< domain is nested into a parent domain
-    LOGICAL ::  neutral = .FALSE.                            !< 
-    LOGICAL ::  nudging = .FALSE.                            !< 
-    LOGICAL ::  ocean = .FALSE.                              !< 
-    LOGICAL ::  outflow_l = .FALSE.                          !< 
-    LOGICAL ::  outflow_n = .FALSE.                          !< 
-    LOGICAL ::  outflow_r = .FALSE.                          !< 
-    LOGICAL ::  outflow_s = .FALSE.                          !< 
-    LOGICAL ::  passive_scalar = .FALSE.                     !< 
-    LOGICAL ::  precipitation = .FALSE.                      !< 
-    LOGICAL ::  random_heatflux = .FALSE.                    !< 
-    LOGICAL ::  recycling_yshift = .FALSE.                   !< 
-    LOGICAL ::  run_control_header = .FALSE.                 !< 
-    LOGICAL ::  run_coupled = .TRUE.                         !< 
-    LOGICAL ::  scalar_rayleigh_damping = .TRUE.             !< 
-    LOGICAL ::  sloping_surface = .FALSE.                    !< 
-    LOGICAL ::  stop_dt = .FALSE.                            !< 
-    LOGICAL ::  synchronous_exchange = .FALSE.               !< 
+    INTEGER(iwp) ::  masks = 0                         !< counter for number of masked output quantities
+    INTEGER(iwp) ::  maximum_grid_level                !< Siggi
+    INTEGER(iwp) ::  maximum_parallel_io_streams = -1  !< Siggi
+    INTEGER(iwp) ::  max_pr_user = 0                   !< number of user-defined profiles (must not change within a job chain)
+    INTEGER(iwp) ::  mgcycles = 0                      !< Siggi
+    INTEGER(iwp) ::  mg_cycles = -1                    !< namelist parameter
+    INTEGER(iwp) ::  mg_switch_to_pe0_level = -1       !< namelist parameter
+    INTEGER(iwp) ::  mid                               !< masked output running index
+    INTEGER(iwp) ::  nlsf = 1000                       !< maximum number of profiles in LSF_DATA (large scale forcing)
+    INTEGER(iwp) ::  ntnudge = 1000                    !< maximum number of profiles in NUDGING_DATA (nudging)
+    INTEGER(iwp) ::  ngsrb = 2                         !< namelist parameter
+    INTEGER(iwp) ::  nr_timesteps_this_run = 0         !< number of timesteps (cpu time measurements)
+    INTEGER(iwp) ::  nsor = 20                         !< namelist parameter
+    INTEGER(iwp) ::  nsor_ini = 100                    !< namelist parameter
+    INTEGER(iwp) ::  n_sor                             !< number of iterations to be used in SOR-scheme
+    INTEGER(iwp) ::  normalizing_region = 0            !< namelist parameter
+    INTEGER(iwp) ::  num_leg=0                         !< number of different legs in virtual flight measurements
+    INTEGER(iwp) ::  num_var_fl                        !< number of sampling/output variables in virtual flight measurements
+    INTEGER(iwp) ::  num_var_fl_user=0                 !< number of user-defined sampling/output variables in virtual flight measurements
+    INTEGER(iwp) ::  nz_do3d = -9999                   !< namelist parameter
+    INTEGER(iwp) ::  prt_time_count = 0                !< number of output intervals for particle data output
+    INTEGER(iwp) ::  recycling_plane                   !< position of recycling plane along x (in grid points) in case of turbulence recycling
+    INTEGER(iwp) ::  runnr = 0                         !< number of run in job chain
+    INTEGER(iwp) ::  subdomain_size                    !< number of grid points in (3d) subdomain including ghost points
+    INTEGER(iwp) ::  terminate_coupled = 0             !< Siggi
+    INTEGER(iwp) ::  terminate_coupled_remote = 0      !< Siggi
+    INTEGER(iwp) ::  timestep_count = 0                !< Siggi --> is it not analogue to intermediate_timestep_count
+    INTEGER(iwp) ::  dist_nxl(0:1)                               !< left boundary of disturbance region
+    INTEGER(iwp) ::  dist_nxr(0:1)                               !< right boundary of disturbance region
+    INTEGER(iwp) ::  dist_nyn(0:1)                               !< north boundary of disturbance region
+    INTEGER(iwp) ::  dist_nys(0:1)                               !< south boundary of disturbance region
+    INTEGER(iwp) ::  do2d_no(0:1) = 0                            !< number of 2d output quantities
+    INTEGER(iwp) ::  do2d_xy_time_count(0:1)                     !< number of output intervals for 2d data (xy)
+    INTEGER(iwp) ::  do2d_xz_time_count(0:1)                     !< number of output intervals for 2d data (xz)
+    INTEGER(iwp) ::  do2d_yz_time_count(0:1)                     !< number of output intervals for 2d data (yz)
+    INTEGER(iwp) ::  do3d_no(0:1) = 0                            !< number of 3d output quantities
+    INTEGER(iwp) ::  do3d_time_count(0:1)                        !< number of output intervals for 3d data
+    INTEGER(iwp) ::  domask_no(max_masks,0:1) = 0                !< number of masked output quantities
+    INTEGER(iwp) ::  domask_time_count(max_masks,0:1)            !< number of output intervals for masked data
+    INTEGER(iwp) ::  mask_size(max_masks,3) = -1                 !< size of mask array per mask and dimension (for netcdf output)
+    INTEGER(iwp) ::  mask_size_l(max_masks,3) = -1               !< subdomain size of mask array per mask and dimension (for netcdf output)
+    INTEGER(iwp) ::  mask_start_l(max_masks,3) = -1              !< subdomain start index of mask array (for netcdf output)
+    INTEGER(iwp) ::  pt_vertical_gradient_level_ind(10) = -9999  !< grid index values of pt_vertical_gradient_level(s)
+    INTEGER(iwp) ::  q_vertical_gradient_level_ind(10) = -9999   !< grid index values of q_vertical_gradient_level(s)
+    INTEGER(iwp) ::  s_vertical_gradient_level_ind(10) = -9999   !< grid index values of s_vertical_gradient_level(s)   
+    INTEGER(iwp) ::  sa_vertical_gradient_level_ind(10) = -9999  !< grid index values of sa_vertical_gradient_level(s)
+    INTEGER(iwp) ::  section(100,3)                              !< collective array for section_xy/xz/yz
+    INTEGER(iwp) ::  section_xy(100) = -9999                     !< namelist parameter
+    INTEGER(iwp) ::  section_xz(100) = -9999                     !< namelist parameter
+    INTEGER(iwp) ::  section_yz(100) = -9999                     !< namelist parameter
+    INTEGER(iwp) ::  ug_vertical_gradient_level_ind(10) = -9999  !< grid index values of ug_vertical_gradient_level(s)
+    INTEGER(iwp) ::  vg_vertical_gradient_level_ind(10) = -9999  !< grid index values of vg_vertical_gradient_level(s)
+    INTEGER(iwp) ::  subs_vertical_gradient_level_i(10) = -9999  !< grid index values of subs_vertical_gradient_level(s)
+
+    INTEGER(iwp), DIMENSION(0:1) ::  ntdim_2d_xy  !< number of output intervals for 2d data (xy)
+    INTEGER(iwp), DIMENSION(0:1) ::  ntdim_2d_xz  !< number of output intervals for 2d data (xz)
+    INTEGER(iwp), DIMENSION(0:1) ::  ntdim_2d_yz  !< number of output intervals for 2d data (yz)
+    INTEGER(iwp), DIMENSION(0:1) ::  ntdim_3d     !< number of output intervals for 3d data
+
+    INTEGER(iwp), DIMENSION(:), ALLOCATABLE ::  grid_level_count  !< Siggi
+
+    INTEGER(iwp), DIMENSION(:,:), ALLOCATABLE ::  mask_i         !< subdomain grid index of masked output point on x-dimension
+    INTEGER(iwp), DIMENSION(:,:), ALLOCATABLE ::  mask_j         !< subdomain grid index of masked output point on y-dimension
+    INTEGER(iwp), DIMENSION(:,:), ALLOCATABLE ::  mask_k         !< subdomain grid index of masked output point on z-dimension
+    INTEGER(iwp), DIMENSION(:,:), ALLOCATABLE ::  mask_i_global  !< global grid index of masked output point on x-dimension
+    INTEGER(iwp), DIMENSION(:,:), ALLOCATABLE ::  mask_j_global  !< global grid index of masked output point on y-dimension
+    INTEGER(iwp), DIMENSION(:,:), ALLOCATABLE ::  mask_k_global  !< global grid index of masked output point on z-dimension
+
+    LOGICAL ::  bc_lr_cyc =.TRUE.                            !< left-right boundary condition cyclic?
+    LOGICAL ::  bc_lr_dirrad = .FALSE.                       !< left-right boundary condition dirichlet/radiation?
+    LOGICAL ::  bc_lr_raddir = .FALSE.                       !< left-right boundary condition radiation/dirichlet?
+    LOGICAL ::  bc_ns_cyc = .TRUE.                           !< north-south boundary condition cyclic?
+    LOGICAL ::  bc_ns_dirrad = .FALSE.                       !< north-south boundary condition dirichlet/radiation?
+    LOGICAL ::  bc_ns_raddir = .FALSE.                       !< north-south boundary condition radiation/dirichlet?
+    LOGICAL ::  call_microphysics_at_all_substeps = .FALSE.  !< namelist parameter
+    LOGICAL ::  call_psolver_at_all_substeps = .TRUE.        !< namelist parameter
+    LOGICAL ::  cloud_droplets = .FALSE.                     !< namelist parameter
+    LOGICAL ::  cloud_physics = .FALSE.                      !< namelist parameter
+    LOGICAL ::  cloud_top_radiation = .FALSE.                !< namelist parameter
+    LOGICAL ::  conserve_volume_flow = .FALSE.               !< namelist parameter
+    LOGICAL ::  constant_diffusion = .FALSE.                 !< diffusion coefficient constant?
+    LOGICAL ::  constant_flux_layer = .TRUE.                 !< namelist parameter
+    LOGICAL ::  constant_heatflux = .TRUE.                   !< heat flux at all surfaces constant?
+    LOGICAL ::  constant_top_heatflux = .TRUE.               !< heat flux at domain top constant?
+    LOGICAL ::  constant_top_momentumflux = .FALSE.          !< momentum flux at domain topconstant?
+    LOGICAL ::  constant_top_salinityflux = .TRUE.           !< salinity flux at ocean domain top?
+    LOGICAL ::  constant_top_scalarflux = .TRUE.             !< passive-scalar flux at domain top constant?
+    LOGICAL ::  constant_scalarflux = .TRUE.                 !< passive-scalar flux at surfaces constant?
+    LOGICAL ::  constant_waterflux = .TRUE.                  !< water flux at all surfaces constant?
+    LOGICAL ::  create_disturbances = .TRUE.                 !< namelist parameter
+    LOGICAL ::  data_output_2d_on_each_pe = .TRUE.           !< namelist parameter
+    LOGICAL ::  disturbance_created = .FALSE.                !< flow disturbance imposed?
+    LOGICAL ::  do2d_at_begin = .FALSE.                      !< namelist parameter
+    LOGICAL ::  do3d_at_begin = .FALSE.                      !< namelist parameter
+    LOGICAL ::  do_sum = .FALSE.                             !< contribute to time average of profile data?
+    LOGICAL ::  dp_external = .FALSE.                        !< namelist parameter
+    LOGICAL ::  dp_smooth = .FALSE.                          !< namelist parameter
+    LOGICAL ::  dt_fixed = .FALSE.                           !< fixed timestep (namelist parameter dt set)?
+    LOGICAL ::  dt_3d_reached                                !< internal timestep for particle advection
+    LOGICAL ::  dt_3d_reached_l                              !< internal timestep for particle advection
+    LOGICAL ::  exchange_mg = .FALSE.                        !< (Siggi add short description) 
+    LOGICAL ::  first_call_lpm = .TRUE.                      !< call lpm only once per timestep?
+    LOGICAL ::  force_print_header = .FALSE.                 !< namelist parameter
+    LOGICAL ::  galilei_transformation = .FALSE.             !< namelist parameter
+    LOGICAL ::  humidity = .FALSE.                           !< namelist parameter
+    LOGICAL ::  humidity_remote = .FALSE.                    !< (Siggi add short description)
+    LOGICAL ::  inflow_l = .FALSE.                           !< left domain boundary has non-cyclic inflow?
+    LOGICAL ::  inflow_n = .FALSE.                           !< north domain boundary has non-cyclic inflow?
+    LOGICAL ::  inflow_r = .FALSE.                           !< right domain boundary has non-cyclic inflow?
+    LOGICAL ::  inflow_s = .FALSE.                           !< south domain boundary has non-cyclic inflow?
+    LOGICAL ::  large_scale_forcing = .FALSE.                !< namelist parameter
+    LOGICAL ::  large_scale_subsidence = .FALSE.             !< namelist parameter
+    LOGICAL ::  land_surface = .FALSE.                       !< use land surface model?
+    LOGICAL ::  lsf_exception = .FALSE.                      !< use of lsf with buildings (temporary)?
+    LOGICAL ::  lsf_surf = .TRUE.                            !< use surface forcing (large scale forcing)?
+    LOGICAL ::  lsf_vert = .TRUE.                            !< use atmospheric forcing (large scale forcing)?
+    LOGICAL ::  masking_method = .FALSE.                     !< namelist parameter
+    LOGICAL ::  microphysics_sat_adjust = .FALSE.            !< use saturation adjust bulk scheme?
+    LOGICAL ::  microphysics_kessler = .FALSE.               !< use kessler bulk scheme?
+    LOGICAL ::  microphysics_seifert = .FALSE.               !< use 2-moment Seifert and Beheng scheme?
+    LOGICAL ::  mg_switch_to_pe0 = .FALSE.                   !< (Siggi add short description)
+    LOGICAL ::  nest_bound_l = .FALSE.                       !< nested boundary on left side?
+    LOGICAL ::  nest_bound_n = .FALSE.                       !< nested boundary on north side?
+    LOGICAL ::  nest_bound_r = .FALSE.                       !< nested boundary on right side?
+    LOGICAL ::  nest_bound_s = .FALSE.                       !< nested boundary on south side?
+    LOGICAL ::  nest_domain  = .FALSE.                       !< domain is nested into a parent domain?
+    LOGICAL ::  neutral = .FALSE.                            !< namelist parameter
+    LOGICAL ::  nudging = .FALSE.                            !< namelist parameter
+    LOGICAL ::  ocean = .FALSE.                              !< namelist parameter
+    LOGICAL ::  outflow_l = .FALSE.                          !< left domain boundary has non-cyclic outflow?
+    LOGICAL ::  outflow_n = .FALSE.                          !< north domain boundary has non-cyclic outflow?
+    LOGICAL ::  outflow_r = .FALSE.                          !< right domain boundary has non-cyclic outflow?
+    LOGICAL ::  outflow_s = .FALSE.                          !< south domain boundary has non-cyclic outflow?
+    LOGICAL ::  passive_scalar = .FALSE.                     !< namelist parameter
+    LOGICAL ::  precipitation = .FALSE.                      !< namelist parameter
+    LOGICAL ::  random_heatflux = .FALSE.                    !< namelist parameter
+    LOGICAL ::  recycling_yshift = .FALSE.                   !< namelist parameter
+    LOGICAL ::  run_control_header = .FALSE.                 !< onetime output of RUN_CONTROL header
+    LOGICAL ::  run_coupled = .TRUE.                         !< (Siggi add short description)
+    LOGICAL ::  scalar_rayleigh_damping = .TRUE.             !< namelist parameter
+    LOGICAL ::  sloping_surface = .FALSE.                    !< use sloped surface?
+                                                             !< (namelist parameter alpha_surface)
+    LOGICAL ::  stop_dt = .FALSE.                            !< (Siggi add short description)
+    LOGICAL ::  synchronous_exchange = .FALSE.               !< namelist parameter
     LOGICAL ::  synthetic_turbulence_generator = .FALSE.     !< flag for synthetic turbulence generator module
-    LOGICAL ::  terminate_run = .FALSE.                      !< 
-    LOGICAL ::  transpose_compute_overlap = .FALSE.          !< 
-    LOGICAL ::  turbulent_inflow = .FALSE.                   !< 
-    LOGICAL ::  turbulent_outflow = .FALSE.                  !< flag for turbulent outflow condition
-    LOGICAL ::  urban_surface = .FALSE.                      !< flag for urban surface model
-    LOGICAL ::  use_cmax = .TRUE.                            !< 
-    LOGICAL ::  use_initial_profile_as_reference = .FALSE.   !< 
-    LOGICAL ::  use_prescribed_profile_data = .FALSE.        !< 
-    LOGICAL ::  use_single_reference_value = .FALSE.         !< 
-    LOGICAL ::  use_subsidence_tendencies = .FALSE.          !< 
-    LOGICAL ::  use_surface_fluxes = .FALSE.                 !< 
-    LOGICAL ::  use_top_fluxes = .FALSE.                     !< 
-    LOGICAL ::  use_ug_for_galilei_tr = .TRUE.               !< 
-    LOGICAL ::  use_upstream_for_tke = .FALSE.               !< 
-    LOGICAL ::  virtual_flight = .FALSE.                     !< flag for virtual flight model
-    LOGICAL ::  wall_adjustment = .TRUE.                     !< 
-    LOGICAL ::  ws_scheme_sca = .FALSE.                      !< 
-    LOGICAL ::  ws_scheme_mom = .FALSE.                      !< 
-    LOGICAL ::  data_output_xy(0:1) = .FALSE.                !< 
-    LOGICAL ::  data_output_xz(0:1) = .FALSE.                !< 
-    LOGICAL ::  data_output_yz(0:1) = .FALSE.                !< 
-
-    REAL(wp) ::  advected_distance_x = 0.0_wp                  !< 
-    REAL(wp) ::  advected_distance_y = 0.0_wp                  !< 
-    REAL(wp) ::  alpha_surface = 0.0_wp                        !< 
-    REAL(wp) ::  atmos_ocean_sign = 1.0_wp                     !< 
-    REAL(wp) ::  averaging_interval = 0.0_wp                   !< 
-    REAL(wp) ::  averaging_interval_pr = 9999999.9_wp          !< 
-    REAL(wp) ::  bc_pt_t_val                                   !< 
-    REAL(wp) ::  bc_q_t_val                                    !< 
-    REAL(wp) ::  bc_s_t_val                                    !< 
-    REAL(wp) ::  bottom_salinityflux = 0.0_wp                  !< 
-    REAL(wp) ::  building_height = 50.0_wp                     !< 
-    REAL(wp) ::  building_length_x = 50.0_wp                   !< 
-    REAL(wp) ::  building_length_y = 50.0_wp                   !< 
-    REAL(wp) ::  building_wall_left = 9999999.9_wp             !< 
-    REAL(wp) ::  building_wall_south = 9999999.9_wp            !< 
-    REAL(wp) ::  canyon_height = 50.0_wp                       !< 
-    REAL(wp) ::  canyon_width_x = 9999999.9_wp                 !< 
-    REAL(wp) ::  canyon_width_y = 9999999.9_wp                 !< 
-    REAL(wp) ::  canyon_wall_left = 9999999.9_wp               !< 
-    REAL(wp) ::  canyon_wall_south = 9999999.9_wp              !< 
-    REAL(wp) ::  cfl_factor = -1.0_wp                          !< 
-    REAL(wp) ::  cos_alpha_surface                             !< 
-    REAL(wp) ::  coupling_start_time = 0.0_wp                  !< 
-    REAL(wp) ::  disturbance_amplitude = 0.25_wp               !< 
-    REAL(wp) ::  disturbance_energy_limit = 0.01_wp            !< 
-    REAL(wp) ::  disturbance_level_b = -9999999.9_wp           !< 
-    REAL(wp) ::  disturbance_level_t = -9999999.9_wp           !< 
-    REAL(wp) ::  dp_level_b = 0.0_wp                           !< 
-    REAL(wp) ::  dt = -1.0_wp                                  !< 
-    REAL(wp) ::  dt_averaging_input = 0.0_wp                   !< 
-    REAL(wp) ::  dt_averaging_input_pr = 9999999.9_wp          !< 
-    REAL(wp) ::  dt_coupling = 9999999.9_wp                    !< 
-    REAL(wp) ::  dt_data_output = 9999999.9_wp                 !< 
-    REAL(wp) ::  dt_data_output_av = 9999999.9_wp              !< 
-    REAL(wp) ::  dt_disturb = 9999999.9_wp                     !< 
-    REAL(wp) ::  dt_dopr = 9999999.9_wp                        !< 
-    REAL(wp) ::  dt_dopr_listing = 9999999.9_wp                !< 
-    REAL(wp) ::  dt_dopts = 9999999.9_wp                       !< 
-    REAL(wp) ::  dt_dots = 9999999.9_wp                        !< 
-    REAL(wp) ::  dt_do2d_xy = 9999999.9_wp                     !< 
-    REAL(wp) ::  dt_do2d_xz = 9999999.9_wp                     !< 
-    REAL(wp) ::  dt_do2d_yz = 9999999.9_wp                     !< 
-    REAL(wp) ::  dt_do3d = 9999999.9_wp                        !< 
-    REAL(wp) ::  dt_dvrp = 9999999.9_wp                        !< 
-    REAL(wp) ::  dt_max = 20.0_wp                              !< 
-    REAL(wp) ::  dt_restart = 9999999.9_wp                     !< 
-    REAL(wp) ::  dt_run_control = 60.0_wp                      !< 
-    REAL(wp) ::  dt_3d = 1.0_wp                                !< 
-    REAL(wp) ::  dz = -1.0_wp                                  !< 
-    REAL(wp) ::  dz_max = 9999999.9_wp                         !< 
-    REAL(wp) ::  dz_stretch_factor = 1.08_wp                   !< 
-    REAL(wp) ::  dz_stretch_level = 100000.0_wp                !< 
-    REAL(wp) ::  e_init = 0.0_wp                               !< 
-    REAL(wp) ::  e_min = 0.0_wp                                !< 
-    REAL(wp) ::  end_time = 0.0_wp                             !< 
-    REAL(wp) ::  f = 0.0_wp                                    !< 
-    REAL(wp) ::  fs = 0.0_wp                                   !< 
-    REAL(wp) ::  g = 9.81_wp                                   !< 
-    REAL(wp) ::  inflow_damping_height = 9999999.9_wp          !< 
-    REAL(wp) ::  inflow_damping_width = 9999999.9_wp           !< 
-    REAL(wp) ::  kappa = 0.4_wp                                !< 
-    REAL(wp) ::  km_constant = -1.0_wp                         !< 
-    REAL(wp) ::  mask_scale_x = 1.0_wp                         !< 
-    REAL(wp) ::  mask_scale_y = 1.0_wp                         !< 
-    REAL(wp) ::  mask_scale_z = 1.0_wp                         !< 
-    REAL(wp) ::  maximum_cpu_time_allowed = 0.0_wp             !< 
-    REAL(wp) ::  molecular_viscosity = 1.461E-5_wp             !< 
-    REAL(wp) ::  old_dt = 1.0E-10_wp                           !< 
-    REAL(wp) ::  omega = 7.29212E-5_wp                         !< 
-    REAL(wp) ::  omega_sor = 1.8_wp                            !< 
-    REAL(wp) ::  outflow_source_plane = -9999999.9_wp          !< x-position of outflow-source plane (turbulent outflow method)
-    REAL(wp) ::  particle_maximum_age = 9999999.9_wp           !< 
-    REAL(wp) ::  phi = 55.0_wp                                 !< 
-    REAL(wp) ::  prandtl_number = 1.0_wp                       !< 
-    REAL(wp) ::  precipitation_amount_interval = 9999999.9_wp  !< 
-    REAL(wp) ::  prho_reference                                !< 
-    REAL(wp) ::  pt_damping_factor = 0.0_wp                    !< 
-    REAL(wp) ::  pt_damping_width = 0.0_wp                     !< 
-    REAL(wp) ::  pt_reference = 9999999.9_wp                   !< 
-    REAL(wp) ::  pt_slope_offset = 0.0_wp                      !< 
-    REAL(wp) ::  pt_surface = 300.0_wp                         !< 
-    REAL(wp) ::  pt_surface_initial_change = 0.0_wp            !< 
-    REAL(wp) ::  q_surface = 0.0_wp                            !< 
-    REAL(wp) ::  q_surface_initial_change = 0.0_wp             !< 
-    REAL(wp) ::  rayleigh_damping_factor = -1.0_wp             !< 
-    REAL(wp) ::  rayleigh_damping_height = -1.0_wp             !< 
-    REAL(wp) ::  recycling_width = 9999999.9_wp                !< 
-    REAL(wp) ::  residual_limit = 1.0E-4_wp                    !< 
-    REAL(wp) ::  restart_time = 9999999.9_wp                   !< 
-    REAL(wp) ::  rho_reference                                 !< 
-    REAL(wp) ::  rho_surface                                   !< 
-    REAL(wp) ::  roughness_length = 0.1_wp                     !< 
-    REAL(wp) ::  sa_surface = 35.0_wp                          !< 
-    REAL(wp) ::  simulated_time = 0.0_wp                       !< 
-    REAL(wp) ::  simulated_time_at_begin                       !< 
-    REAL(wp) ::  sin_alpha_surface                             !< 
-    REAL(wp) ::  skip_time_data_output = 0.0_wp                !< 
-    REAL(wp) ::  skip_time_data_output_av = 9999999.9_wp       !< 
-    REAL(wp) ::  skip_time_dopr = 9999999.9_wp                 !< 
-    REAL(wp) ::  skip_time_do2d_xy = 9999999.9_wp              !< 
-    REAL(wp) ::  skip_time_do2d_xz = 9999999.9_wp              !< 
-    REAL(wp) ::  skip_time_do2d_yz = 9999999.9_wp              !< 
-    REAL(wp) ::  skip_time_do3d = 9999999.9_wp                 !< 
-    REAL(wp) ::  surface_heatflux = 9999999.9_wp               !< 
-    REAL(wp) ::  surface_pressure = 1013.25_wp                 !< 
-    REAL(wp) ::  surface_scalarflux = 9999999.9_wp             !< 
-    REAL(wp) ::  surface_waterflux = 9999999.9_wp              !< 
-    REAL(wp) ::  s_surface = 0.0_wp                            !< 
-    REAL(wp) ::  s_surface_initial_change = 0.0_wp             !< 
-    REAL(wp) ::  termination_time_needed = -1.0_wp             !< 
-    REAL(wp) ::  time_coupling = 0.0_wp                        !< 
-    REAL(wp) ::  time_disturb = 0.0_wp                         !< 
-    REAL(wp) ::  time_dopr = 0.0_wp                            !< 
-    REAL(wp) ::  time_dopr_av = 0.0_wp                         !< 
-    REAL(wp) ::  time_dopr_listing = 0.0_wp                    !< 
-    REAL(wp) ::  time_dopts = 0.0_wp                           !< 
-    REAL(wp) ::  time_dosp = 0.0_wp                            !< 
-    REAL(wp) ::  time_dosp_av = 0.0_wp                         !< 
-    REAL(wp) ::  time_dots = 0.0_wp                            !< 
-    REAL(wp) ::  time_do2d_xy = 0.0_wp                         !< 
-    REAL(wp) ::  time_do2d_xz = 0.0_wp                         !< 
-    REAL(wp) ::  time_do2d_yz = 0.0_wp                         !< 
-    REAL(wp) ::  time_do3d = 0.0_wp                            !< 
-    REAL(wp) ::  time_do_av = 0.0_wp                           !< 
-    REAL(wp) ::  time_do_sla = 0.0_wp                          !< 
-    REAL(wp) ::  time_dvrp = 0.0_wp                            !< 
-    REAL(wp) ::  time_restart = 9999999.9_wp                   !< 
-    REAL(wp) ::  time_run_control = 0.0_wp                     !< 
-    REAL(wp) ::  time_since_reference_point                    !< 
-    REAL(wp) ::  top_heatflux = 9999999.9_wp                   !< 
-    REAL(wp) ::  top_momentumflux_u = 9999999.9_wp             !< 
-    REAL(wp) ::  top_momentumflux_v = 9999999.9_wp             !< 
-    REAL(wp) ::  top_salinityflux = 9999999.9_wp               !< 
-    REAL(wp) ::  top_scalarflux = 9999999.9_wp                 !< 
-    REAL(wp) ::  tunnel_height = 9999999.9_wp                  !< height of tunnel outer wall
-    REAL(wp) ::  tunnel_length = 9999999.9_wp                  !< tunnel length
-    REAL(wp) ::  tunnel_width_x = 9999999.9_wp                 !< tunnel width in x, with respect to outer wall
-    REAL(wp) ::  tunnel_width_y = 9999999.9_wp                 !< tunnel width in y, with respect to outer wall
-    REAL(wp) ::  tunnel_wall_depth = 9999999.9_wp              !< tunnel wall depth
-    REAL(wp) ::  ug_surface = 0.0_wp                           !< 
-    REAL(wp) ::  u_bulk = 0.0_wp                               !< 
-    REAL(wp) ::  u_gtrans = 0.0_wp                             !< 
-    REAL(wp) ::  vg_surface = 0.0_wp                           !< 
-    REAL(wp) ::  vpt_reference = 9999999.9_wp                  !< 
-    REAL(wp) ::  v_bulk = 0.0_wp                               !< 
-    REAL(wp) ::  v_gtrans = 0.0_wp                             !< 
-    REAL(wp) ::  wall_adjustment_factor = 1.8_wp               !< 
-    REAL(wp) ::  zeta_max = 20.0_wp                            !< Maximum value of zeta = z/L
-    REAL(wp) ::  zeta_min = -20.0_wp                           !< Minimum value of zeta = z/L
-    REAL(wp) ::  z_max_do2d = -1.0_wp                          !< 
-    REAL(wp) ::  z0h_factor = 1.0_wp                           !< 
-
-    REAL(wp) ::  do2d_xy_last_time(0:1) = -1.0_wp                  !< 
-    REAL(wp) ::  do2d_xz_last_time(0:1) = -1.0_wp                  !< 
-    REAL(wp) ::  do2d_yz_last_time(0:1) = -1.0_wp                  !< 
-    REAL(wp) ::  dpdxy(1:2) = 0.0_wp                               !< 
-    REAL(wp) ::  dt_domask(max_masks) = 9999999.9_wp               !< 
-    REAL(wp) ::  mask_scale(3)                                     !< 
-    REAL(wp) ::  pt_vertical_gradient(10) = 0.0_wp                 !< 
-    REAL(wp) ::  pt_vertical_gradient_level(10) = -1.0_wp          !< 
-    REAL(wp) ::  q_vertical_gradient(10) = 0.0_wp                  !< 
-    REAL(wp) ::  q_vertical_gradient_level(10) = -1.0_wp           !< 
-    REAL(wp) ::  s_vertical_gradient(10) = 0.0_wp                  !< 
-    REAL(wp) ::  s_vertical_gradient_level(10) = -1.0_wp           !< 
-    REAL(wp) ::  sa_vertical_gradient(10) = 0.0_wp                 !< 
-    REAL(wp) ::  sa_vertical_gradient_level(10) = -1.0_wp          !< 
-    REAL(wp) ::  skip_time_domask(max_masks) = 9999999.9_wp        !< 
-    REAL(wp) ::  threshold(20) = 0.0_wp                            !< 
-    REAL(wp) ::  time_domask(max_masks) = 0.0_wp                   !< 
-    REAL(wp) ::  tsc(10) = (/ 1.0_wp, 1.0_wp, 0.0_wp, 0.0_wp, &    !< 
+    LOGICAL ::  terminate_run = .FALSE.                      !< terminate run (cpu-time limit, restarts)?
+    LOGICAL ::  transpose_compute_overlap = .FALSE.          !< namelist parameter
+    LOGICAL ::  turbulent_inflow = .FALSE.                   !< namelist parameter
+    LOGICAL ::  turbulent_outflow = .FALSE.                  !< namelist parameter
+    LOGICAL ::  urban_surface = .FALSE.                      !< use urban surface model?
+    LOGICAL ::  use_cmax = .TRUE.                            !< namelist parameter
+    LOGICAL ::  use_initial_profile_as_reference = .FALSE.   !< use of initial profiles as reference state?
+    LOGICAL ::  use_prescribed_profile_data = .FALSE.        !< use of prescribed wind profiles?
+                                                             !< (namelist parameters u_profile, v_profile)
+    LOGICAL ::  use_single_reference_value = .FALSE.         !< use of single value as reference state?
+    LOGICAL ::  use_subsidence_tendencies = .FALSE.          !< namelist parameter
+    LOGICAL ::  use_surface_fluxes = .FALSE.                 !< namelist parameter
+    LOGICAL ::  use_top_fluxes = .FALSE.                     !< namelist parameter
+    LOGICAL ::  use_ug_for_galilei_tr = .TRUE.               !< namelist parameter
+    LOGICAL ::  use_upstream_for_tke = .FALSE.               !< namelist parameter
+    LOGICAL ::  virtual_flight = .FALSE.                     !< use virtual flight model?
+    LOGICAL ::  wall_adjustment = .TRUE.                     !< namelist parameter
+    LOGICAL ::  ws_scheme_sca = .FALSE.                      !< use Wicker-Skamarock scheme (scalar advection)?
+    LOGICAL ::  ws_scheme_mom = .FALSE.                      !< use Wicker-Skamarock scheme (momentum advection)?
+    LOGICAL ::  data_output_xy(0:1) = .FALSE.                !< output of xy cross-section data?
+    LOGICAL ::  data_output_xz(0:1) = .FALSE.                !< output of xz cross-section data?
+    LOGICAL ::  data_output_yz(0:1) = .FALSE.                !< output of yz cross-section data?
+
+    REAL(wp) ::  advected_distance_x = 0.0_wp                  !< advected distance of model domain along x 
+                                                               !< (galilei transformation) 
+    REAL(wp) ::  advected_distance_y = 0.0_wp                  !< advected distance of model domain along y 
+                                                               !< (galilei transformation)
+    REAL(wp) ::  alpha_surface = 0.0_wp                        !< namelist parameter
+    REAL(wp) ::  atmos_ocean_sign = 1.0_wp                     !< vertical-grid conversion factor 
+                                                               !< (=1.0 in atmosphere, =-1.0 in ocean)
+    REAL(wp) ::  averaging_interval = 0.0_wp                   !< namelist parameter
+    REAL(wp) ::  averaging_interval_pr = 9999999.9_wp          !< namelist parameter
+    REAL(wp) ::  bc_pt_t_val                                   !< vertical gradient of pt near domain top
+    REAL(wp) ::  bc_q_t_val                                    !< vertical gradient of humidity near domain top
+    REAL(wp) ::  bc_s_t_val                                    !< vertical gradient of passive scalar near domain top
+    REAL(wp) ::  bottom_salinityflux = 0.0_wp                  !< namelist parameter
+    REAL(wp) ::  building_height = 50.0_wp                     !< namelist parameter
+    REAL(wp) ::  building_length_x = 50.0_wp                   !< namelist parameter
+    REAL(wp) ::  building_length_y = 50.0_wp                   !< namelist parameter
+    REAL(wp) ::  building_wall_left = 9999999.9_wp             !< namelist parameter
+    REAL(wp) ::  building_wall_south = 9999999.9_wp            !< namelist parameter
+    REAL(wp) ::  canyon_height = 50.0_wp                       !< namelist parameter
+    REAL(wp) ::  canyon_width_x = 9999999.9_wp                 !< namelist parameter
+    REAL(wp) ::  canyon_width_y = 9999999.9_wp                 !< namelist parameter
+    REAL(wp) ::  canyon_wall_left = 9999999.9_wp               !< namelist parameter
+    REAL(wp) ::  canyon_wall_south = 9999999.9_wp              !< namelist parameter
+    REAL(wp) ::  cfl_factor = -1.0_wp                          !< namelist parameter
+    REAL(wp) ::  cos_alpha_surface                             !< cosine of alpha_surface
+    REAL(wp) ::  coupling_start_time = 0.0_wp                  !< namelist parameter
+    REAL(wp) ::  disturbance_amplitude = 0.25_wp               !< namelist parameter
+    REAL(wp) ::  disturbance_energy_limit = 0.01_wp            !< namelist parameter
+    REAL(wp) ::  disturbance_level_b = -9999999.9_wp           !< namelist parameter
+    REAL(wp) ::  disturbance_level_t = -9999999.9_wp           !< namelist parameter
+    REAL(wp) ::  dp_level_b = 0.0_wp                           !< namelist parameter
+    REAL(wp) ::  dt = -1.0_wp                                  !< namelist parameter
+    REAL(wp) ::  dt_averaging_input = 0.0_wp                   !< namelist parameter
+    REAL(wp) ::  dt_averaging_input_pr = 9999999.9_wp          !< namelist parameter
+    REAL(wp) ::  dt_coupling = 9999999.9_wp                    !< namelist parameter
+    REAL(wp) ::  dt_data_output = 9999999.9_wp                 !< namelist parameter
+    REAL(wp) ::  dt_data_output_av = 9999999.9_wp              !< namelist parameter
+    REAL(wp) ::  dt_disturb = 9999999.9_wp                     !< namelist parameter
+    REAL(wp) ::  dt_dopr = 9999999.9_wp                        !< namelist parameter
+    REAL(wp) ::  dt_dopr_listing = 9999999.9_wp                !< namelist parameter
+    REAL(wp) ::  dt_dopts = 9999999.9_wp                       !< namelist parameter
+    REAL(wp) ::  dt_dots = 9999999.9_wp                        !< namelist parameter
+    REAL(wp) ::  dt_do2d_xy = 9999999.9_wp                     !< namelist parameter
+    REAL(wp) ::  dt_do2d_xz = 9999999.9_wp                     !< namelist parameter
+    REAL(wp) ::  dt_do2d_yz = 9999999.9_wp                     !< namelist parameter
+    REAL(wp) ::  dt_do3d = 9999999.9_wp                        !< namelist parameter
+    REAL(wp) ::  dt_dvrp = 9999999.9_wp                        !< namelist parameter
+    REAL(wp) ::  dt_max = 20.0_wp                              !< namelist parameter
+    REAL(wp) ::  dt_restart = 9999999.9_wp                     !< namelist parameter
+    REAL(wp) ::  dt_run_control = 60.0_wp                      !< namelist parameter
+    REAL(wp) ::  dt_3d = 1.0_wp                                !< time step
+    REAL(wp) ::  dz = -1.0_wp                                  !< namelist parameter
+    REAL(wp) ::  dz_max = 9999999.9_wp                         !< namelist parameter
+    REAL(wp) ::  dz_stretch_factor = 1.08_wp                   !< namelist parameter
+    REAL(wp) ::  dz_stretch_level = 100000.0_wp                !< namelist parameter
+    REAL(wp) ::  e_init = 0.0_wp                               !< namelist parameter
+    REAL(wp) ::  e_min = 0.0_wp                                !< namelist parameter
+    REAL(wp) ::  end_time = 0.0_wp                             !< namelist parameter
+    REAL(wp) ::  f = 0.0_wp                                    !< Coriolis parameter
+    REAL(wp) ::  fs = 0.0_wp                                   !< Coriolis parameter
+    REAL(wp) ::  g = 9.81_wp                                   !< gravitational acceleration
+    REAL(wp) ::  inflow_damping_height = 9999999.9_wp          !< namelist parameter
+    REAL(wp) ::  inflow_damping_width = 9999999.9_wp           !< namelist parameter
+    REAL(wp) ::  kappa = 0.4_wp                                !< von Karman constant
+    REAL(wp) ::  km_constant = -1.0_wp                         !< namelist parameter
+    REAL(wp) ::  mask_scale_x = 1.0_wp                         !< namelist parameter
+    REAL(wp) ::  mask_scale_y = 1.0_wp                         !< namelist parameter
+    REAL(wp) ::  mask_scale_z = 1.0_wp                         !< namelist parameter
+    REAL(wp) ::  maximum_cpu_time_allowed = 0.0_wp             !< given wall time for run
+    REAL(wp) ::  molecular_viscosity = 1.461E-5_wp             !< molecular viscosity (used in lsm and lpm)
+    REAL(wp) ::  old_dt = 1.0E-10_wp                           !< length of previous timestep
+    REAL(wp) ::  omega = 7.29212E-5_wp                         !< namelist parameter
+    REAL(wp) ::  omega_sor = 1.8_wp                            !< namelist parameter
+    REAL(wp) ::  outflow_source_plane = -9999999.9_wp          !< namelist parameter
+    REAL(wp) ::  particle_maximum_age = 9999999.9_wp           !< namelist parameter
+    REAL(wp) ::  phi = 55.0_wp                                 !< namelist parameter
+    REAL(wp) ::  prandtl_number = 1.0_wp                       !< namelist parameter
+    REAL(wp) ::  precipitation_amount_interval = 9999999.9_wp  !< namelist parameter
+    REAL(wp) ::  prho_reference                                !< reference state of potential density
+    REAL(wp) ::  pt_damping_factor = 0.0_wp                    !< namelist parameter
+    REAL(wp) ::  pt_damping_width = 0.0_wp                     !< namelist parameter
+    REAL(wp) ::  pt_reference = 9999999.9_wp                   !< namelist parameter
+    REAL(wp) ::  pt_slope_offset = 0.0_wp                      !< temperature difference between left and right 
+                                                               !< boundary of total domain
+    REAL(wp) ::  pt_surface = 300.0_wp                         !< namelist parameter
+    REAL(wp) ::  pt_surface_initial_change = 0.0_wp            !< namelist parameter
+    REAL(wp) ::  q_surface = 0.0_wp                            !< namelist parameter
+    REAL(wp) ::  q_surface_initial_change = 0.0_wp             !< namelist parameter
+    REAL(wp) ::  rayleigh_damping_factor = -1.0_wp             !< namelist parameter
+    REAL(wp) ::  rayleigh_damping_height = -1.0_wp             !< namelist parameter
+    REAL(wp) ::  recycling_width = 9999999.9_wp                !< namelist parameter
+    REAL(wp) ::  residual_limit = 1.0E-4_wp                    !< namelist parameter
+    REAL(wp) ::  restart_time = 9999999.9_wp                   !< namelist parameter
+    REAL(wp) ::  rho_reference                                 !< reference state of density
+    REAL(wp) ::  rho_surface                                   !< surface value of density
+    REAL(wp) ::  roughness_length = 0.1_wp                     !< namelist parameter
+    REAL(wp) ::  sa_surface = 35.0_wp                          !< namelist parameter
+    REAL(wp) ::  simulated_time = 0.0_wp                       !< elapsed simulated time
+    REAL(wp) ::  simulated_time_at_begin                       !< elapsed simulated time of previous run (job chain)
+    REAL(wp) ::  sin_alpha_surface                             !< sine of alpha_surface (sloped surface)
+    REAL(wp) ::  skip_time_data_output = 0.0_wp                !< namelist parameter
+    REAL(wp) ::  skip_time_data_output_av = 9999999.9_wp       !< namelist parameter
+    REAL(wp) ::  skip_time_dopr = 9999999.9_wp                 !< namelist parameter
+    REAL(wp) ::  skip_time_do2d_xy = 9999999.9_wp              !< namelist parameter
+    REAL(wp) ::  skip_time_do2d_xz = 9999999.9_wp              !< namelist parameter
+    REAL(wp) ::  skip_time_do2d_yz = 9999999.9_wp              !< namelist parameter
+    REAL(wp) ::  skip_time_do3d = 9999999.9_wp                 !< namelist parameter
+    REAL(wp) ::  surface_heatflux = 9999999.9_wp               !< namelist parameter
+    REAL(wp) ::  surface_pressure = 1013.25_wp                 !< namelist parameter
+    REAL(wp) ::  surface_scalarflux = 9999999.9_wp             !< namelist parameter
+    REAL(wp) ::  surface_waterflux = 9999999.9_wp              !< namelist parameter
+    REAL(wp) ::  s_surface = 0.0_wp                            !< namelist parameter
+    REAL(wp) ::  s_surface_initial_change = 0.0_wp             !< namelist parameter
+    REAL(wp) ::  termination_time_needed = -1.0_wp             !< namelist parameter
+    REAL(wp) ::  time_coupling = 0.0_wp                        !< time since last coupling (surface_coupler)
+    REAL(wp) ::  time_disturb = 0.0_wp                         !< time since last flow disturbance
+    REAL(wp) ::  time_dopr = 0.0_wp                            !< time since last profile output
+    REAL(wp) ::  time_dopr_av = 0.0_wp                         !< time since last averaged profile output
+    REAL(wp) ::  time_dopr_listing = 0.0_wp                    !< time since last profile output (ASCII) on file
+    REAL(wp) ::  time_dopts = 0.0_wp                           !< time since last particle timeseries output
+    REAL(wp) ::  time_dosp = 0.0_wp                            !< time since last spectra output
+    REAL(wp) ::  time_dosp_av = 0.0_wp                         !< time since last averaged spectra output
+    REAL(wp) ::  time_dots = 0.0_wp                            !< time since last timeseries output
+    REAL(wp) ::  time_do2d_xy = 0.0_wp                         !< time since last xy cross-section output
+    REAL(wp) ::  time_do2d_xz = 0.0_wp                         !< time since last xz cross-section output
+    REAL(wp) ::  time_do2d_yz = 0.0_wp                         !< time since last yz cross-section output
+    REAL(wp) ::  time_do3d = 0.0_wp                            !< time since last 3d output
+    REAL(wp) ::  time_do_av = 0.0_wp                           !< time since last averaged-data output
+    REAL(wp) ::  time_do_sla = 0.0_wp                          !< time since last 
+    REAL(wp) ::  time_dvrp = 0.0_wp                            !< time since last dvrp output
+    REAL(wp) ::  time_restart = 9999999.9_wp                   !< time at which run shall be terminated and restarted
+    REAL(wp) ::  time_run_control = 0.0_wp                     !< time since last RUN_CONTROL output
+    REAL(wp) ::  time_since_reference_point                    !< Siggi
+    REAL(wp) ::  top_heatflux = 9999999.9_wp                   !< namelist parameter
+    REAL(wp) ::  top_momentumflux_u = 9999999.9_wp             !< namelist parameter
+    REAL(wp) ::  top_momentumflux_v = 9999999.9_wp             !< namelist parameter
+    REAL(wp) ::  top_salinityflux = 9999999.9_wp               !< namelist parameter
+    REAL(wp) ::  top_scalarflux = 9999999.9_wp                 !< namelist parameter
+    REAL(wp) ::  tunnel_height = 9999999.9_wp                  !< namelist parameter
+    REAL(wp) ::  tunnel_length = 9999999.9_wp                  !< namelist parameter
+    REAL(wp) ::  tunnel_width_x = 9999999.9_wp                 !< namelist parameter
+    REAL(wp) ::  tunnel_width_y = 9999999.9_wp                 !< namelist parameter
+    REAL(wp) ::  tunnel_wall_depth = 9999999.9_wp              !< namelist parameter
+    REAL(wp) ::  ug_surface = 0.0_wp                           !< namelist parameter 
+    REAL(wp) ::  u_bulk = 0.0_wp                               !< namelist parameter 
+    REAL(wp) ::  u_gtrans = 0.0_wp                             !< transformed wind component (galilei transformation)
+    REAL(wp) ::  vg_surface = 0.0_wp                           !< namelist parameter
+    REAL(wp) ::  vpt_reference = 9999999.9_wp                  !< reference state of virtual potential temperature
+    REAL(wp) ::  v_bulk = 0.0_wp                               !< namelist parameter
+    REAL(wp) ::  v_gtrans = 0.0_wp                             !< transformed wind component (galilei transformation)
+    REAL(wp) ::  wall_adjustment_factor = 1.8_wp               !< adjustment factor for mixing length l
+    REAL(wp) ::  zeta_max = 20.0_wp                            !< namelist parameter
+    REAL(wp) ::  zeta_min = -20.0_wp                           !< namelist parameter
+    REAL(wp) ::  z_max_do2d = -1.0_wp                          !< namelist parameter
+    REAL(wp) ::  z0h_factor = 1.0_wp                           !< namelist parameter
+
+    REAL(wp) ::  do2d_xy_last_time(0:1) = -1.0_wp                  !< time of previous xy output
+    REAL(wp) ::  do2d_xz_last_time(0:1) = -1.0_wp                  !< time of previous xz output
+    REAL(wp) ::  do2d_yz_last_time(0:1) = -1.0_wp                  !< time of previous yz output
+    REAL(wp) ::  dpdxy(1:2) = 0.0_wp                               !< namelist parameter
+    REAL(wp) ::  dt_domask(max_masks) = 9999999.9_wp               !< namelist parameter
+    REAL(wp) ::  mask_scale(3)                                     !< collective array for mask_scale_x/y/z
+    REAL(wp) ::  pt_vertical_gradient(10) = 0.0_wp                 !< namelist parameter
+    REAL(wp) ::  pt_vertical_gradient_level(10) = -1.0_wp          !< namelist parameter
+    REAL(wp) ::  q_vertical_gradient(10) = 0.0_wp                  !< namelist parameter
+    REAL(wp) ::  q_vertical_gradient_level(10) = -1.0_wp           !< namelist parameter
+    REAL(wp) ::  s_vertical_gradient(10) = 0.0_wp                  !< namelist parameter
+    REAL(wp) ::  s_vertical_gradient_level(10) = -1.0_wp           !< namelist parameter
+    REAL(wp) ::  sa_vertical_gradient(10) = 0.0_wp                 !< namelist parameter
+    REAL(wp) ::  sa_vertical_gradient_level(10) = -1.0_wp          !< namelist parameter
+    REAL(wp) ::  skip_time_domask(max_masks) = 9999999.9_wp        !< namelist parameter
+    REAL(wp) ::  threshold(20) = 0.0_wp                            !< namelist parameter
+    REAL(wp) ::  time_domask(max_masks) = 0.0_wp                   !< namelist parameter
+    REAL(wp) ::  tsc(10) = (/ 1.0_wp, 1.0_wp, 0.0_wp, 0.0_wp, &    !< array used for controlling time-integration at different substeps
                  0.0_wp, 0.0_wp, 0.0_wp, 0.0_wp, 0.0_wp, 0.0_wp /)
-    REAL(wp) ::  u_profile(100) = 9999999.9_wp                     !< 
-    REAL(wp) ::  uv_heights(100) = 9999999.9_wp                    !< 
-    REAL(wp) ::  v_profile(100) = 9999999.9_wp                     !< 
-    REAL(wp) ::  ug_vertical_gradient(10) = 0.0_wp                 !< 
-    REAL(wp) ::  ug_vertical_gradient_level(10) = -9999999.9_wp    !< 
-    REAL(wp) ::  vg_vertical_gradient(10) = 0.0_wp                 !< 
-    REAL(wp) ::  vg_vertical_gradient_level(10) = -9999999.9_wp    !< 
-    REAL(wp) ::  volume_flow(1:3) = 0.0_wp                         !< 
-    REAL(wp) ::  volume_flow_area(1:3) = 0.0_wp                    !< 
-    REAL(wp) ::  volume_flow_initial(1:3) = 0.0_wp                 !< 
-    REAL(wp) ::  wall_heatflux(0:5) = 0.0_wp                       !< 
-    REAL(wp) ::  wall_humidityflux(0:5) = 0.0_wp                   !< 
-    REAL(wp) ::  wall_salinityflux(0:5) = 0.0_wp                   !< 
-    REAL(wp) ::  wall_scalarflux(0:5) = 0.0_wp                     !< 
-    REAL(wp) ::  subs_vertical_gradient(10) = 0.0_wp               !< 
-    REAL(wp) ::  subs_vertical_gradient_level(10) = -9999999.9_wp  !< 
-
-    REAL(wp), DIMENSION(:), ALLOCATABLE ::  dp_smooth_factor  !< 
-
-    REAL(wp), DIMENSION(max_masks,mask_xyz_dimension) ::  mask_x = -1.0_wp  !< 
-    REAL(wp), DIMENSION(max_masks,mask_xyz_dimension) ::  mask_y = -1.0_wp  !< 
-    REAL(wp), DIMENSION(max_masks,mask_xyz_dimension) ::  mask_z = -1.0_wp  !<
+    REAL(wp) ::  u_profile(100) = 9999999.9_wp                     !< namelist parameter
+    REAL(wp) ::  uv_heights(100) = 9999999.9_wp                    !< namelist parameter
+    REAL(wp) ::  v_profile(100) = 9999999.9_wp                     !< namelist parameter
+    REAL(wp) ::  ug_vertical_gradient(10) = 0.0_wp                 !< namelist parameter
+    REAL(wp) ::  ug_vertical_gradient_level(10) = -9999999.9_wp    !< namelist parameter
+    REAL(wp) ::  vg_vertical_gradient(10) = 0.0_wp                 !< namelist parameter
+    REAL(wp) ::  vg_vertical_gradient_level(10) = -9999999.9_wp    !< namelist parameter
+    REAL(wp) ::  volume_flow(1:3) = 0.0_wp                         !< Siggi
+    REAL(wp) ::  volume_flow_area(1:3) = 0.0_wp                    !< Siggi
+    REAL(wp) ::  volume_flow_initial(1:3) = 0.0_wp                 !< Siggi
+    REAL(wp) ::  wall_heatflux(0:5) = 0.0_wp                       !< namelist parameter
+    REAL(wp) ::  wall_humidityflux(0:5) = 0.0_wp                   !< namelist parameter
+    REAL(wp) ::  wall_salinityflux(0:5) = 0.0_wp                   !< namelist parameter
+    REAL(wp) ::  wall_scalarflux(0:5) = 0.0_wp                     !< namelist parameter 
+    REAL(wp) ::  subs_vertical_gradient(10) = 0.0_wp               !< namelist parameter 
+    REAL(wp) ::  subs_vertical_gradient_level(10) = -9999999.9_wp  !< namelist parameter
+
+    REAL(wp), DIMENSION(:), ALLOCATABLE ::  dp_smooth_factor  !< smoothing factor for external pressure gradient forcing
+
+    REAL(wp), DIMENSION(max_masks,mask_xyz_dimension) ::  mask_x = -1.0_wp  !< namelist parameter
+    REAL(wp), DIMENSION(max_masks,mask_xyz_dimension) ::  mask_y = -1.0_wp  !< namelist parameter
+    REAL(wp), DIMENSION(max_masks,mask_xyz_dimension) ::  mask_z = -1.0_wp  !< namelist parameter
     
-    REAL(wp), DIMENSION(max_masks,3) ::  mask_x_loop = -1.0_wp  !< 
-    REAL(wp), DIMENSION(max_masks,3) ::  mask_y_loop = -1.0_wp  !< 
-    REAL(wp), DIMENSION(max_masks,3) ::  mask_z_loop = -1.0_wp  !< 
+    REAL(wp), DIMENSION(max_masks,3) ::  mask_x_loop = -1.0_wp  !< namelist parameter
+    REAL(wp), DIMENSION(max_masks,3) ::  mask_y_loop = -1.0_wp  !< namelist parameter
+    REAL(wp), DIMENSION(max_masks,3) ::  mask_z_loop = -1.0_wp  !< namelist parameter
     
 !
 !--    internal mask arrays ("mask,dimension,selection")
-       REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  mask       !< 
-       REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  mask_loop  !< 
+       REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  mask       !< collective array for mask_x/y/z
+       REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  mask_loop  !< collective array for mask_x/y/z_loop
 
     SAVE
@@ -1408,5 +1414,5 @@
     USE kinds
 
-    CHARACTER (LEN=10) ::  dvrp_output = 'rtsp'        !< 
+    CHARACTER (LEN=10) ::  dvrp_output = 'rtsp'        !< Siggi (entire MODULE)
     CHARACTER (LEN=10) ::  particle_color = 'none'     !< 
     CHARACTER (LEN=10) ::  particle_dvrpsize = 'none'  !< 
@@ -1448,5 +1454,5 @@
     LOGICAL ::  dvrp_overlap                               !< 
     LOGICAL ::  dvrp_total_overlap                         !< 
-    LOGICAL ::  local_dvrserver_running                    !< 
+    LOGICAL ::  local_dvrserver_running                    !< internally set namelist parameter
     LOGICAL ::  lock_steering_update = .FALSE.             !< 
     LOGICAL ::  use_seperate_pe_for_dvrp_output = .FALSE.  !< 
@@ -1526,18 +1532,18 @@
     USE kinds
 
-    REAL(wp) ::  ddx          !< 
-    REAL(wp) ::  ddx2         !< 
-    REAL(wp) ::  dx = 1.0_wp  !< 
-    REAL(wp) ::  dx2          !< 
-    REAL(wp) ::  ddy          !< 
-    REAL(wp) ::  ddy2         !< 
-    REAL(wp) ::  dy = 1.0_wp  !< 
-    REAL(wp) ::  dy2          !< 
-
-    REAL(wp), DIMENSION(:), ALLOCATABLE ::  ddx2_mg  !< 
-    REAL(wp), DIMENSION(:), ALLOCATABLE ::  ddy2_mg  !< 
-
-    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  zu_s_inner  !<  
-    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  zw_w_inner  !< 
+    REAL(wp) ::  ddx          !< 1/dx
+    REAL(wp) ::  ddx2         !< 1/dx2
+    REAL(wp) ::  dx = 1.0_wp  !< horizontal grid size (along x-direction) 
+    REAL(wp) ::  dx2          !< dx*dx
+    REAL(wp) ::  ddy          !< 1/dy
+    REAL(wp) ::  ddy2         !< 1/dy2
+    REAL(wp) ::  dy = 1.0_wp  !< horizontal grid size (along y-direction)
+    REAL(wp) ::  dy2          !< dy*dy
+
+    REAL(wp), DIMENSION(:), ALLOCATABLE ::  ddx2_mg  !< 1/dx_l**2 (dx_l: grid spacing along x on different multigrid level)
+    REAL(wp), DIMENSION(:), ALLOCATABLE ::  ddy2_mg  !< 1/dy_l**2 (dy_l: grid spacing along y on different multigrid level)
+
+    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  zu_s_inner  !< height of topography top on scalar grid 
+    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  zw_w_inner  !< height of topography top on w grid 
                                               
     SAVE
@@ -1555,77 +1561,77 @@
     USE kinds
 
-    INTEGER(iwp) ::  nbgp = 3     !< 
-    INTEGER(iwp) ::  ngp_sums     !< 
-    INTEGER(iwp) ::  ngp_sums_ls  !< 
-    INTEGER(iwp) ::  nnx          !< 
-    INTEGER(iwp) ::  nx = 0       !< 
-    INTEGER(iwp) ::  nx_a         !< 
-    INTEGER(iwp) ::  nx_o         !< 
-    INTEGER(iwp) ::  nxl          !< 
-    INTEGER(iwp) ::  nxlg         !< 
-    INTEGER(iwp) ::  nxlu         !< 
-    INTEGER(iwp) ::  nxr          !< 
-    INTEGER(iwp) ::  nxrg         !< 
-    INTEGER(iwp) ::  nx_on_file   !< 
-    INTEGER(iwp) ::  nny          !< 
-    INTEGER(iwp) ::  ny = 0       !< 
-    INTEGER(iwp) ::  ny_a         !< 
-    INTEGER(iwp) ::  ny_o         !< 
-    INTEGER(iwp) ::  nyn          !< 
-    INTEGER(iwp) ::  nyng         !< 
-    INTEGER(iwp) ::  nys          !< 
-    INTEGER(iwp) ::  nysg         !< 
-    INTEGER(iwp) ::  nysv         !< 
-    INTEGER(iwp) ::  ny_on_file   !< 
-    INTEGER(iwp) ::  nnz          !< 
-    INTEGER(iwp) ::  nz = 0       !< 
-    INTEGER(iwp) ::  nzb          !< 
-    INTEGER(iwp) ::  nzb_diff     !< 
-    INTEGER(iwp) ::  nzb_max      !< 
-    INTEGER(iwp) ::  nzt          !< 
-
-    INTEGER(idp), DIMENSION(:), ALLOCATABLE ::  ngp_3d        !< 
+    INTEGER(iwp) ::  nbgp = 3     !< number of boundary ghost points
+    INTEGER(iwp) ::  ngp_sums     !< number of vertical profile grid points time number of output profiles - used for allreduce statements in MPI calls
+    INTEGER(iwp) ::  ngp_sums_ls  !< number of vertical profile grid points time number of large-scale forcing profiles - used for allreduce statements in MPI calls
+    INTEGER(iwp) ::  nnx          !< number of subdomain grid points in x-direction
+    INTEGER(iwp) ::  nx = 0       !< nx+1 = total number of grid points in x-direction
+    INTEGER(iwp) ::  nx_a         !< Siggi
+    INTEGER(iwp) ::  nx_o         !< Siggi
+    INTEGER(iwp) ::  nxl          !< left-most grid index of subdomain (excluding ghost points)
+    INTEGER(iwp) ::  nxlg         !< left-most grid index of subdomain (including ghost points)
+    INTEGER(iwp) ::  nxlu         !< =nxl+1 (at left domain boundary with inflow from left), else =nxl
+    INTEGER(iwp) ::  nxr          !< right-most grid index of subdomain (excluding ghost points)
+    INTEGER(iwp) ::  nxrg         !< right-most grid index of subdomain (including ghost points)
+    INTEGER(iwp) ::  nx_on_file   !< nx of previous run in job chain
+    INTEGER(iwp) ::  nny          !< number of subdomain grid points in y-direction
+    INTEGER(iwp) ::  ny = 0       !< ny+1 = total number of grid points in y-direction
+    INTEGER(iwp) ::  ny_a         !< Siggi
+    INTEGER(iwp) ::  ny_o         !< Siggi
+    INTEGER(iwp) ::  nyn          !< north-most grid index of subdomain (excluding ghost points)
+    INTEGER(iwp) ::  nyng         !< north-most grid index of subdomain (including ghost points)
+    INTEGER(iwp) ::  nys          !< south-most grid index of subdomain (excluding ghost points)
+    INTEGER(iwp) ::  nysg         !< south-most grid index of subdomain (including ghost points)
+    INTEGER(iwp) ::  nysv         !< =nys+1 (at south domain boundary with inflow from south), else =nys
+    INTEGER(iwp) ::  ny_on_file   !< ny of previous run in job chain
+    INTEGER(iwp) ::  nnz          !< number of subdomain grid points in z-direction
+    INTEGER(iwp) ::  nz = 0       !< total number of grid points in z-direction
+    INTEGER(iwp) ::  nzb          !< bottom grid index of computational domain
+    INTEGER(iwp) ::  nzb_diff     !< will be removed
+    INTEGER(iwp) ::  nzb_max      !< vertical index of topography top
+    INTEGER(iwp) ::  nzt          !< nzt+1 = top grid index of computational domain
+
+    INTEGER(idp), DIMENSION(:), ALLOCATABLE ::  ngp_3d        !< number of grid points of the total domain
     INTEGER(idp), DIMENSION(:), ALLOCATABLE ::  ngp_3d_inner  !< ! need to have 64 bit for grids > 2E9
                     
-    INTEGER(iwp), DIMENSION(:), ALLOCATABLE ::  ngp_2dh  !< 
-    INTEGER(iwp), DIMENSION(:), ALLOCATABLE ::  nxl_mg   !< 
-    INTEGER(iwp), DIMENSION(:), ALLOCATABLE ::  nxr_mg   !< 
-    INTEGER(iwp), DIMENSION(:), ALLOCATABLE ::  nyn_mg   !< 
-    INTEGER(iwp), DIMENSION(:), ALLOCATABLE ::  nys_mg   !< 
-    INTEGER(iwp), DIMENSION(:), ALLOCATABLE ::  nzt_mg   !< 
-
-
-    INTEGER(iwp), DIMENSION(:,:), ALLOCATABLE ::  ngp_2dh_outer     !< 
-    INTEGER(iwp), DIMENSION(:,:), ALLOCATABLE ::  ngp_2dh_s_inner   !< 
-    INTEGER(iwp), DIMENSION(:,:), ALLOCATABLE ::  mg_loc_ind        !< 
-    INTEGER(iwp), DIMENSION(:,:), ALLOCATABLE ::  nzb_diff_s_inner  !< 
-    INTEGER(iwp), DIMENSION(:,:), ALLOCATABLE ::  nzb_diff_s_outer  !< 
-    INTEGER(iwp), DIMENSION(:,:), ALLOCATABLE ::  nzb_inner         !< 
-    INTEGER(iwp), DIMENSION(:,:), ALLOCATABLE ::  nzb_outer         !< 
-    INTEGER(iwp), DIMENSION(:,:), ALLOCATABLE ::  nzb_s_inner       !< 
-    INTEGER(iwp), DIMENSION(:,:), ALLOCATABLE ::  nzb_s_outer       !< 
-    INTEGER(iwp), DIMENSION(:,:), ALLOCATABLE ::  nzb_u_inner       !< 
-    INTEGER(iwp), DIMENSION(:,:), ALLOCATABLE ::  nzb_u_outer       !< 
-    INTEGER(iwp), DIMENSION(:,:), ALLOCATABLE ::  nzb_v_inner       !< 
-    INTEGER(iwp), DIMENSION(:,:), ALLOCATABLE ::  nzb_v_outer       !< 
-    INTEGER(iwp), DIMENSION(:,:), ALLOCATABLE ::  nzb_w_inner       !< 
-    INTEGER(iwp), DIMENSION(:,:), ALLOCATABLE ::  nzb_w_outer       !< 
-
-    INTEGER(iwp), DIMENSION(:,:,:), POINTER ::  flags  !<
-
-    INTEGER(iwp), DIMENSION(:,:,:), ALLOCATABLE,  TARGET ::  wall_flags_1   !< 
-    INTEGER(iwp), DIMENSION(:,:,:), ALLOCATABLE,  TARGET ::  wall_flags_2   !< 
-    INTEGER(iwp), DIMENSION(:,:,:), ALLOCATABLE,  TARGET ::  wall_flags_3   !<
-    INTEGER(iwp), DIMENSION(:,:,:), ALLOCATABLE,  TARGET ::  wall_flags_4   !< 
-    INTEGER(iwp), DIMENSION(:,:,:), ALLOCATABLE,  TARGET ::  wall_flags_5   !< 
-    INTEGER(iwp), DIMENSION(:,:,:), ALLOCATABLE,  TARGET ::  wall_flags_6   !< 
-    INTEGER(iwp), DIMENSION(:,:,:), ALLOCATABLE,  TARGET ::  wall_flags_7   !< 
-    INTEGER(iwp), DIMENSION(:,:,:), ALLOCATABLE,  TARGET ::  wall_flags_8   !< 
-    INTEGER(iwp), DIMENSION(:,:,:), ALLOCATABLE,  TARGET ::  wall_flags_9   !< 
-    INTEGER(iwp), DIMENSION(:,:,:), ALLOCATABLE,  TARGET ::  wall_flags_10  !< 
+    INTEGER(iwp), DIMENSION(:), ALLOCATABLE ::  ngp_2dh  !< number of grid points of a horizontal cross section through the total domain
+    INTEGER(iwp), DIMENSION(:), ALLOCATABLE ::  nxl_mg   !< left-most grid index of subdomain on different multigrid level
+    INTEGER(iwp), DIMENSION(:), ALLOCATABLE ::  nxr_mg   !< right-most grid index of subdomain on different multigrid level
+    INTEGER(iwp), DIMENSION(:), ALLOCATABLE ::  nyn_mg   !< north-most grid index of subdomain on different multigrid level
+    INTEGER(iwp), DIMENSION(:), ALLOCATABLE ::  nys_mg   !< south-most grid index of subdomain on different multigrid level
+    INTEGER(iwp), DIMENSION(:), ALLOCATABLE ::  nzt_mg   !< top-most grid index of subdomain on different multigrid level
+
+
+    INTEGER(iwp), DIMENSION(:,:), ALLOCATABLE ::  ngp_2dh_outer     !< number of horizontal grid points which are non-topography and non-surface-bounded
+    INTEGER(iwp), DIMENSION(:,:), ALLOCATABLE ::  ngp_2dh_s_inner   !< number of horizontal grid points which are non-topography
+    INTEGER(iwp), DIMENSION(:,:), ALLOCATABLE ::  mg_loc_ind        !< Siggi
+    INTEGER(iwp), DIMENSION(:,:), ALLOCATABLE ::  nzb_diff_s_inner  !< will be removed
+    INTEGER(iwp), DIMENSION(:,:), ALLOCATABLE ::  nzb_diff_s_outer  !< will be removed
+    INTEGER(iwp), DIMENSION(:,:), ALLOCATABLE ::  nzb_inner         !< will be removed
+    INTEGER(iwp), DIMENSION(:,:), ALLOCATABLE ::  nzb_outer         !< will be removed
+    INTEGER(iwp), DIMENSION(:,:), ALLOCATABLE ::  nzb_s_inner       !< will be removed
+    INTEGER(iwp), DIMENSION(:,:), ALLOCATABLE ::  nzb_s_outer       !< will be removed
+    INTEGER(iwp), DIMENSION(:,:), ALLOCATABLE ::  nzb_u_inner       !< will be removed
+    INTEGER(iwp), DIMENSION(:,:), ALLOCATABLE ::  nzb_u_outer       !< will be removed
+    INTEGER(iwp), DIMENSION(:,:), ALLOCATABLE ::  nzb_v_inner       !< will be removed
+    INTEGER(iwp), DIMENSION(:,:), ALLOCATABLE ::  nzb_v_outer       !< will be removed
+    INTEGER(iwp), DIMENSION(:,:), ALLOCATABLE ::  nzb_w_inner       !< will be removed
+    INTEGER(iwp), DIMENSION(:,:), ALLOCATABLE ::  nzb_w_outer       !< will be removed
+
+    INTEGER(iwp), DIMENSION(:,:,:), POINTER ::  flags  !< pointer to wall_flags_1-10
+
+    INTEGER(iwp), DIMENSION(:,:,:), ALLOCATABLE,  TARGET ::  wall_flags_1   !< topograpyh masking flag on multigrid level 1 
+    INTEGER(iwp), DIMENSION(:,:,:), ALLOCATABLE,  TARGET ::  wall_flags_2   !< topograpyh masking flag on multigrid level 2 
+    INTEGER(iwp), DIMENSION(:,:,:), ALLOCATABLE,  TARGET ::  wall_flags_3   !< topograpyh masking flag on multigrid level 3 
+    INTEGER(iwp), DIMENSION(:,:,:), ALLOCATABLE,  TARGET ::  wall_flags_4   !< topograpyh masking flag on multigrid level 4 
+    INTEGER(iwp), DIMENSION(:,:,:), ALLOCATABLE,  TARGET ::  wall_flags_5   !< topograpyh masking flag on multigrid level 5 
+    INTEGER(iwp), DIMENSION(:,:,:), ALLOCATABLE,  TARGET ::  wall_flags_6   !< topograpyh masking flag on multigrid level 6 
+    INTEGER(iwp), DIMENSION(:,:,:), ALLOCATABLE,  TARGET ::  wall_flags_7   !< topograpyh masking flag on multigrid level 7 
+    INTEGER(iwp), DIMENSION(:,:,:), ALLOCATABLE,  TARGET ::  wall_flags_8   !< topograpyh masking flag on multigrid level 8 
+    INTEGER(iwp), DIMENSION(:,:,:), ALLOCATABLE,  TARGET ::  wall_flags_9   !< topograpyh masking flag on multigrid level 9 
+    INTEGER(iwp), DIMENSION(:,:,:), ALLOCATABLE,  TARGET ::  wall_flags_10  !< topograpyh masking flag on multigrid level 10 
 
     INTEGER(iwp), DIMENSION(:,:,:), ALLOCATABLE ::  advc_flags_1            !< flags used to degrade order of advection scheme
     INTEGER(iwp), DIMENSION(:,:,:), ALLOCATABLE ::  advc_flags_2            !< flags used to degrade order of advection scheme
-    INTEGER(iwp), DIMENSION(:,:,:), ALLOCATABLE ::  wall_flags_0            !< flags to mask topography
+    INTEGER(iwp), DIMENSION(:,:,:), ALLOCATABLE ::  wall_flags_0            !< flags to mask topography and surface-bounded grid points
 
     SAVE
@@ -1653,5 +1659,5 @@
           USE kinds
 
-          CHARACTER (LEN=*), INTENT(IN) ::  mode                     !< 
+          CHARACTER (LEN=*), INTENT(IN) ::  mode                     !< Siggi (entire module, some variables are still in German)
           INTEGER(iwp), INTENT(IN)      ::  i1                       !< 
           INTEGER(iwp), INTENT(IN)      ::  i2                       !< 
@@ -1695,9 +1701,9 @@
           USE kinds
 
-          CHARACTER (LEN=*), INTENT(IN) ::  sk_char  !< 
+          CHARACTER (LEN=*), INTENT(IN) ::  sk_char  !< string for treated scalar in Bott-Chlond scheme
 #if defined( __nopointer )
-          REAL(wp), DIMENSION(:,:,:) ::  sk  !< 
+          REAL(wp), DIMENSION(:,:,:) ::  sk  !< treated scalar array in Bott-Chlond scheme
 #else
-          REAL(wp), DIMENSION(:,:,:), POINTER ::  sk  !< 
+          REAL(wp), DIMENSION(:,:,:), POINTER ::  sk  !< treated scalar array in Bott-Chlond scheme
 #endif
        END SUBROUTINE advec_s_bc
@@ -1719,46 +1725,46 @@
     USE kinds
 
-    INTEGER(iwp) ::  current_timestep_number_1d = 0  !< 
-    INTEGER(iwp) ::  damp_level_ind_1d               !< 
-
-    LOGICAL ::  run_control_header_1d = .FALSE.  !< 
-    LOGICAL ::  stop_dt_1d = .FALSE.             !< 
-
-    REAL(wp) ::  damp_level_1d = -1.0_wp       !< 
-    REAL(wp) ::  dt_1d = 60.0_wp               !< 
-    REAL(wp) ::  dt_max_1d = 300.0_wp          !< 
-    REAL(wp) ::  dt_pr_1d = 9999999.9_wp       !< 
-    REAL(wp) ::  dt_run_control_1d = 60.0_wp   !< 
-    REAL(wp) ::  end_time_1d = 864000.0_wp     !< 
-    REAL(wp) ::  old_dt_1d = 1.0E-10_wp        !< 
-    REAL(wp) ::  qs1d                          !< 
-    REAL(wp) ::  simulated_time_1d = 0.0_wp    !< 
-    REAL(wp) ::  time_pr_1d = 0.0_wp           !< 
-    REAL(wp) ::  time_run_control_1d = 0.0_wp  !< 
-    REAL(wp) ::  ts1d                          !< 
-    REAL(wp) ::  us1d                          !< 
-    REAL(wp) ::  usws1d                        !< 
-    REAL(wp) ::  vsws1d                        !<               
-    REAL(wp) ::  z01d                          !< 
-    REAL(wp) ::  z0h1d                         !< 
-
-
-    REAL(wp), DIMENSION(:), ALLOCATABLE ::  e1d      !< 
-    REAL(wp), DIMENSION(:), ALLOCATABLE ::  e1d_p    !< 
-    REAL(wp), DIMENSION(:), ALLOCATABLE ::  kh1d     !< 
-    REAL(wp), DIMENSION(:), ALLOCATABLE ::  km1d     !< 
-    REAL(wp), DIMENSION(:), ALLOCATABLE ::  l_black  !< 
-    REAL(wp), DIMENSION(:), ALLOCATABLE ::  l1d      !< 
-    REAL(wp), DIMENSION(:), ALLOCATABLE ::  rif1d    !< 
-    REAL(wp), DIMENSION(:), ALLOCATABLE ::  te_e     !< 
-    REAL(wp), DIMENSION(:), ALLOCATABLE ::  te_em    !< 
-    REAL(wp), DIMENSION(:), ALLOCATABLE ::  te_u     !< 
-    REAL(wp), DIMENSION(:), ALLOCATABLE ::  te_um    !< 
-    REAL(wp), DIMENSION(:), ALLOCATABLE ::  te_v     !< 
-    REAL(wp), DIMENSION(:), ALLOCATABLE ::  te_vm    !< 
-    REAL(wp), DIMENSION(:), ALLOCATABLE ::  u1d      !< 
-    REAL(wp), DIMENSION(:), ALLOCATABLE ::  u1d_p    !< 
-    REAL(wp), DIMENSION(:), ALLOCATABLE ::  v1d      !< 
-    REAL(wp), DIMENSION(:), ALLOCATABLE ::  v1d_p    !< 
+    INTEGER(iwp) ::  current_timestep_number_1d = 0  !< current timestep number (1d-model)
+    INTEGER(iwp) ::  damp_level_ind_1d               !< lower grid index of damping layer (1d-model)
+
+    LOGICAL ::  run_control_header_1d = .FALSE.  !< flag for output of run control header (1d-model)
+    LOGICAL ::  stop_dt_1d = .FALSE.             !< termination flag, used in case of too small timestep (1d-model)
+
+    REAL(wp) ::  damp_level_1d = -1.0_wp       !< namelist parameter
+    REAL(wp) ::  dt_1d = 60.0_wp               !< dynamic timestep (1d-model)
+    REAL(wp) ::  dt_max_1d = 300.0_wp          !< timestep limit (1d-model)
+    REAL(wp) ::  dt_pr_1d = 9999999.9_wp       !< namelist parameter
+    REAL(wp) ::  dt_run_control_1d = 60.0_wp   !< namelist parameter
+    REAL(wp) ::  end_time_1d = 864000.0_wp     !< namelist parameter
+    REAL(wp) ::  old_dt_1d = 1.0E-10_wp        !< previous timestep (1d-model)
+    REAL(wp) ::  qs1d                          !< characteristic humidity scale (1d-model)
+    REAL(wp) ::  simulated_time_1d = 0.0_wp    !< updated simulated time (1d-model)
+    REAL(wp) ::  time_pr_1d = 0.0_wp           !< updated simulated time for profile output (1d-model)
+    REAL(wp) ::  time_run_control_1d = 0.0_wp  !< updated simulated time for run-control output (1d-model)
+    REAL(wp) ::  ts1d                          !< characteristic temperature scale (1d-model)
+    REAL(wp) ::  us1d                          !< friction velocity (1d-model)
+    REAL(wp) ::  usws1d                        !< u-component of the momentum flux (1d-model)
+    REAL(wp) ::  vsws1d                        !< v-component of the momentum flux (1d-model)    
+    REAL(wp) ::  z01d                          !< roughness length for momentum (1d-model)
+    REAL(wp) ::  z0h1d                         !< roughness length for scalars (1d-model)
+
+
+    REAL(wp), DIMENSION(:), ALLOCATABLE ::  e1d      !< tke (1d-model)
+    REAL(wp), DIMENSION(:), ALLOCATABLE ::  e1d_p    !< prognostic value of tke (1d-model)
+    REAL(wp), DIMENSION(:), ALLOCATABLE ::  kh1d     !< turbulent diffusion coefficient for heat (1d-model)
+    REAL(wp), DIMENSION(:), ALLOCATABLE ::  km1d     !< turbulent diffusion coefficient for momentum (1d-model)
+    REAL(wp), DIMENSION(:), ALLOCATABLE ::  l_black  !< mixing length Blackadar (1d-model)
+    REAL(wp), DIMENSION(:), ALLOCATABLE ::  l1d      !< mixing length (1d-model)
+    REAL(wp), DIMENSION(:), ALLOCATABLE ::  rif1d    !< Richardson flux number (1d-model)
+    REAL(wp), DIMENSION(:), ALLOCATABLE ::  te_e     !< Tobias (1d-model)
+    REAL(wp), DIMENSION(:), ALLOCATABLE ::  te_em    !< Tobias (1d-model)
+    REAL(wp), DIMENSION(:), ALLOCATABLE ::  te_u     !< Tobias (1d-model)
+    REAL(wp), DIMENSION(:), ALLOCATABLE ::  te_um    !< Tobias (1d-model)
+    REAL(wp), DIMENSION(:), ALLOCATABLE ::  te_v     !< Tobias (1d-model)
+    REAL(wp), DIMENSION(:), ALLOCATABLE ::  te_vm    !< Tobias (1d-model)
+    REAL(wp), DIMENSION(:), ALLOCATABLE ::  u1d      !< u-velocity component (1d-model)
+    REAL(wp), DIMENSION(:), ALLOCATABLE ::  u1d_p    !< prognostic value of u-velocity component (1d-model)
+    REAL(wp), DIMENSION(:), ALLOCATABLE ::  v1d      !< v-velocity component (1d-model)
+    REAL(wp), DIMENSION(:), ALLOCATABLE ::  v1d_p    !< prognostic value of v-velocity component (1d-model)
 
     SAVE
@@ -1787,85 +1793,85 @@
 #endif
 #endif
-    CHARACTER(LEN=2) ::  send_receive = 'al'
-    CHARACTER(LEN=7) ::  myid_char = ''
+    CHARACTER(LEN=2) ::  send_receive = 'al'     !< Siggi
+    CHARACTER(LEN=7) ::  myid_char = ''          !< character string containing processor id number
     
-    INTEGER(iwp) ::  comm1dx                     !< 
-    INTEGER(iwp) ::  comm1dy                     !< 
-    INTEGER(iwp) ::  comm2d                      !< 
-    INTEGER(iwp) ::  comm_inter                  !< 
-    INTEGER(iwp) ::  comm_palm                   !< 
-    INTEGER(iwp) ::  id_inflow = 0               !< 
+    INTEGER(iwp) ::  comm1dx                     !< Siggi
+    INTEGER(iwp) ::  comm1dy                     !< Siggi
+    INTEGER(iwp) ::  comm2d                      !< Siggi
+    INTEGER(iwp) ::  comm_inter                  !< Siggi
+    INTEGER(iwp) ::  comm_palm                   !< Siggi
+    INTEGER(iwp) ::  id_inflow = 0               !< myidx of procs at inflow (turbulent inflow method)
     INTEGER(iwp) ::  id_outflow = 0              !< myidx of procs at outflow (turbulent outflow method)
     INTEGER(iwp) ::  id_outflow_source = 0       !< myidx of procs including ouflow source plane (turbulent outflow method)
-    INTEGER(iwp) ::  id_recycling = 0            !< 
-    INTEGER(iwp) ::  ierr                        !< 
-    INTEGER(iwp) ::  myid = 0                    !< 
-    INTEGER(iwp) ::  myidx = 0                   !< 
-    INTEGER(iwp) ::  myidy = 0                   !< 
-    INTEGER(iwp) ::  ndim = 2                    !< 
-    INTEGER(iwp) ::  ngp_a                       !<
-    INTEGER(iwp) ::  ngp_o                       !<
-    INTEGER(iwp) ::  ngp_xy                      !< 
-    INTEGER(iwp) ::  ngp_y                       !< 
-    INTEGER(iwp) ::  npex = -1                   !< 
-    INTEGER(iwp) ::  npey = -1                   !< 
-    INTEGER(iwp) ::  numprocs = 1                !< 
-    INTEGER(iwp) ::  numprocs_previous_run = -1  !< 
-    INTEGER(iwp) ::  pleft                       !< 
-    INTEGER(iwp) ::  pnorth                      !< 
-    INTEGER(iwp) ::  pright                      !< 
-    INTEGER(iwp) ::  psouth                      !< 
-    INTEGER(iwp) ::  req_count = 0               !< 
-    INTEGER(iwp) ::  sendrecvcount_xy            !< 
-    INTEGER(iwp) ::  sendrecvcount_yz            !< 
-    INTEGER(iwp) ::  sendrecvcount_zx            !< 
-    INTEGER(iwp) ::  sendrecvcount_zyd           !< 
-    INTEGER(iwp) ::  sendrecvcount_yxd           !< 
-    INTEGER(iwp) ::  target_id                   !< 
-    INTEGER(iwp) ::  tasks_per_node = -9999      !< 
-    INTEGER(iwp) ::  threads_per_task = 1        !< 
-    INTEGER(iwp) ::  type_x                      !< 
-    INTEGER(iwp) ::  type_xy                     !< 
-    INTEGER(iwp) ::  type_y                      !< 
-
-    INTEGER(iwp) ::  pdims(2) = 1  !< 
-    INTEGER(iwp) ::  req(100)      !< 
-
-    INTEGER(iwp), DIMENSION(:,:), ALLOCATABLE ::  hor_index_bounds               !< 
-    INTEGER(iwp), DIMENSION(:,:), ALLOCATABLE ::  hor_index_bounds_previous_run  !< 
-
-    LOGICAL ::  collective_wait = .FALSE.          !< 
-    LOGICAL ::  sendrecv_in_background = .FALSE.   !< 
+    INTEGER(iwp) ::  id_recycling = 0            !< myidx of procs containing the recycling plane (turbulence recycling method)
+    INTEGER(iwp) ::  ierr                        !< Siggi
+    INTEGER(iwp) ::  myid = 0                    !< id number of processor element
+    INTEGER(iwp) ::  myidx = 0                   !< id number of processor elements with same position along x-direction
+    INTEGER(iwp) ::  myidy = 0                   !< id number of processor elements with same position along y-direction
+    INTEGER(iwp) ::  ndim = 2                    !< Siggi
+    INTEGER(iwp) ::  ngp_a                       !< number of grid points in atmosphere domain   Siggi
+    INTEGER(iwp) ::  ngp_o                       !< number of grid points in ocean domain   Siggi
+    INTEGER(iwp) ::  ngp_xy                      !< number of grid points at atmosphere-ocean interface   Siggi   
+    INTEGER(iwp) ::  ngp_y                       !< Siggi
+    INTEGER(iwp) ::  npex = -1                   !< number of processor elements in x-direction
+    INTEGER(iwp) ::  npey = -1                   !< number of processor elements in y-direction
+    INTEGER(iwp) ::  numprocs = 1                !< total number of appointed processor elements
+    INTEGER(iwp) ::  numprocs_previous_run = -1  !< total number of appointed processor elements in previous run (job chain)
+    INTEGER(iwp) ::  pleft                       !< MPI-address of the processor left of the current one
+    INTEGER(iwp) ::  pnorth                      !< MPI-address of the processor north of the current one
+    INTEGER(iwp) ::  pright                      !< MPI-address of the processor right of the current one
+    INTEGER(iwp) ::  psouth                      !< MPI-address of the processor south of the current one
+    INTEGER(iwp) ::  req_count = 0               !< MPI return variable - checks if Send-Receive operation is already finished
+    INTEGER(iwp) ::  sendrecvcount_xy            !< Siggi
+    INTEGER(iwp) ::  sendrecvcount_yz            !< Siggi
+    INTEGER(iwp) ::  sendrecvcount_zx            !< Siggi
+    INTEGER(iwp) ::  sendrecvcount_zyd           !< Siggi
+    INTEGER(iwp) ::  sendrecvcount_yxd           !< Siggi
+    INTEGER(iwp) ::  target_id                   !< Siggi
+    INTEGER(iwp) ::  tasks_per_node = -9999      !< MPI tasks per computing node 
+    INTEGER(iwp) ::  threads_per_task = 1        !< OPENMP threads per MPI task
+    INTEGER(iwp) ::  type_x                      !< derived MPI datatype for 2-D ghost-point exchange - north / south 
+    INTEGER(iwp) ::  type_xy                     !< derived MPI datatype for 2-D ghost-point exchange - north / south 
+    INTEGER(iwp) ::  type_y                      !< derived MPI datatype for 2-D exchange in atmosphere-ocean coupler 
+
+    INTEGER(iwp) ::  pdims(2) = 1  !< number of processors along x-y dimension
+    INTEGER(iwp) ::  req(100)      !< MPI return variable indicating if send-receive operation is finished
+
+    INTEGER(iwp), DIMENSION(:,:), ALLOCATABLE ::  hor_index_bounds               !< horizontal index bounds 
+    INTEGER(iwp), DIMENSION(:,:), ALLOCATABLE ::  hor_index_bounds_previous_run  !< horizontal index bounds of previous run
+
+    LOGICAL ::  collective_wait = .FALSE.          !< Siggi
+    LOGICAL ::  sendrecv_in_background = .FALSE.   !< Siggi
 
 #if defined( __parallel )
 #if defined( __mpi2 )
-    CHARACTER (LEN=MPI_MAX_PORT_NAME) ::  port_name  !< 
+    CHARACTER (LEN=MPI_MAX_PORT_NAME) ::  port_name  !< Siggi
 #endif
 
-    INTEGER(iwp) ::  ibuf(12)                 !< 
-    INTEGER(iwp) ::  pcoord(2)                !< 
-    INTEGER(iwp) ::  status(MPI_STATUS_SIZE)  !< 
+    INTEGER(iwp) ::  ibuf(12)                 !< Siggi
+    INTEGER(iwp) ::  pcoord(2)                !< Siggi
+    INTEGER(iwp) ::  status(MPI_STATUS_SIZE)  !< Siggi
     
-    INTEGER(iwp), DIMENSION(MPI_STATUS_SIZE,100) ::  wait_stat  !< 
+    INTEGER(iwp), DIMENSION(MPI_STATUS_SIZE,100) ::  wait_stat  !< Siggi
     
-    INTEGER(iwp) ::  ngp_yz_int   !< 
-    INTEGER(iwp) ::  type_xz_int  !< 
-    INTEGER(iwp) ::  type_yz_int  !< 
-
-    INTEGER(iwp), DIMENSION(:), ALLOCATABLE ::  ngp_xz      !< 
-    INTEGER(iwp), DIMENSION(:), ALLOCATABLE ::  ngp_yz      !< 
-    INTEGER(iwp), DIMENSION(:), ALLOCATABLE ::  type_x_int  !< 
-    INTEGER(iwp), DIMENSION(:), ALLOCATABLE ::  type_xz     !< 
-    INTEGER(iwp), DIMENSION(:), ALLOCATABLE ::  type_y_int  !< 
-    INTEGER(iwp), DIMENSION(:), ALLOCATABLE ::  type_yz     !< 
-
-    LOGICAL ::  left_border_pe  = .FALSE.  !< 
-    LOGICAL ::  north_border_pe = .FALSE.  !< 
-    LOGICAL ::  reorder = .TRUE.           !< 
-    LOGICAL ::  right_border_pe = .FALSE.  !< 
-    LOGICAL ::  south_border_pe = .FALSE.  !< 
-
-    LOGICAL, DIMENSION(2) ::  cyclic = (/ .TRUE. , .TRUE. /)  !< 
-    LOGICAL, DIMENSION(2) ::  remain_dims                     !< 
+    INTEGER(iwp) ::  ngp_yz_int   !< number of ghost points in yz-plane 
+    INTEGER(iwp) ::  type_xz_int  !< derived MPI datatype for 3-D integer ghost-point exchange - north / south
+    INTEGER(iwp) ::  type_yz_int  !< derived MPI datatype for 3-D integer ghost-point exchange - left / right
+
+    INTEGER(iwp), DIMENSION(:), ALLOCATABLE ::  ngp_xz      !< number of ghost points in xz-plane on different multigrid level
+    INTEGER(iwp), DIMENSION(:), ALLOCATABLE ::  ngp_yz      !< number of ghost points in yz-plane on different multigrid level
+    INTEGER(iwp), DIMENSION(:), ALLOCATABLE ::  type_x_int  !< derived MPI datatype for 2-D integer ghost-point exchange - north / south
+    INTEGER(iwp), DIMENSION(:), ALLOCATABLE ::  type_xz     !< derived MPI datatype for 3-D integer ghost-point exchange - north / south
+    INTEGER(iwp), DIMENSION(:), ALLOCATABLE ::  type_y_int  !< derived MPI datatype for 2-D integer ghost-point exchange - left / right
+    INTEGER(iwp), DIMENSION(:), ALLOCATABLE ::  type_yz     !< derived MPI datatype for 3-D integer ghost-point exchange - left / right 
+
+    LOGICAL ::  left_border_pe  = .FALSE.  !< = .TRUE. if PE is on left border of computational domain
+    LOGICAL ::  north_border_pe = .FALSE.  !< = .TRUE. if PE is on north border of computational domain
+    LOGICAL ::  reorder = .TRUE.           !< Siggi
+    LOGICAL ::  right_border_pe = .FALSE.  !< = .TRUE. if PE is on right border of computational domain
+    LOGICAL ::  south_border_pe = .FALSE.  !< = .TRUE. if PE is on south border of computational domain
+
+    LOGICAL, DIMENSION(2) ::  cyclic = (/ .TRUE. , .TRUE. /)  !< Siggi
+    LOGICAL, DIMENSION(2) ::  remain_dims                     !< Siggi
 #endif
 
@@ -1884,5 +1890,5 @@
     USE kinds
 
-    INTEGER(iwp), PARAMETER ::  crmax = 100  !< 
+    INTEGER(iwp), PARAMETER ::  crmax = 100  !< Siggi (entire module)
 
     CHARACTER (LEN=20), DIMENSION(20) ::  cross_ts_profiles = &  !< 
@@ -1942,48 +1948,50 @@
     USE kinds
 
-    CHARACTER (LEN=40) ::  region(0:9)  !< 
+    CHARACTER (LEN=40) ::  region(0:9)  !< label for statistic region
     
-    INTEGER(iwp) ::  pr_palm = 130          !< 
-    INTEGER(iwp) ::  statistic_regions = 0  !< 
+    INTEGER(iwp) ::  pr_palm = 130          !< maximum number of output profiles
+    INTEGER(iwp) ::  statistic_regions = 0  !< identifier for statistic regions
     
-    INTEGER(iwp) ::  u_max_ijk(3) = -1  !< 
-    INTEGER(iwp) ::  v_max_ijk(3) = -1  !< 
-    INTEGER(iwp) ::  w_max_ijk(3) = -1  !< 
+    INTEGER(iwp) ::  u_max_ijk(3) = -1  !< index values (i,j,k) of location where u_max occurs
+    INTEGER(iwp) ::  v_max_ijk(3) = -1  !< index values (i,j,k) of location where v_max occurs
+    INTEGER(iwp) ::  w_max_ijk(3) = -1  !< index values (i,j,k) of location where w_max occurs
     
-    LOGICAL ::  flow_statistics_called = .FALSE.  !< 
+    LOGICAL ::  flow_statistics_called = .FALSE.  !< flag that tells other routines if flow statistics was executed
+                                                  !< (after each timestep)
     
-    REAL(wp) ::  u_max  !< 
-    REAL(wp) ::  v_max  !< 
-    REAL(wp) ::  w_max  !< 
+    REAL(wp) ::  u_max  !< maximum of absolute u-veloctiy in entire domain
+    REAL(wp) ::  v_max  !< maximum of absolute v-veloctiy in entire domain
+    REAL(wp) ::  w_max  !< maximum of absolute w-veloctiy in entire domain
     
-    REAL(wp), DIMENSION(:), ALLOCATABLE ::  mean_surface_level_height  !< 
-    REAL(wp), DIMENSION(:), ALLOCATABLE ::  sums_divnew_l              !< 
-    REAL(wp), DIMENSION(:), ALLOCATABLE ::  sums_divold_l              !< 
-    REAL(wp), DIMENSION(:), ALLOCATABLE ::  weight_substep             !< 
-    REAL(wp), DIMENSION(:), ALLOCATABLE ::  weight_pres                !< 
+    REAL(wp), DIMENSION(:), ALLOCATABLE ::  mean_surface_level_height  !< Siggi
+    REAL(wp), DIMENSION(:), ALLOCATABLE ::  sums_divnew_l              !< subdomain sum (_l) of divergence after pressure 
+                                                                       !< solver call (new)
+    REAL(wp), DIMENSION(:), ALLOCATABLE ::  sums_divold_l              !< subdomain sum (_l) of divergence before pressure
+                                                                       !< solver call (old)
+    REAL(wp), DIMENSION(:), ALLOCATABLE ::  weight_substep             !< weighting factor for substeps in timestepping
+    REAL(wp), DIMENSION(:), ALLOCATABLE ::  weight_pres                !< substep weighting factor for pressure solver
     
-    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  sums             !< 
-    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  sums_wsts_bc_l   !< 
-    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  ts_value         !< 
-    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  sums_wsus_ws_l   !< 
-    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  sums_wsvs_ws_l   !< 
-    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  sums_us2_ws_l    !< 
-    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  sums_vs2_ws_l    !< 
-    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  sums_ws2_ws_l    !< 
-    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  sums_wsnrs_ws_l  !< 
-    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  sums_wspts_ws_l  !< 
-    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  sums_wsqs_ws_l   !< 
-    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  sums_wsqrs_ws_l  !< 
-    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  sums_wssas_ws_l  !< 
-    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  sums_wsss_ws_l   !< 
-    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  sums_ls_l        !< 
+    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  sums             !< global sum array for the various output quantities
+    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  sums_wsts_bc_l   !< subdomain sum of sensible heat flux in Bott-Chlond scheme
+    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  ts_value         !< timeseries output array for the various output quantities
+    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  sums_wsus_ws_l   !< subdomain sum of vertical momentum flux w'u' (5th-order advection scheme only)
+    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  sums_wsvs_ws_l   !< subdomain sum of vertical momentum flux w'v' (5th-order advection scheme only)
+    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  sums_us2_ws_l    !< subdomain sum of horizontal momentum flux u'u' (5th-order advection scheme only)
+    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  sums_vs2_ws_l    !< subdomain sum of horizontal momentum flux v'v' (5th-order advection scheme only)
+    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  sums_ws2_ws_l    !< subdomain sum of vertical momentum flux w'w' (5th-order advection scheme only)
+    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  sums_wsnrs_ws_l  !< subdomain sum of vertical raindrop-number concentration flux w'nr' (5th-order advection scheme only)
+    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  sums_wspts_ws_l  !< subdomain sum of vertical sensible heat flux w'pt' (5th-order advection scheme only)
+    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  sums_wsqs_ws_l   !< subdomain sum of vertical latent heat flux w'q' (5th-order advection scheme only)
+    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  sums_wsqrs_ws_l  !< subdomain sum of vertical rainwater flux w'qr' (5th-order advection scheme only)
+    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  sums_wssas_ws_l  !< subdomain sum of vertical salinity flux w'sa' (5th-order advection scheme only)
+    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  sums_wsss_ws_l   !< subdomain sum of vertical passive scalar flux w's' (5th-order advection scheme only)
+    REAL(wp), DIMENSION(:,:), ALLOCATABLE ::  sums_ls_l        !< subdomain sum of large scale forcing and nudging tendencies
                                               
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  hom_sum             !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  rmask               !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  sums_l              !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  sums_l_l            !< 
-    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  sums_up_fraction_l  !< 
-
-    REAL(wp), DIMENSION(:,:,:,:), ALLOCATABLE ::  hom  !< 
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  hom_sum             !< sum array for horizontal mean
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  rmask               !< REAL flag array (0.0 or 1.0) for statistic regions
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  sums_l              !< subdomain sum (_l) gathered for various quantities
+    REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  sums_l_l            !< subdomain sum (_l) of mixing length from diffusivities
+
+    REAL(wp), DIMENSION(:,:,:,:), ALLOCATABLE ::  hom  !< horizontal mean of various quantities (profiles/timeseries)
 
     SAVE
@@ -2002,5 +2010,5 @@
     USE kinds
 
-    INTEGER(iwp) ::  nxl_y   !< 
+    INTEGER(iwp) ::  nxl_y   !< Siggi (entire module)
     INTEGER(iwp) ::  nxl_yd  !< 
     INTEGER(iwp) ::  nxl_z   !< 
Index: /palm/trunk/SOURCE/nudging_mod.f90
===================================================================
--- /palm/trunk/SOURCE/nudging_mod.f90	(revision 2276)
+++ /palm/trunk/SOURCE/nudging_mod.f90	(revision 2277)
@@ -25,4 +25,7 @@
 ! -----------------
 ! $Id$
+! Removed unused variables lptnudge, lqnudge, lunudge, lvnudge, lwnudge
+! 
+! 2271 2017-06-09 12:34:55Z sward
 ! Error message changed
 ! 
@@ -130,6 +133,5 @@
 
        USE control_parameters,                                                 &
-           ONLY:  dt_3d, lptnudge, lqnudge, lunudge, lvnudge, lwnudge,         &
-                   message_string, ntnudge
+           ONLY:  dt_3d, message_string, ntnudge
 
        USE indices,                                                            &
@@ -266,12 +268,4 @@
        CLOSE ( finput )
 
-!
-!--    Prevent nudging if nudging profiles exhibt too small values
-!--    not used so far
-       lptnudge  = ANY( ABS( ptnudge ) > 1.0e-8_wp )
-       lqnudge   = ANY( ABS( qnudge )  > 1.0e-8_wp )
-       lunudge   = ANY( ABS( unudge )  > 1.0e-8_wp )
-       lvnudge   = ANY( ABS( vnudge )  > 1.0e-8_wp )
-       lwnudge   = ANY( ABS( wnudge )  > 1.0e-8_wp )
 
     END SUBROUTINE init_nudge
