Changeset 4648 for palm/trunk/SOURCE/lagrangian_particle_model_mod.f90

Timestamp:

Aug 25, 2020 7:52:08 AM (4 years ago)

Author:

raasch

Message:

files re-formatted to follow the PALM coding standard

File:

• palm/trunk/SOURCE/lagrangian_particle_model_mod.f90 (modified) (371 diffs)

palm/trunk/SOURCE/lagrangian_particle_model_mod.f90

@@ -1 +1 @@
 !> @file lagrangian_particle_model_mod.f90
-!------------------------------------------------------------------------------!
+!--------------------------------------------------------------------------------------------------!
 ! This file is part of the PALM model system.
 !
-! PALM is free software: you can redistribute it and/or modify it under the
-! terms of the GNU General Public License as published by the Free Software
-! Foundation, either version 3 of the License, or (at your option) any later
-! version.
-!
-! PALM is distributed in the hope that it will be useful, but WITHOUT ANY
-! WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
-! A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
-!
-! You should have received a copy of the GNU General Public License along with
-! PALM. If not, see <http://www.gnu.org/licenses/>.
+! PALM is free software: you can redistribute it and/or modify it under the terms of the GNU General
+! Public License as published by the Free Software Foundation, either version 3 of the License, or
+! (at your option) any later version.
+!
+! PALM is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the
+! implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
+! Public License for more details.
+!
+! You should have received a copy of the GNU General Public License along with PALM. If not, see
+! <http://www.gnu.org/licenses/>.
 !
 ! Copyright 1997-2020 Leibniz Universitaet Hannover
-!------------------------------------------------------------------------------!
+!--------------------------------------------------------------------------------------------------!
 !
 ! Current revisions:
@@ -25 +24 @@
 ! -----------------
 ! $Id$
+! file re-formatted to follow the PALM coding standard
+!
+! 4629 2020-07-29 09:37:56Z raasch
 ! support for MPI Fortran77 interface (mpif.h) removed
 !
@@ -32 +34 @@
 ! 4616 2020-07-21 10:09:46Z schwenkel
 ! Bugfix in case of strechting: k-calculation limited lower bound of 1
-! 
+!
 ! 4589 2020-07-06 12:34:09Z suehring
 ! remove unused variables
-! 
+!
 ! 4588 2020-07-06 11:06:02Z suehring
 ! Simplify particle-speed interpolation in logarithmic layer
-! 
+!
 ! 4585 2020-06-30 15:05:20Z suehring
-! Limit logarithmically interpolated particle speed to the velocity component
-! at the first prognostic grid point (since no stability corrected interpolation
-! is employed the particle speed could be overestimated in unstable conditions).
-! 
+! Limit logarithmically interpolated particle speed to the velocity component at the first
+! prognostic grid point (since no stability corrected interpolation is employed the particle speed
+! could be overestimated in unstable conditions).
+!
 ! 4546 2020-05-24 12:16:41Z raasch
 ! Variables iran and iran_part completely removed, added I/O of parallel random numbers to restart
 ! file
-! 
+!
 ! 4545 2020-05-22 13:17:57Z schwenkel
 ! Using parallel random generator, thus preventing dependency of PE number
-! 
+!
 ! 4535 2020-05-15 12:07:23Z raasch
 ! bugfix for restart data format query
-! 
+!
 ! 4520 2020-05-06 08:57:19Z schwenkel
 ! Add error number
-! 
+!
 ! 4517 2020-05-03 14:29:30Z raasch
 ! restart data handling with MPI-IO added
-! 
+!
 ! 4471 2020-03-24 12:08:06Z schwenkel
 ! Bugfix in lpm_droplet_interactions_ptq
-! 
+!
 ! 4457 2020-03-11 14:20:43Z raasch
 ! use statement for exchange horiz added
-! 
+!
 ! 4444 2020-03-05 15:59:50Z raasch
 ! bugfix: cpp-directives for serial mode added
-! 
+!
 ! 4430 2020-02-27 18:02:20Z suehring
-! - Bugfix in logarithmic interpolation of near-ground particle speed (density
-!   was not considered).
+! - Bugfix in logarithmic interpolation of near-ground particle speed (density was not considered).
 ! - Revise CFL-check when SGS particle speeds are considered.
-! - In nested case with SGS particle speeds in the child domain, do not give 
-!   warning that particles are on domain boundaries. At the end of the particle
-!   time integration these will be transferred to the parent domain anyhow.
-! 
+! - In nested case with SGS particle speeds in the child domain, do not give warning that particles
+!   are on domain boundaries. At the end of the particle time integration these will be transferred
+!   to the parent domain anyhow.
+!
 ! 4360 2020-01-07 11:25:50Z suehring
-! Introduction of wall_flags_total_0, which currently sets bits based on static
-! topography information used in wall_flags_static_0
-! 
+! Introduction of wall_flags_total_0, which currently sets bits based on static topography
+! information used in wall_flags_static_0
+!
 ! 4336 2019-12-13 10:12:05Z raasch
-! bugfix: wrong header output of particle group features (density ratio) in case
-! of restarts corrected
-! 
+! bugfix: wrong header output of particle group features (density ratio) in case of restarts
+!         corrected
+!
 ! 4329 2019-12-10 15:46:36Z motisi
 ! Renamed wall_flags_0 to wall_flags_static_0
-! 
+!
 ! 4282 2019-10-29 16:18:46Z schwenkel
 ! Bugfix of particle timeseries in case of more than one particle group
-! 
+!
 ! 4277 2019-10-28 16:53:23Z schwenkel
 ! Bugfix: Added first_call_lpm in use statement
-! 
+!
 ! 4276 2019-10-28 16:03:29Z schwenkel
 ! Modularize lpm: Move conditions in time intergration to module
-! 
+!
 ! 4275 2019-10-28 15:34:55Z schwenkel
-! Change call of simple predictor corrector method, i.e. two divergence free
-! velocitiy fields are now used.
+! Change call of simple predictor corrector method, i.e. two divergence free velocitiy fields are
+! now used.
 !
 ! 4232 2019-09-20 09:34:22Z knoop
 ! Removed INCLUDE "mpif.h", as it is not needed because of USE pegrid
-! 
+!
 ! 4195 2019-08-28 13:44:27Z schwenkel
-! Bugfix for simple_corrector interpolation method in case of ocean runs and
-! output particle advection interpolation method into header
-! 
+! Bugfix for simple_corrector interpolation method in case of ocean runs and output particle
+! advection interpolation method into header
+!
 ! 4182 2019-08-22 15:20:23Z scharf
 ! Corrected "Former revisions" section
-! 
+!
 ! 4168 2019-08-16 13:50:17Z suehring
 ! Replace function get_topography_top_index by topo_top_ind
-! 
+!
 ! 4145 2019-08-06 09:55:22Z schwenkel
 ! Some reformatting
-! 
+!
 ! 4144 2019-08-06 09:11:47Z raasch
 ! relational operators .EQ., .NE., etc. replaced by ==, /=, etc.
-! 
+!
 ! 4143 2019-08-05 15:14:53Z schwenkel
 ! Rename variable and change select case to if statement
-! 
+!
 ! 4122 2019-07-26 13:11:56Z schwenkel
 ! Implement reset method as bottom boundary condition
-! 
+!
 ! 4121 2019-07-26 10:01:22Z schwenkel
-! Implementation of an simple method for interpolating the velocities to
-! particle position
-! 
+! Implementation of an simple method for interpolating the velocities to particle position
+!
 ! 4114 2019-07-23 14:09:27Z schwenkel
 ! Bugfix: Added working precision for if statement
-! 
+!
 ! 4054 2019-06-27 07:42:18Z raasch
 ! bugfix for calculating the minimum particle time step
-! 
+!
 ! 4044 2019-06-19 12:28:27Z schwenkel
 ! Bugfix in case of grid strecting: corrected calculation of k-Index
@@ -141 +141 @@
 ! 4043 2019-06-18 16:59:00Z schwenkel
 ! Remove min_nr_particle, Add lpm_droplet_interactions_ptq into module
-! 
+!
 ! 4028 2019-06-13 12:21:37Z schwenkel
 ! Further modularization of particle code components
-! 
+!
 ! 4020 2019-06-06 14:57:48Z schwenkel
-! Removing submodules 
-! 
+! Removing submodules
+!
 ! 4018 2019-06-06 13:41:50Z eckhard
 ! Bugfix for former revision
-! 
+!
 ! 4017 2019-06-06 12:16:46Z schwenkel
 ! Modularization of all lagrangian particle model code components
-! 
-! 3655 2019-01-07 16:51:22Z knoop 
-! bugfix to guarantee correct particle releases in case that the release
-! interval is smaller than the model timestep
+!
+! 3655 2019-01-07 16:51:22Z knoop
+! bugfix to guarantee correct particle releases in case that the release interval is smaller than
+! the model timestep
 !
 ! Revision 1.1  1999/11/25 16:16:06  raasch
@@ -164 +164 @@
 ! Description:
 ! ------------
-!> The embedded LPM allows for studying transport and dispersion processes within
-!> turbulent flows. This model including passive particles that do not show any
-!> feedback on the turbulent flow. Further also particles with inertia and
-!> cloud droplets ca be simulated explicitly.
+!> The embedded LPM allows for studying transport and dispersion processes within turbulent flows.
+!> This model is including passive particles that do not show any feedback on the turbulent flow.
+!> Further also particles with inertia and cloud droplets can be simulated explicitly.
 !>
 !> @todo test lcm
@@ -173 +172 @@
 !> @note <Enter notes on the module>
 !> @bug  <Enter bug on the module>
-!------------------------------------------------------------------------------!
+!--------------------------------------------------------------------------------------------------!
  MODULE lagrangian_particle_model_mod
 
     USE, INTRINSIC ::  ISO_C_BINDING
 
-    USE arrays_3d,                                                             &
-        ONLY:  de_dx, de_dy, de_dz,                                            &
-               d_exner,                                                        &
-               dzw, zu, zw,  ql_c, ql_v, ql_vp, hyp,                           &
-               pt, q, exner, ql, diss, e, u, v, w, km, ql_1, ql_2
- 
-    USE averaging,                                                             &
-        ONLY:  ql_c_av, pr_av, pc_av, ql_vp_av, ql_v_av
-
-    USE basic_constants_and_equations_mod,                                     &
-        ONLY: molecular_weight_of_solute, molecular_weight_of_water, magnus,   &
-              pi, rd_d_rv, rho_l, r_v, rho_s, vanthoff, l_v, kappa, g, lv_d_cp
-
-    USE control_parameters,                                                    &
-        ONLY:  bc_dirichlet_l, bc_dirichlet_n, bc_dirichlet_r, bc_dirichlet_s, &
-               child_domain,                                                   &
-               cloud_droplets, constant_flux_layer, current_timestep_number,   &
-               dt_3d, dt_3d_reached, debug_output, first_call_lpm, humidity,   &
-               dt_3d_reached_l, dt_dopts, dz, initializing_actions,            &
-               intermediate_timestep_count, intermediate_timestep_count_max,   &
-               message_string, molecular_viscosity, ocean_mode,                &
-               particle_maximum_age, restart_data_format_input,                &
-               restart_data_format_output,                                     &
-               simulated_time, topography, dopts_time_count,                   &
-               time_since_reference_point, rho_surface, u_gtrans, v_gtrans,    &
-               dz_stretch_level, dz_stretch_level_start
-
-    USE cpulog,                                                                &
+    USE arrays_3d,                                                                                 &
+        ONLY:  d_exner, de_dx, de_dy, de_dz, diss, dzw, e, exner, hyp, km, pt, q, ql, ql_1, ql_2,  &
+               ql_c, ql_v, ql_vp, u, v, w, zu, zw
+
+    USE averaging,                                                                                 &
+        ONLY:  pc_av, pr_av, ql_c_av, ql_v_av, ql_vp_av
+
+    USE basic_constants_and_equations_mod,                                                         &
+        ONLY:  g, kappa, l_v, lv_d_cp, magnus, molecular_weight_of_solute,                         &
+               molecular_weight_of_water, pi, r_v, rd_d_rv, rho_l, rho_s, vanthoff
+
+    USE control_parameters,                                                                        &
+        ONLY:  bc_dirichlet_l, bc_dirichlet_n, bc_dirichlet_r, bc_dirichlet_s,                     &
+               child_domain, cloud_droplets, constant_flux_layer, current_timestep_number,         &
+               debug_output, dopts_time_count, dt_3d, dt_3d_reached, dt_3d_reached_l, dt_dopts, dz,&
+               dz_stretch_level, dz_stretch_level_start, first_call_lpm, humidity,                 &
+               initializing_actions, intermediate_timestep_count, intermediate_timestep_count_max, &
+               message_string, molecular_viscosity, ocean_mode, particle_maximum_age,              &
+               restart_data_format_input, restart_data_format_output, rho_surface, simulated_time, &
+               time_since_reference_point, topography, u_gtrans, v_gtrans
+
+    USE cpulog,                                                                                    &
         ONLY:  cpu_log, log_point, log_point_s
 
-    USE indices,                                                               &
-        ONLY:  nx, nxl, nxlg, nxrg, nxr, ny, nyn, nys, nyng, nysg, nz, nzb,    &
-               nzb_max, nzt,nbgp, ngp_2dh_outer,                               &
-               topo_top_ind,                                                   &
-               wall_flags_total_0
+    USE indices,                                                                                   &
+        ONLY:  nbgp, ngp_2dh_outer, nx, nxl, nxlg, nxrg, nxr, ny, nyn, nys, nyng, nysg, nz, nzb,   &
+               nzb_max, nzt, topo_top_ind, wall_flags_total_0
 
     USE kinds
@@ -221 +212 @@
 
 #if defined( __parallel )
-    USE pmc_particle_interface,                                                &
-        ONLY: pmcp_c_get_particle_from_parent, pmcp_p_fill_particle_win,       &
-              pmcp_c_send_particle_to_parent, pmcp_p_empty_particle_win,       &
-              pmcp_p_delete_particles_in_fine_grid_area, pmcp_g_init,          &
-              pmcp_g_print_number_of_particles
+    USE pmc_particle_interface,                                                                    &
+        ONLY: pmcp_c_get_particle_from_parent, pmcp_c_send_particle_to_parent, pmcp_g_init,        &
+              pmcp_g_print_number_of_particles, pmcp_p_delete_particles_in_fine_grid_area,         &
+              pmcp_p_empty_particle_win, pmcp_p_fill_particle_win
 #endif
 
-    USE pmc_interface,                                                         &
+    USE pmc_interface,                                                                             &
         ONLY: nested_run
 
-    USE grid_variables,                                                        &
+    USE grid_variables,                                                                            &
         ONLY:  ddx, dx, ddy, dy
 
-    USE netcdf_interface,                                                      &
-        ONLY:  netcdf_data_format, netcdf_deflate, dopts_num, id_set_pts,      &
-               id_var_dopts, id_var_time_pts, nc_stat,                         &
-               netcdf_handle_error
-
-    USE random_generator_parallel,                                             &
-        ONLY:  init_parallel_random_generator,                                 &
-               random_dummy,                                                   &
-               random_number_parallel,                                         &
-               random_number_parallel_gauss,                                   &
-               random_seed_parallel,                                           &
-               id_random_array
-
-    USE restart_data_mpi_io_mod,                                               &
-        ONLY:  rd_mpi_io_check_array,                                          &
-               rd_mpi_io_check_open,                                           &
-               rd_mpi_io_close,                                                &
-               rd_mpi_io_open,                                                 &
-               rd_mpi_io_particle_filetypes,                                   &
-               rrd_mpi_io,                                                     &
-               rrd_mpi_io_global_array,                                        &
-               rrd_mpi_io_particles,                                           &
-               wrd_mpi_io,                                                     &
-               wrd_mpi_io_global_array,                                        &
+    USE netcdf_interface,                                                                          &
+        ONLY:  dopts_num, id_set_pts, id_var_dopts, id_var_time_pts, nc_stat, netcdf_data_format,  &
+               netcdf_deflate, netcdf_handle_error
+
+    USE random_generator_parallel,                                                                 &
+        ONLY:  init_parallel_random_generator,                                                     &
+               id_random_array,                                                                    &
+               random_dummy,                                                                       &
+               random_number_parallel,                                                             &
+               random_number_parallel_gauss,                                                       &
+               random_seed_parallel
+
+    USE restart_data_mpi_io_mod,                                                                   &
+        ONLY:  rd_mpi_io_check_array,                                                              &
+               rd_mpi_io_check_open,                                                               &
+               rd_mpi_io_close,                                                                    &
+               rd_mpi_io_open,                                                                     &
+               rd_mpi_io_particle_filetypes,                                                       &
+               rrd_mpi_io,                                                                         &
+               rrd_mpi_io_global_array,                                                            &
+               rrd_mpi_io_particles,                                                               &
+               wrd_mpi_io,                                                                         &
+               wrd_mpi_io_global_array,                                                            &
                wrd_mpi_io_particles
 
-    USE statistics,                                                            &
+    USE statistics,                                                                                &
         ONLY:  hom
 
-    USE surface_mod,                                                           &
-        ONLY:  bc_h,                                                           &
-               surf_def_h,                                                     &
-               surf_lsm_h,                                                     &
+    USE surface_mod,                                                                               &
+        ONLY:  bc_h,                                                                               &
+               surf_def_h,                                                                         &
+               surf_lsm_h,                                                                         &
                surf_usm_h
 
@@ -283 +272 @@
     IMPLICIT NONE
 
+    INTEGER(iwp), PARAMETER         ::  nr_2_direction_move = 10000 !<
+    INTEGER(iwp), PARAMETER         ::  phase_init    = 1           !<
+    INTEGER(iwp), PARAMETER, PUBLIC ::  phase_release = 2           !<
+
+    REAL(wp), PARAMETER ::  c_0 = 3.0_wp         !< parameter for lagrangian timescale
+
     CHARACTER(LEN=15) ::  aero_species = 'nacl'                   !< aerosol species
     CHARACTER(LEN=15) ::  aero_type    = 'maritime'               !< aerosol type
+    CHARACTER(LEN=15) ::  bc_par_b     = 'reflect'                !< bottom boundary condition
     CHARACTER(LEN=15) ::  bc_par_lr    = 'cyclic'                 !< left/right boundary condition
     CHARACTER(LEN=15) ::  bc_par_ns    = 'cyclic'                 !< north/south boundary condition
-    CHARACTER(LEN=15) ::  bc_par_b     = 'reflect'                !< bottom boundary condition
     CHARACTER(LEN=15) ::  bc_par_t     = 'absorb'                 !< top boundary condition
     CHARACTER(LEN=15) ::  collision_kernel   = 'none'             !< collision kernel
@@ -296 +291 @@
     CHARACTER(LEN=25) ::  particle_advection_interpolation = 'trilinear' !< interpolation method for calculatin the particle
 
-    INTEGER(iwp) ::  deleted_particles = 0                        !< number of deleted particles per time step    
+    INTEGER(iwp) ::  deleted_particles = 0                        !< number of deleted particles per time step
     INTEGER(iwp) ::  i_splitting_mode                             !< dummy for splitting mode
+    INTEGER(iwp) ::  isf                                          !< dummy for splitting function
     INTEGER(iwp) ::  max_number_particles_per_gridbox = 100       !< namelist parameter (see documentation)
-    INTEGER(iwp) ::  isf                                          !< dummy for splitting function
     INTEGER(iwp) ::  number_particles_per_gridbox = -1            !< namelist parameter (see documentation)
-    INTEGER(iwp) ::  number_of_sublayers = 20                     !< number of sublayers for particle velocities betwenn surface and first grid level
-    INTEGER(iwp) ::  offset_ocean_nzt = 0                         !< in case of oceans runs, the vertical index calculations need an offset
-    INTEGER(iwp) ::  offset_ocean_nzt_m1 = 0                      !< in case of oceans runs, the vertical index calculations need an offset
+    INTEGER(iwp) ::  number_of_sublayers = 20                     !< number of sublayers for particle velocities betwenn surface
+                                                                  !< and first grid level
+    INTEGER(iwp) ::  offset_ocean_nzt = 0                         !< in case of oceans runs, the vertical index calculations need
+                                                                  !< an offset
+    INTEGER(iwp) ::  offset_ocean_nzt_m1 = 0                      !< in case of oceans runs, the vertical index calculations need
+                                                                  !< an offset
     INTEGER(iwp) ::  particles_per_point = 1                      !< namelist parameter (see documentation)
     INTEGER(iwp) ::  radius_classes = 20                          !< namelist parameter (see documentation)
@@ -310 +308 @@
     INTEGER(iwp) ::  step_dealloc = 100                           !< namelist parameter (see documentation)
     INTEGER(iwp) ::  total_number_of_particles                    !< total number of particles in the whole model domain
+    INTEGER(iwp) ::  trlp_count_recv_sum                          !< parameter for particle exchange of PEs
     INTEGER(iwp) ::  trlp_count_sum                               !< parameter for particle exchange of PEs
-    INTEGER(iwp) ::  trlp_count_recv_sum                          !< parameter for particle exchange of PEs
+    INTEGER(iwp) ::  trrp_count_recv_sum                          !< parameter for particle exchange of PEs
     INTEGER(iwp) ::  trrp_count_sum                               !< parameter for particle exchange of PEs
-    INTEGER(iwp) ::  trrp_count_recv_sum                          !< parameter for particle exchange of PEs
+    INTEGER(iwp) ::  trsp_count_recv_sum                          !< parameter for particle exchange of PEs
     INTEGER(iwp) ::  trsp_count_sum                               !< parameter for particle exchange of PEs
-    INTEGER(iwp) ::  trsp_count_recv_sum                          !< parameter for particle exchange of PEs
+    INTEGER(iwp) ::  trnp_count_recv_sum                          !< parameter for particle exchange of PEs
     INTEGER(iwp) ::  trnp_count_sum                               !< parameter for particle exchange of PEs
-    INTEGER(iwp) ::  trnp_count_recv_sum                          !< parameter for particle exchange of PEs
 
     INTEGER(isp), DIMENSION(:,:,:), ALLOCATABLE ::  seq_random_array_particles   !< sequence of random array for particle
 
-    LOGICAL ::  lagrangian_particle_model = .FALSE.       !< namelist parameter (see documentation) 
     LOGICAL ::  curvature_solution_effects = .FALSE.      !< namelist parameter (see documentation)
     LOGICAL ::  deallocate_memory = .TRUE.                !< namelist parameter (see documentation)
     LOGICAL ::  hall_kernel = .FALSE.                     !< flag for collision kernel
+    LOGICAL ::  interpolation_simple_corrector = .FALSE.  !< flag for simple particle advection interpolation with corrector step
+    LOGICAL ::  interpolation_simple_predictor = .FALSE.  !< flag for simple particle advection interpolation with predictor step
+    LOGICAL ::  interpolation_trilinear = .FALSE.         !< flag for trilinear particle advection interpolation
+    LOGICAL ::  lagrangian_particle_model = .FALSE.       !< namelist parameter (see documentation)
     LOGICAL ::  merging = .FALSE.                         !< namelist parameter (see documentation)
     LOGICAL ::  random_start_position = .FALSE.           !< namelist parameter (see documentation)
@@ -332 +333 @@
     LOGICAL ::  use_kernel_tables = .FALSE.               !< parameter, which turns on the use of precalculated collision kernels
     LOGICAL ::  write_particle_statistics = .FALSE.       !< namelist parameter (see documentation)
-    LOGICAL ::  interpolation_simple_predictor = .FALSE.  !< flag for simple particle advection interpolation with predictor step
-    LOGICAL ::  interpolation_simple_corrector = .FALSE.  !< flag for simple particle advection interpolation with corrector step
-    LOGICAL ::  interpolation_trilinear = .FALSE.         !< flag for trilinear particle advection interpolation
-
-    LOGICAL, DIMENSION(max_number_of_particle_groups) ::   vertical_particle_advection = .TRUE. !< Switch for vertical particle transport
+
+    LOGICAL, DIMENSION(max_number_of_particle_groups) ::   vertical_particle_advection = .TRUE.  !< Switch for vertical particle
+                                                                                                 !< transport
 
     REAL(wp) ::  aero_weight = 1.0_wp                      !< namelist parameter (see documentation)
@@ -342 +341 @@
     REAL(wp) ::  dt_prel = 9999999.9_wp                    !< namelist parameter (see documentation)
     REAL(wp) ::  dt_write_particle_data = 9999999.9_wp     !< namelist parameter (see documentation)
+    REAL(wp) ::  epsilon_collision                         !<
     REAL(wp) ::  end_time_prel = 9999999.9_wp              !< namelist parameter (see documentation)
     REAL(wp) ::  initial_weighting_factor = 1.0_wp         !< namelist parameter (see documentation)
@@ -350 +350 @@
     REAL(wp) ::  radius_merge = 1.0E-7_wp                  !< namelist parameter (see documentation)
     REAL(wp) ::  radius_split = 40.0E-6_wp                 !< namelist parameter (see documentation)
+    REAL(wp) ::  rclass_lbound                             !<
+    REAL(wp) ::  rclass_ubound                             !<
     REAL(wp) ::  rm(3) = 1.0E-6_wp                         !< namelist parameter (see documentation)
     REAL(wp) ::  sgs_wf_part                               !< parameter for sgs
     REAL(wp) ::  time_write_particle_data = 0.0_wp         !< write particle data at current time on file
+    REAL(wp) ::  urms                                      !<
     REAL(wp) ::  weight_factor_merge = -1.0_wp             !< namelist parameter (see documentation)
     REAL(wp) ::  weight_factor_split = -1.0_wp             !< namelist parameter (see documentation)
     REAL(wp) ::  z0_av_global                              !< horizontal mean value of z0
-
-    REAL(wp) ::  rclass_lbound !<
-    REAL(wp) ::  rclass_ubound !<
-
-    REAL(wp), PARAMETER ::  c_0 = 3.0_wp         !< parameter for lagrangian timescale
 
     REAL(wp), DIMENSION(max_number_of_particle_groups) ::  density_ratio = 9999999.9_wp  !< namelist parameter (see documentation)
@@ -376 +374 @@
     REAL(wp), DIMENSION(:), ALLOCATABLE     ::  log_z_z0   !< Precalculate LOG(z/z0)
 
-    INTEGER(iwp), PARAMETER ::  NR_2_direction_move = 10000 !<
-
 #if defined( __parallel )
     INTEGER(iwp)            ::  nr_move_north               !<
@@ -385 +381 @@
     TYPE(particle_type), DIMENSION(:), ALLOCATABLE ::  move_also_south
 #endif
-
-    REAL(wp) ::  epsilon_collision !<
-    REAL(wp) ::  urms              !<
 
     REAL(wp), DIMENSION(:),   ALLOCATABLE ::  epsclass  !< dissipation rate class
@@ -404 +397 @@
     REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::  w_t   !< w value of old timelevel t
 
-
-    INTEGER(iwp), PARAMETER         ::  PHASE_INIT    = 1  !<
-    INTEGER(iwp), PARAMETER, PUBLIC ::  PHASE_RELEASE = 2  !<
-
     SAVE
 
     PRIVATE
 
-    PUBLIC lpm_parin,     &
-           lpm_header,    &
-           lpm_init_arrays,&
-           lpm_init,      &
-           lpm_actions,   &
-           lpm_data_output_ptseries, &
-           lpm_interaction_droplets_ptq, &
-           lpm_rrd_local_particles, &
-           lpm_wrd_local, &
-           lpm_rrd_global, &
-           lpm_wrd_global, &
-           lpm_rrd_local, &
+    PUBLIC lpm_parin,                                                                              &
+           lpm_header,                                                                             &
+           lpm_init_arrays,                                                                        &
+           lpm_init,                                                                               &
+           lpm_actions,                                                                            &
+           lpm_data_output_ptseries,                                                               &
+           lpm_interaction_droplets_ptq,                                                           &
+           lpm_rrd_local_particles,                                                                &
+           lpm_wrd_local,                                                                          &
+           lpm_rrd_global,                                                                         &
+           lpm_wrd_global,                                                                         &
+           lpm_rrd_local,                                                                          &
            lpm_check_parameters
 
@@ -443 +432 @@
        MODULE PROCEDURE lpm_init_arrays
     END INTERFACE lpm_init_arrays
- 
+
     INTERFACE lpm_init
        MODULE PROCEDURE lpm_init
@@ -544 +533 @@
 
  CONTAINS
- 
-
-!------------------------------------------------------------------------------!
+
+
+!--------------------------------------------------------------------------------------------------!
 ! Description:
 ! ------------
 !> Parin for &particle_parameters for the Lagrangian particle model
-!------------------------------------------------------------------------------!
+!--------------------------------------------------------------------------------------------------!
  SUBROUTINE lpm_parin
- 
+
     CHARACTER (LEN=80) ::  line  !<
 
-    NAMELIST /particles_par/ &
-       aero_species, &
-       aero_type, &
-       aero_weight, &
-       alloc_factor, &
-       bc_par_b, &
-       bc_par_lr, &
-       bc_par_ns, &
-       bc_par_t, &
-       collision_kernel, &
-       curvature_solution_effects, &
-       deallocate_memory, &
-       density_ratio, &
-       dissipation_classes, &
-       dt_dopts, &
-       dt_min_part, &
-       dt_prel, &
-       dt_write_particle_data, &
-       end_time_prel, &
-       initial_weighting_factor, &
-       log_sigma, &
-       max_number_particles_per_gridbox, &
-       merging, &
-       na, &
-       number_concentration, &
-       number_of_particle_groups, &
-       number_particles_per_gridbox, &
-       particles_per_point, &
-       particle_advection_start, &
-       particle_advection_interpolation, &
-       particle_maximum_age, &
-       pdx, &
-       pdy, &
-       pdz, &
-       psb, &
-       psl, &
-       psn, &
-       psr, &
-       pss, &
-       pst, &
-       radius, &
-       radius_classes, &
-       radius_merge, &
-       radius_split, &
-       random_start_position, &
-       read_particles_from_restartfile, &
-       rm, &
-       seed_follows_topography, &
-       splitting, &
-       splitting_factor, &
-       splitting_factor_max, &
-       splitting_function, &
-       splitting_mode, &
-       step_dealloc, &
-       use_sgs_for_particles, &
-       vertical_particle_advection, &
-       weight_factor_merge, &
-       weight_factor_split, &
+    NAMELIST /particles_par/                                                                       &
+       aero_species,                                                                               &
+       aero_type,                                                                                  &
+       aero_weight,                                                                                &
+       alloc_factor,                                                                               &
+       bc_par_b,                                                                                   &
+       bc_par_lr,                                                                                  &
+       bc_par_ns,                                                                                  &
+       bc_par_t,                                                                                   &
+       collision_kernel,                                                                           &
+       curvature_solution_effects,                                                                 &
+       deallocate_memory,                                                                          &
+       density_ratio,                                                                              &
+       dissipation_classes,                                                                        &
+       dt_dopts,                                                                                   &
+       dt_min_part,                                                                                &
+       dt_prel,                                                                                    &
+       dt_write_particle_data,                                                                     &
+       end_time_prel,                                                                              &
+       initial_weighting_factor,                                                                   &
+       log_sigma,                                                                                  &
+       max_number_particles_per_gridbox,                                                           &
+       merging,                                                                                    &
+       na,                                                                                         &
+       number_concentration,                                                                       &
+       number_of_particle_groups,                                                                  &
+       number_particles_per_gridbox,                                                               &
+       particles_per_point,                                                                        &
+       particle_advection_start,                                                                   &
+       particle_advection_interpolation,                                                           &
+       particle_maximum_age,                                                                       &
+       pdx,                                                                                        &
+       pdy,                                                                                        &
+       pdz,                                                                                        &
+       psb,                                                                                        &
+       psl,                                                                                        &
+       psn,                                                                                        &
+       psr,                                                                                        &
+       pss,                                                                                        &
+       pst,                                                                                        &
+       radius,                                                                                     &
+       radius_classes,                                                                             &
+       radius_merge,                                                                               &
+       radius_split,                                                                               &
+       random_start_position,                                                                      &
+       read_particles_from_restartfile,                                                            &
+       rm,                                                                                         &
+       seed_follows_topography,                                                                    &
+       splitting,                                                                                  &
+       splitting_factor,                                                                           &
+       splitting_factor_max,                                                                       &
+       splitting_function,                                                                         &
+       splitting_mode,                                                                             &
+       step_dealloc,                                                                               &
+       use_sgs_for_particles,                                                                      &
+       vertical_particle_advection,                                                                &
+       weight_factor_merge,                                                                        &
+       weight_factor_split,                                                                        &
        write_particle_statistics
 
-    NAMELIST /particle_parameters/ &
-       aero_species, &
-       aero_type, &
-       aero_weight, &
-       alloc_factor, &
-       bc_par_b, &
-       bc_par_lr, &
-       bc_par_ns, &
-       bc_par_t, &
-       collision_kernel, &
-       curvature_solution_effects, &
-       deallocate_memory, &
-       density_ratio, &
-       dissipation_classes, &
-       dt_dopts, &
-       dt_min_part, &
-       dt_prel, &
-       dt_write_particle_data, &
-       end_time_prel, &
-       initial_weighting_factor, &
-       log_sigma, &
-       max_number_particles_per_gridbox, &
-       merging, &
-       na, &
-       number_concentration, &
-       number_of_output_particles, &
-       number_of_particle_groups, &
-       number_particles_per_gridbox, &
-       oversize, &
-       particles_per_point, &
-       particle_advection_start, &
-       particle_advection_interpolation, &
-       particle_maximum_age, &
-       part_output, &
-       part_inc, &
-       part_percent, &
-       pdx, &
-       pdy, &
-       pdz, &
-       psb, &
-       psl, &
-       psn, &
-       psr, &
-       pss, &
-       pst, &
-       radius, &
-       radius_classes, &
-       radius_merge, &
-       radius_split, &
-       random_start_position, &
-       read_particles_from_restartfile, &
-       rm, &
-       seed_follows_topography, &
-       splitting, &
-       splitting_factor, &
-       splitting_factor_max, &
-       splitting_function, &
-       splitting_mode, &
-       step_dealloc, &
-       unlimited_dimension, &
-       use_sgs_for_particles, &
-       vertical_particle_advection, &
-       weight_factor_merge, &
-       weight_factor_split, &
+    NAMELIST /particle_parameters/                                                                 &
+       aero_species,                                                                               &
+       aero_type,                                                                                  &
+       aero_weight,                                                                                &
+       alloc_factor,                                                                               &
+       bc_par_b,                                                                                   &
+       bc_par_lr,                                                                                  &
+       bc_par_ns,                                                                                  &
+       bc_par_t,                                                                                   &
+       collision_kernel,                                                                           &
+       curvature_solution_effects,                                                                 &
+       deallocate_memory,                                                                          &
+       density_ratio,                                                                              &
+       dissipation_classes,                                                                        &
+       dt_dopts,                                                                                   &
+       dt_min_part,                                                                                &
+       dt_prel,                                                                                    &
+       dt_write_particle_data,                                                                     &
+       end_time_prel,                                                                              &
+       initial_weighting_factor,                                                                   &
+       log_sigma,                                                                                  &
+       max_number_particles_per_gridbox,                                                           &
+       merging,                                                                                    &
+       na,                                                                                         &
+       number_concentration,                                                                       &
+       number_of_output_particles,                                                                 &
+       number_of_particle_groups,                                                                  &
+       number_particles_per_gridbox,                                                               &
+       oversize,                                                                                   &
+       particles_per_point,                                                                        &
+       particle_advection_start,                                                                   &
+       particle_advection_interpolation,                                                           &
+       particle_maximum_age,                                                                       &
+       part_output,                                                                                &
+       part_inc,                                                                                   &
+       part_percent,                                                                               &
+       pdx,                                                                                        &
+       pdy,                                                                                        &
+       pdz,                                                                                        &
+       psb,                                                                                        &
+       psl,                                                                                        &
+       psn,                                                                                        &
+       psr,                                                                                        &
+       pss,                                                                                        &
+       pst,                                                                                        &
+       radius,                                                                                     &
+       radius_classes,                                                                             &
+       radius_merge,                                                                               &
+       radius_split,                                                                               &
+       random_start_position,                                                                      &
+       read_particles_from_restartfile,                                                            &
+       rm,                                                                                         &
+       seed_follows_topography,                                                                    &
+       splitting,                                                                                  &
+       splitting_factor,                                                                           &
+       splitting_factor_max,                                                                       &
+       splitting_function,                                                                         &
+       splitting_mode,                                                                             &
+       step_dealloc,                                                                               &
+       unlimited_dimension,                                                                        &
+       use_sgs_for_particles,                                                                      &
+       vertical_particle_advection,                                                                &
+       weight_factor_merge,                                                                        &
+       weight_factor_split,                                                                        &
        write_particle_statistics
 
 !
-!-- Position the namelist-file at the beginning (it was already opened in
-!-- parin), search for the namelist-group of the package and position the
-!-- file at this line. Do the same for each optionally used package.
+!-- Position the namelist-file at the beginning (it was already opened in parin), search for the
+!-- namelist-group of the package and position the file at this line. Do the same for each
+!-- optionally used package.
     line = ' '
-    
+
 !
 !-- Try to find particles package
@@ -701 +690 @@
 !-- Set flag that indicates that particles are switched on
     particle_advection = .TRUE.
-    
+
     GOTO 14
 
@@ -719 +708 @@
     READ ( 11, particles_par, ERR = 13, END = 14 )
 
-    message_string = 'namelist particles_par is deprecated and will be ' //    &
-                     'removed in near future. Please use namelist ' //         &
+    message_string = 'namelist particles_par is deprecated and will be ' //                        &
+                     'removed in near future. Please use namelist ' //                             &
                      'particle_parameters instead'
     CALL message( 'package_parin', 'PA0487', 0, 1, 0, 6, 0 )
@@ -737 +726 @@
 
  END SUBROUTINE lpm_parin
- 
-!------------------------------------------------------------------------------!
+
+!--------------------------------------------------------------------------------------------------!
 ! Description:
 ! ------------
 !> Writes used particle attributes in header file.
-!------------------------------------------------------------------------------! 
+!--------------------------------------------------------------------------------------------------!
  SUBROUTINE lpm_header ( io )
 
@@ -763 +752 @@
        ENDIF
     ENDIF
- 
+
     IF ( particle_advection )  THEN
 !
 !--    Particle attributes
-       WRITE ( io, 480 )  particle_advection_start, TRIM(particle_advection_interpolation), &
-                          dt_prel, bc_par_lr, &
-                          bc_par_ns, bc_par_b, bc_par_t, particle_maximum_age, &
+       WRITE ( io, 480 )  particle_advection_start, TRIM(particle_advection_interpolation),        &
+                          dt_prel, bc_par_lr, bc_par_ns, bc_par_b, bc_par_t, particle_maximum_age, &
                           end_time_prel
        IF ( use_sgs_for_particles )  WRITE ( io, 488 )  dt_min_part
@@ -801 +789 @@
              WRITE ( io, 492 )
           ENDIF
-          WRITE ( io, 493 )  psl(i), psr(i), pss(i), psn(i), psb(i), pst(i), &
-                             pdx(i), pdy(i), pdz(i)
+          WRITE ( io, 493 )  psl(i), psr(i), pss(i), psn(i), psb(i), pst(i), pdx(i), pdy(i), pdz(i)
           IF ( .NOT. vertical_particle_advection(i) )  WRITE ( io, 482 )
        ENDDO
 
     ENDIF
-    
+
 344 FORMAT ('       Output format: ',A/)
 354 FORMAT ('       Output format: ',A, '   compressed with level: ',I1/)
 
-433 FORMAT ('    Cloud droplets treated explicitly using the Lagrangian part', &
-                 'icle model')
-434 FORMAT ('    Curvature and solution effecs are considered for growth of', &
+433 FORMAT ('    Cloud droplets treated explicitly using the Lagrangian part','icle model')
+434 FORMAT ('    Curvature and solution effecs are considered for growth of',                      &
                  ' droplets < 1.0E-6 m')
 435 FORMAT ('    Droplet collision is handled by ',A,'-kernel')
-436 FORMAT ('       Fast kernel with fixed radius- and dissipation classes ', &
-                    'are used'/ &
-            '          number of radius classes:       ',I3,'    interval ', &
-                       '[1.0E-6,2.0E-4] m'/ &
-            '          number of dissipation classes:   ',I2,'    interval ', &
-                       '[0,1000] cm**2/s**3')
+436 FORMAT ('       Fast kernel with fixed radius- and dissipation classes ','are used'/           &
+            '          number of radius classes:       ',I3,'    interval ','[1.0E-6,2.0E-4] m'/   &
+            '          number of dissipation classes:   ',I2,'    interval ','[0,1000] cm**2/s**3')
 437 FORMAT ('    Droplet collision is switched off')
 
-480 FORMAT ('    Particles:'/ &
-            '    ---------'// &
-            '       Particle advection is active (switched on at t = ', F7.1, &
-                    ' s)'/ &
-            '       Interpolation of particle velocities is done by using ', A, &
-                    ' method'/ &
-            '       Start of new particle generations every  ',F6.1,' s'/ &
-            '       Boundary conditions: left/right: ', A, ' north/south: ', A/&
-            '                            bottom:     ', A, ' top:         ', A/&
-            '       Maximum particle age:                 ',F9.1,' s'/ &
+480 FORMAT ('    Particles:'/                                                                      &
+            '    ---------'//                                                                      &
+            '       Particle advection is active (switched on at t = ', F7.1,' s)'/                &
+            '       Interpolation of particle velocities is done by using ', A,' method'/          &
+            '       Start of new particle generations every  ',F6.1,' s'/                          &
+            '       Boundary conditions: left/right: ', A, ' north/south: ', A/                    &
+            '                            bottom:     ', A, ' top:         ', A/                    &
+            '       Maximum particle age:                 ',F9.1,' s'/                             &
             '       Advection stopped at t = ',F9.1,' s'/)
 481 FORMAT ('       Particles have random start positions'/)
@@ -840 +821 @@
 486 FORMAT ('       Particle statistics are written on file'/)
 487 FORMAT ('       Number of particle groups: ',I2/)
-488 FORMAT ('       SGS velocity components are used for particle advection'/ &
+488 FORMAT ('       SGS velocity components are used for particle advection'/                      &
             '          minimum timestep for advection:', F8.5/)
-489 FORMAT ('       Number of particles simultaneously released at each ', &
-                    'point: ', I5/)
-490 FORMAT ('       Particle group ',I2,':'/ &
+489 FORMAT ('       Number of particles simultaneously released at each ','point: ', I5/)
+490 FORMAT ('       Particle group ',I2,':'/                                                       &
             '          Particle radius: ',E10.3, 'm')
-491 FORMAT ('          Particle inertia is activated'/ &
+491 FORMAT ('          Particle inertia is activated'/                                             &
             '             density_ratio (rho_fluid/rho_particle) =',F6.3/)
 492 FORMAT ('          Particles are advected only passively (no inertia)'/)
-493 FORMAT ('          Boundaries of particle source: x:',F8.1,' - ',F8.1,' m'/&
-            '                                         y:',F8.1,' - ',F8.1,' m'/&
-            '                                         z:',F8.1,' - ',F8.1,' m'/&
-            '          Particle distances:  dx = ',F8.1,' m  dy = ',F8.1, &
-                       ' m  dz = ',F8.1,' m'/)
-494 FORMAT ('       Output of particle time series in NetCDF format every ', &
-                    F8.2,' s'/)
+493 FORMAT ('          Boundaries of particle source: x:',F8.1,' - ',F8.1,' m'/                    &
+            '                                         y:',F8.1,' - ',F8.1,' m'/                    &
+            '                                         z:',F8.1,' - ',F8.1,' m'/                    &
+            '          Particle distances:  dx = ',F8.1,' m  dy = ',F8.1,' m  dz = ',F8.1,' m'/)
+494 FORMAT ('       Output of particle time series in NetCDF format every ',F8.2,' s'/)
 495 FORMAT ('       Number of particles in total domain: ',I10/)
-496 FORMAT ('       Initial vertical particle positions are interpreted ', &
+496 FORMAT ('       Initial vertical particle positions are interpreted ',                         &
                     'as relative to the given topography')
-    
+
  END SUBROUTINE lpm_header
- 
-!------------------------------------------------------------------------------!
+
+!--------------------------------------------------------------------------------------------------!
 ! Description:
 ! ------------
 !> Writes used particle attributes in header file.
-!------------------------------------------------------------------------------!  
+!--------------------------------------------------------------------------------------------------!
  SUBROUTINE lpm_check_parameters
- 
+
 !
 !-- Collision kernels:
@@ -883 +861 @@
 
        CASE DEFAULT
-          message_string = 'unknown collision kernel: collision_kernel = "' // &
+          message_string = 'unknown collision kernel: collision_kernel = "' //                     &
                            TRIM( collision_kernel ) // '"'
           CALL message( 'lpm_check_parameters', 'PA0350', 1, 2, 0, 6, 0 )
@@ -891 +869 @@
 
 !
-!-- Subgrid scale velocites with the simple interpolation method for resolved
-!-- velocites is not implemented for passive particles. However, for cloud
-!-- it can be combined as the sgs-velocites for active particles are
-!-- calculated differently, i.e. no subboxes are needed.
-    IF ( .NOT. TRIM( particle_advection_interpolation ) == 'trilinear'  .AND.  &
-       use_sgs_for_particles  .AND.  .NOT. cloud_droplets )  THEN
-          message_string = 'subrgrid scale velocities in combination with ' // &
-                           'simple interpolation method is not '            // &
+!-- Subgrid scale velocites with the simple interpolation method for resolved velocites is not
+!-- implemented for passive particles. However, for cloud it can be combined as the sgs-velocites
+!-- for active particles are calculated differently, i.e. no subboxes are needed.
+    IF ( .NOT. TRIM( particle_advection_interpolation ) == 'trilinear'  .AND.                      &
+         use_sgs_for_particles  .AND.  .NOT. cloud_droplets )  THEN
+          message_string = 'subrgrid scale velocities in combination with ' //                     &
+                           'simple interpolation method is not '            //                     &
                            'implemented'
           CALL message( 'lpm_check_parameters', 'PA0659', 1, 2, 0, 6, 0 )
@@ -904 +881 @@
 
     IF ( nested_run  .AND.  cloud_droplets )  THEN
-       message_string = 'nested runs in combination with cloud droplets ' // &
+       message_string = 'nested runs in combination with cloud droplets ' //                       &
                         'is not implemented'
           CALL message( 'lpm_check_parameters', 'PA0687', 1, 2, 0, 6, 0 )
@@ -911 +888 @@
 
  END SUBROUTINE lpm_check_parameters
- 
-!------------------------------------------------------------------------------!
+
+!--------------------------------------------------------------------------------------------------!
 ! Description:
 ! ------------
 !> Initialize arrays for lpm
-!------------------------------------------------------------------------------!   
+!--------------------------------------------------------------------------------------------------!
  SUBROUTINE lpm_init_arrays
- 
+
     IF ( cloud_droplets )  THEN
 !
 !--    Liquid water content, change in liquid water content
-       ALLOCATE ( ql_1(nzb:nzt+1,nysg:nyng,nxlg:nxrg),                         &
+       ALLOCATE ( ql_1(nzb:nzt+1,nysg:nyng,nxlg:nxrg),                                             &
                   ql_2(nzb:nzt+1,nysg:nyng,nxlg:nxrg) )
 !--    Real volume of particles (with weighting), volume of particles
-       ALLOCATE ( ql_v(nzb:nzt+1,nysg:nyng,nxlg:nxrg),                         &
+       ALLOCATE ( ql_v(nzb:nzt+1,nysg:nyng,nxlg:nxrg),                                             &
                   ql_vp(nzb:nzt+1,nysg:nyng,nxlg:nxrg) )
     ENDIF
 
 
-    ALLOCATE( u_t(nzb:nzt+1,nysg:nyng,nxlg:nxrg),                              &
-              v_t(nzb:nzt+1,nysg:nyng,nxlg:nxrg),                              &
+    ALLOCATE( u_t(nzb:nzt+1,nysg:nyng,nxlg:nxrg),                                                  &
+              v_t(nzb:nzt+1,nysg:nyng,nxlg:nxrg),                                                  &
               w_t(nzb:nzt+1,nysg:nyng,nxlg:nxrg) )
 !
@@ -946 +923 @@
 
  END SUBROUTINE lpm_init_arrays
- 
-!------------------------------------------------------------------------------!
+
+!--------------------------------------------------------------------------------------------------!
 ! Description:
 ! ------------
 !> Initialize Lagrangian particle model
-!------------------------------------------------------------------------------! 
+!--------------------------------------------------------------------------------------------------!
  SUBROUTINE lpm_init
 
@@ -965 +942 @@
 
 !
-!-- In case of oceans runs, the vertical index calculations need an offset,
-!-- because otherwise the k indices will become negative
+!-- In case of oceans runs, the vertical index calculations need an offset, because otherwise the k
+!-- indices will become negative
     IF ( ocean_mode )  THEN
        offset_ocean_nzt    = nzt
@@ -973 +950 @@
 
 !
-!-- Define block offsets for dividing a gridcell in 8 sub cells
-!-- See documentation for List of subgrid boxes
-!-- See pack_and_sort in lpm_pack_arrays.f90 for assignment of the subgrid boxes
+!-- Define block offsets for dividing a gridcell in 8 sub cells.
+!-- See documentation for List of subgrid boxes.
+!-- See pack_and_sort in lpm_pack_arrays.f90 for assignment of the subgrid boxes.
     block_offset(0) = block_offset_def ( 0, 0, 0)
     block_offset(1) = block_offset_def ( 0, 0,-1)
@@ -987 +964 @@
 !-- Check the number of particle groups.
     IF ( number_of_particle_groups > max_number_of_particle_groups )  THEN
-       WRITE( message_string, * ) 'max_number_of_particle_groups =',           &
-                                  max_number_of_particle_groups ,              &
-                                  '&number_of_particle_groups reset to ',      &
+       WRITE( message_string, * ) 'max_number_of_particle_groups =',                               &
+                                  max_number_of_particle_groups ,                                  &
+                                  '&number_of_particle_groups reset to ',                          &
                                   max_number_of_particle_groups
        CALL message( 'lpm_init', 'PA0213', 0, 1, 0, 6, 0 )
@@ -995 +972 @@
     ENDIF
 !
-!-- Check if downward-facing walls exist. This case, reflection boundary
-!-- conditions (as well as subgrid-scale velocities) may do not work
-!-- propably (not realized so far).
+!-- Check if downward-facing walls exist. This case, reflection boundary conditions (as well as
+!-- subgrid-scale velocities) may do not work properly (not realized so far).
     IF ( surf_def_h(1)%ns >= 1 )  THEN
-       WRITE( message_string, * ) 'Overhanging topography do not work '//      &
+       WRITE( message_string, * ) 'Overhanging topography do not work '//                          &
                                   'with particles'
        CALL message( 'lpm_init', 'PA0212', 0, 1, 0, 6, 0 )
@@ -1019 +995 @@
 
 !
-!-- If number_particles_per_gridbox is set, the parametres pdx, pdy and pdz are
-!-- calculated diagnostically. Therfore an isotropic distribution is prescribed.
+!-- If number_particles_per_gridbox is set, the parametres pdx, pdy and pdz are calculated
+!-- diagnostically. Therfore an isotropic distribution is prescribed.
     IF ( number_particles_per_gridbox /= -1 .AND.   &
          number_particles_per_gridbox >= 1 )    THEN
@@ -1026 +1002 @@
              REAL(number_particles_per_gridbox))**0.3333333_wp
 !
-!--    Ensure a smooth value (two significant digits) of distance between
-!--    particles (pdx, pdy, pdz).
+!--    Ensure a smooth value (two significant digits) of distance between particles (pdx, pdy, pdz).
        div = 1000.0_wp
        DO  WHILE ( pdx(1) < div )
@@ -1066 +1041 @@
 
 !
-!-- Allocate array required for logarithmic vertical interpolation of
-!-- horizontal particle velocities between the surface and the first vertical
-!-- grid level. In order to avoid repeated CPU cost-intensive CALLS of
-!-- intrinsic FORTRAN procedure LOG(z/z0), LOG(z/z0) is precalculated for
+!-- Allocate array required for logarithmic vertical interpolation of horizontal particle velocities
+!-- between the surface and the first vertical grid level. In order to avoid repeated CPU
+!-- cost-intensive CALLS of intrinsic FORTRAN procedure LOG(z/z0), LOG(z/z0) is precalculated for
 !-- several heights. Splitting into 20 sublayers turned out to be sufficient.
-!-- To obtain exact height levels of particles, linear interpolation is applied
-!-- (see lpm_advec.f90).
+!-- To obtain exact height levels of particles, linear interpolation is applied (see lpm_advec.f90).
     IF ( constant_flux_layer )  THEN
 
@@ -1079 +1052 @@
 
 !
-!--    Calculate horizontal mean value of z0 used for logartihmic
-!--    interpolation. Note: this is not exact for heterogeneous z0.
-!--    However, sensitivity studies showed that the effect is
-!--    negligible.
-       z0_av_local  = SUM( surf_def_h(0)%z0 ) + SUM( surf_lsm_h%z0 ) +         &
-                      SUM( surf_usm_h%z0 )
+!--    Calculate horizontal mean value of z0 used for logartihmic interpolation. Note: this is not
+!--    exact for heterogeneous z0.
+!--    However, sensitivity studies showed that the effect is negligible.
+       z0_av_local  = SUM( surf_def_h(0)%z0 ) + SUM( surf_lsm_h%z0 ) + SUM( surf_usm_h%z0 )
        z0_av_global = 0.0_wp
 
 #if defined( __parallel )
-       CALL MPI_ALLREDUCE(z0_av_local, z0_av_global, 1, MPI_REAL, MPI_SUM, &
-                          comm2d, ierr )
+       CALL MPI_ALLREDUCE( z0_av_local, z0_av_global, 1, MPI_REAL, MPI_SUM, comm2d, ierr )
 #else
        z0_av_global = z0_av_local
@@ -1143 +1113 @@
 
        CASE DEFAULT
-          WRITE( message_string, * )  'unknown boundary condition ',           &
+          WRITE( message_string, * )  'unknown boundary condition ',                               &
                                        'bc_par_b = "', TRIM( bc_par_b ), '"'
           CALL message( 'lpm_init', 'PA0217', 1, 2, 0, 6, 0 )
@@ -1160 +1130 @@
 
        CASE DEFAULT
-          WRITE( message_string, * ) 'unknown boundary condition ',            &
+          WRITE( message_string, * ) 'unknown boundary condition ',                                &
                                      'bc_par_t = "', TRIM( bc_par_t ), '"'
           CALL message( 'lpm_init', 'PA0218', 1, 2, 0, 6, 0 )
@@ -1180 +1150 @@
 
        CASE DEFAULT
-          WRITE( message_string, * ) 'unknown boundary condition ',   &
+          WRITE( message_string, * ) 'unknown boundary condition ',                                &
                                      'bc_par_lr = "', TRIM( bc_par_lr ), '"'
           CALL message( 'lpm_init', 'PA0219', 1, 2, 0, 6, 0 )
@@ -1200 +1170 @@
 
        CASE DEFAULT
-          WRITE( message_string, * ) 'unknown boundary condition ',   &
+          WRITE( message_string, * ) 'unknown boundary condition ',                                &
                                      'bc_par_ns = "', TRIM( bc_par_ns ), '"'
           CALL message( 'lpm_init', 'PA0220', 1, 2, 0, 6, 0 )
@@ -1217 +1187 @@
 
        CASE DEFAULT
-          WRITE( message_string, * )  'unknown splitting_mode = "',            &
-                                      TRIM( splitting_mode ), '"'
+          WRITE( message_string, * )  'unknown splitting_mode = "', TRIM( splitting_mode ), '"'
           CALL message( 'lpm_init', 'PA0146', 1, 2, 0, 6, 0 )
 
@@ -1234 +1203 @@
 
        CASE DEFAULT
-          WRITE( message_string, * )  'unknown splitting function = "',        &
+          WRITE( message_string, * )  'unknown splitting function = "',                            &
                                        TRIM( splitting_function ), '"'
           CALL message( 'lpm_init', 'PA0147', 1, 2, 0, 6, 0 )
@@ -1244 +1213 @@
 
 !
-!-- For the first model run of a possible job chain initialize the
-!-- particles, otherwise read the particle data from restart file.
-    IF ( TRIM( initializing_actions ) == 'read_restart_data'  &
+!-- For the first model run of a possible job chain initialize the particles, otherwise read the
+!-- particle data from restart file.
+    IF ( TRIM( initializing_actions ) == 'read_restart_data'                                       &
          .AND.  read_particles_from_restartfile )  THEN
        CALL lpm_rrd_local_particles
     ELSE
 !
-!--    Allocate particle arrays and set attributes of the initial set of
-!--    particles, which can be also periodically released at later times.
-       ALLOCATE( prt_count(nzb:nzt+1,nysg:nyng,nxlg:nxrg), &
+!--    Allocate particle arrays and set attributes of the initial set of particles, which can be
+!--    also periodically released at later times.
+       ALLOCATE( prt_count(nzb:nzt+1,nysg:nyng,nxlg:nxrg),                                         &
                  grid_particles(nzb+1:nzt,nys:nyn,nxl:nxr) )
 
@@ -1259 +1228 @@
        prt_count           = 0
 !
-!--    initialize counter for particle IDs
+!--    Initialize counter for particle IDs
        grid_particles%id_counter = 1
 !
-!--    Initialize all particles with dummy values (otherwise errors may
-!--    occur within restart runs). The reason for this is still not clear
-!--    and may be presumably caused by errors in the respective user-interface.
-       zero_particle = particle_type( 0.0_wp, 0.0_wp, 0.0_wp, 0.0_wp, 0.0_wp,  &
-                                      0.0_wp, 0.0_wp, 0.0_wp, 0.0_wp, 0.0_wp,  &
-                                      0.0_wp, 0.0_wp, 0.0_wp, 0.0_wp, 0.0_wp,  &
-                                      0.0_wp, 0.0_wp, 0.0_wp, 0.0_wp, 0.0_wp,  &
+!--    Initialize all particles with dummy values (otherwise errors may occur within restart runs).
+!--    The reason for this is still not clear and may be presumably caused by errors in the
+!--    respective user-interface.
+       zero_particle = particle_type( 0.0_wp, 0.0_wp, 0.0_wp, 0.0_wp, 0.0_wp,                      &
+                                      0.0_wp, 0.0_wp, 0.0_wp, 0.0_wp, 0.0_wp,                      &
+                                      0.0_wp, 0.0_wp, 0.0_wp, 0.0_wp, 0.0_wp,                      &
+                                      0.0_wp, 0.0_wp, 0.0_wp, 0.0_wp, 0.0_wp,                      &
                                       0, 0, 0_idp, .FALSE., -1, -1 )
 
        particle_groups = particle_groups_type( 0.0_wp, 0.0_wp, 0.0_wp, 0.0_wp )
 !
-!--    Set values for the density ratio and radius for all particle
-!--    groups, if necessary
+!--    Set values for the density ratio and radius for all particle groups, if necessary.
        IF ( density_ratio(1) == 9999999.9_wp )  density_ratio(1) = 0.0_wp
        IF ( radius(1)        == 9999999.9_wp )  radius(1) = 0.0_wp
@@ -1286 +1254 @@
        DO  i = 1, number_of_particle_groups
           IF ( density_ratio(i) /= 0.0_wp  .AND.  radius(i) == 0 )  THEN
-             WRITE( message_string, * ) 'particle group #', i, ' has a',       &
+             WRITE( message_string, * ) 'particle group #', i, ' has a',                           &
                                         'density ratio /= 0 but radius = 0'
              CALL message( 'lpm_init', 'PA0215', 1, 2, 0, 6, 0 )
@@ -1295 +1263 @@
 
 !
-!--    Initialize parallel random number sequence seed for particles
+!--    Initialize parallel random number sequence seed for particles.
 !--    This is done separately here, as thus particle random numbers do not affect the random
 !--    numbers used for the flow field (e.g. for generating flow disturbances).
@@ -1301 +1269 @@
        seq_random_array_particles = 0
 
-!--    Initializing with random_seed_parallel for every vertical
-!--    gridpoint column.
+!--    Initializing with random_seed_parallel for every vertical gridpoint column.
        random_dummy = 0
        DO  i = nxl, nxr
@@ -1322 +1289 @@
        IF ( write_particle_statistics )  THEN
           CALL check_open( 80 )
-          WRITE ( 80, 8000 )  current_timestep_number, simulated_time,         &
-                              number_of_particles
+          WRITE ( 80, 8000 )  current_timestep_number, simulated_time, number_of_particles
           CALL close_file( 80 )
        ENDIF
@@ -1333 +1299 @@
 #endif
 
+!
 !-- next line is in preparation for particle data output
 !    CALL dop_init
@@ -1346 +1313 @@
 
  END SUBROUTINE lpm_init
- 
-!------------------------------------------------------------------------------!
+
+!--------------------------------------------------------------------------------------------------!
 ! Description:
 ! ------------
 !> Create Lagrangian particles
-!------------------------------------------------------------------------------!  
+!--------------------------------------------------------------------------------------------------!
  SUBROUTINE lpm_create_particle (phase)
 
@@ -1378 +1345 @@
     REAL(wp)                   ::  rand_contr !< dummy argument for random position
 
-    TYPE(particle_type),TARGET ::  tmp_particle !< temporary particle used for initialization
-
-
-!
-!-- Calculate particle positions and store particle attributes, if
-!-- particle is situated on this PE
+    TYPE(particle_type), TARGET ::  tmp_particle !< temporary particle used for initialization
+
+
+!
+!-- Calculate particle positions and store particle attributes, if particle is situated on this PE.
     DO  loop_stride = 1, 2
        first_stride = (loop_stride == 1)
@@ -1395 +1361 @@
 !--    Calculate initial_weighting_factor diagnostically
        IF ( number_concentration /= -1.0_wp  .AND.  number_concentration > 0.0_wp )  THEN
-          initial_weighting_factor =  number_concentration  *                           &
-                                      pdx(1) * pdy(1) * pdz(1)
+          initial_weighting_factor =  number_concentration * pdx(1) * pdy(1) * pdz(1)
        END IF
 
@@ -1406 +1371 @@
                 pos_y = pss(i)
                 DO WHILE ( pos_y <= psn(i) )
-                   IF ( pos_y >= nys * dy  .AND.                  &
-                        pos_y <  ( nyn + 1 ) * dy  )  THEN
+                   IF ( pos_y >= nys * dy  .AND.  pos_y <  ( nyn + 1 ) * dy  )  THEN
                       pos_x = psl(i)
                xloop: DO WHILE ( pos_x <= psr(i) )
-                         IF ( pos_x >= nxl * dx  .AND.            &
-                              pos_x <  ( nxr + 1) * dx )  THEN
+                         IF ( pos_x >= nxl * dx  .AND.  pos_x <  ( nxr + 1) * dx )  THEN
                             DO  j = 1, particles_per_point
                                n = n + 1
@@ -1450 +1413 @@
 !
 !--                            In case of stretching the actual k index is found iteratively
-                               IF ( dz_stretch_level /= -9999999.9_wp  .OR.           &
+                               IF ( dz_stretch_level /= -9999999.9_wp  .OR.                        &
                                     dz_stretch_level_start(1) /= -9999999.9_wp )  THEN
                                   kp = MAX( MINLOC( ABS( tmp_particle%z - zu ), DIM = 1 ) - 1, 1 )
@@ -1457 +1420 @@
                                ENDIF
 !
-!--                            Determine surface level. Therefore, check for
-!--                            upward-facing wall on w-grid. 
+!--                            Determine surface level. Therefore, check for upward-facing wall on
+!--                            w-grid.
                                k_surf = topo_top_ind(jp,ip,3)
                                IF ( seed_follows_topography )  THEN
@@ -1465 +1428 @@
                                   kp = kp + k_surf
                                   tmp_particle%z = tmp_particle%z + zw(k_surf)
-!--                               Skip particle release if particle position is
-!--                               above model top, or within topography in case
-!--                               of overhanging structures.
-                                  IF ( kp > nzt  .OR.                          &
-                                 .NOT. BTEST( wall_flags_total_0(kp,jp,ip), 0 ) )  THEN
+!
+!--                               Skip particle release if particle position is above model top, or
+!--                               within topography in case of overhanging structures.
+                                  IF ( kp > nzt  .OR.                                              &
+                                       .NOT. BTEST( wall_flags_total_0(kp,jp,ip), 0 ) )  THEN
                                      pos_x = pos_x + pdx(i)
                                      CYCLE xloop
                                   ENDIF
 !
-!--                            Skip particle release if particle position is
-!--                            below surface, or within topography in case
-!--                            of overhanging structures.
-                               ELSEIF ( .NOT. seed_follows_topography .AND.    &
-                                         tmp_particle%z <= zw(k_surf)  .OR.    &
-                                        .NOT. BTEST( wall_flags_total_0(kp,jp,ip), 0 ) )&
-                               THEN
+!--                            Skip particle release if particle position is below surface, or
+!--                            within topography in case of overhanging structures.
+                               ELSEIF ( .NOT. seed_follows_topography .AND.                        &
+                                         tmp_particle%z <= zw(k_surf)  .OR.                        &
+                                        .NOT. BTEST( wall_flags_total_0(kp,jp,ip), 0 ) )  THEN
                                   pos_x = pos_x + pdx(i)
                                   CYCLE xloop
@@ -1494 +1455 @@
                                      write(6,*) 'xu ',ip,jp,kp,nxr,nyn,nzt
                                   ENDIF
-                                  grid_particles(kp,jp,ip)%particles(local_count(kp,jp,ip)) = tmp_particle
+                                  grid_particles(kp,jp,ip)%particles(local_count(kp,jp,ip)) =      &
+                                                                                        tmp_particle
                                ENDIF
                             ENDDO
@@ -1513 +1475 @@
              DO  jp = nys, nyn
                 DO  kp = nzb+1, nzt
-                   IF ( phase == PHASE_INIT )  THEN
+                   IF ( phase == phase_init )  THEN
                       IF ( local_count(kp,jp,ip) > 0 )  THEN
-                         alloc_size = MAX( INT( local_count(kp,jp,ip) *        &
-                            ( 1.0_wp + alloc_factor / 100.0_wp ) ),            &
-                            1 )
+                         alloc_size = MAX( INT( local_count(kp,jp,ip) *                            &
+                                                ( 1.0_wp + alloc_factor / 100.0_wp ) ), 1 )
                       ELSE
                          alloc_size = 1
@@ -1525 +1486 @@
                          grid_particles(kp,jp,ip)%particles(n) = zero_particle
                       ENDDO
-                   ELSEIF ( phase == PHASE_RELEASE )  THEN
+                   ELSEIF ( phase == phase_release )  THEN
                       IF ( local_count(kp,jp,ip) > 0 )  THEN
                          new_size   = local_count(kp,jp,ip) + prt_count(kp,jp,ip)
-                         alloc_size = MAX( INT( new_size * ( 1.0_wp +          &
-                            alloc_factor / 100.0_wp ) ), 1 )
+                         alloc_size = MAX( INT( new_size * ( 1.0_wp +                              &
+                                                alloc_factor / 100.0_wp ) ), 1 )
                          IF( alloc_size > SIZE( grid_particles(kp,jp,ip)%particles) )  THEN
                             CALL realloc_particles_array( ip, jp, kp, alloc_size )
@@ -1555 +1516 @@
              DO  n = local_start(kp,jp,ip), number_of_particles  !only new particles
 
-                particles(n)%id = 10000_idp**3 * grid_particles(kp,jp,ip)%id_counter + &
+                particles(n)%id = 10000_idp**3 * grid_particles(kp,jp,ip)%id_counter +             &
                                   10000_idp**2 * kp + 10000_idp * jp + ip
 !
 !--             Count the number of particles that have been released before
-                grid_particles(kp,jp,ip)%id_counter =                          &
-                                         grid_particles(kp,jp,ip)%id_counter + 1
+                grid_particles(kp,jp,ip)%id_counter = grid_particles(kp,jp,ip)%id_counter + 1
 
              ENDDO
@@ -1585 +1545 @@
                 particles => grid_particles(kp,jp,ip)%particles(1:number_of_particles)
 !
-!--             Move only new particles. Moreover, limit random fluctuation
-!--             in order to prevent that particles move more than one grid box,
-!--             which would lead to problems concerning particle exchange
-!--             between processors in case pdx/pdy are larger than dx/dy,
+!--             Move only new particles. Moreover, limit random fluctuation in order to prevent that
+!--             particles move more than one grid box, which would lead to problems concerning
+!--             particle exchange between processors in case pdx/pdy are larger than dx/dy,
 !--             respectively.
                 DO  n = local_start(kp,jp,ip), number_of_particles
                    IF ( psl(particles(n)%group) /= psr(particles(n)%group) )  THEN
                       CALL random_number_parallel( random_dummy )
-                      rand_contr = ( random_dummy - 0.5_wp ) *                 &
-                                     pdx(particles(n)%group)
-                      particles(n)%x = particles(n)%x +                        &
-                              MERGE( rand_contr, SIGN( dx, rand_contr ),       &
-                                     ABS( rand_contr ) < dx                    &
-                                   )
+                      rand_contr = ( random_dummy - 0.5_wp ) * pdx(particles(n)%group)
+                      particles(n)%x = particles(n)%x +                                            &
+                                       MERGE( rand_contr, SIGN( dx, rand_contr ),                  &
+                                              ABS( rand_contr ) < dx                               &
+                                            )
                    ENDIF
                    IF ( pss(particles(n)%group) /= psn(particles(n)%group) )  THEN
                       CALL random_number_parallel( random_dummy )
-                      rand_contr = ( random_dummy - 0.5_wp ) *                 &
-                                     pdy(particles(n)%group)
-                      particles(n)%y = particles(n)%y +                        &
-                              MERGE( rand_contr, SIGN( dy, rand_contr ),       &
-                                     ABS( rand_contr ) < dy                    &
-                                   )
+                      rand_contr = ( random_dummy - 0.5_wp ) * pdy(particles(n)%group)
+                      particles(n)%y = particles(n)%y +                                            &
+                                       MERGE( rand_contr, SIGN( dy, rand_contr ),                  &
+                                              ABS( rand_contr ) < dy                               &
+                                            )
                    ENDIF
                    IF ( psb(particles(n)%group) /= pst(particles(n)%group) )  THEN
                       CALL random_number_parallel( random_dummy )
-                      rand_contr = ( random_dummy - 0.5_wp ) *                 &
-                                     pdz(particles(n)%group)
-                      particles(n)%z = particles(n)%z +                        &
-                              MERGE( rand_contr, SIGN( dzw(kp), rand_contr ),  &
-                                     ABS( rand_contr ) < dzw(kp)               &
-                                   )
+                      rand_contr = ( random_dummy - 0.5_wp ) * pdz(particles(n)%group)
+                      particles(n)%z = particles(n)%z +                                            &
+                                       MERGE( rand_contr, SIGN( dzw(kp), rand_contr ),             &
+                                              ABS( rand_contr ) < dzw(kp)                          &
+                                            )
                    ENDIF
                 ENDDO
 !
-!--             Identify particles located outside the model domain and reflect
-!--             or absorb them if necessary.
+!--             Identify particles located outside the model domain and reflect or absorb them if
+!--             necessary.
                 CALL lpm_boundary_conds( 'bottom/top', i, j, k )
 !
@@ -1627 +1583 @@
 !--             the particle speed is still zero at this point, wall
 !--             reflection boundary conditions will not work in this case.
-                particles =>                                                   &
-                       grid_particles(kp,jp,ip)%particles(1:number_of_particles)
+                particles =>  grid_particles(kp,jp,ip)%particles(1:number_of_particles)
                 DO  n = local_start(kp,jp,ip), number_of_particles
                    i = particles(n)%x * ddx
@@ -1660 +1615 @@
     ENDIF
 !
-!-- In case of random_start_position, delete particles identified by
-!-- lpm_exchange_horiz and lpm_boundary_conds. Then sort particles into blocks,
-!-- which is needed for a fast interpolation of the LES fields on the particle
-!-- position.
+!-- In case of random_start_position, delete particles identified by lpm_exchange_horiz and
+!-- lpm_boundary_conds. Then sort particles into blocks, which is needed for a fast interpolation of
+!-- the LES fields on the particle position.
     CALL lpm_sort_and_delete
 !
@@ -1670 +1624 @@
        DO  jp = nys, nyn
           DO  kp = nzb+1, nzt
-             number_of_particles         = number_of_particles                 &
-                                           + prt_count(kp,jp,ip)
+             number_of_particles         = number_of_particles + prt_count(kp,jp,ip)
           ENDDO
        ENDDO
@@ -1679 +1632 @@
 #if defined( __parallel )
     IF ( collective_wait )  CALL MPI_BARRIER( comm2d, ierr )
-    CALL MPI_ALLREDUCE( number_of_particles, total_number_of_particles, 1, &
-    MPI_INTEGER, MPI_SUM, comm2d, ierr )
+    CALL MPI_ALLREDUCE( number_of_particles, total_number_of_particles, 1, MPI_INTEGER, MPI_SUM,   &
+                        comm2d, ierr )
 #else
     total_number_of_particles = number_of_particles
@@ -1688 +1641 @@
 
  END SUBROUTINE lpm_create_particle
- 
- 
-!------------------------------------------------------------------------------!
+
+
+!--------------------------------------------------------------------------------------------------!
 ! Description:
 ! ------------
-!> This routine initialize the particles as aerosols with physio-chemical 
-!> properties. 
-!------------------------------------------------------------------------------!   
+!> This routine initializes the particles as aerosols with physio-chemical properties.
+!--------------------------------------------------------------------------------------------------!
  SUBROUTINE lpm_init_aerosols(local_start)
+
+    INTEGER(iwp) ::  ip             !<
+    INTEGER(iwp) ::  jp             !<
+    INTEGER(iwp) ::  kp             !<
+    INTEGER(iwp) ::  n              !<
+
+    INTEGER(iwp), DIMENSION(nzb:nzt+1,nysg:nyng,nxlg:nxrg), INTENT(IN) ::  local_start !<
 
     REAL(wp) ::  afactor            !< curvature effects
@@ -1703 +1662 @@
     REAL(wp) ::  e_a                !< vapor pressure
     REAL(wp) ::  e_s                !< saturation vapor pressure
+    REAL(wp) ::  rmax = 10.0e-6_wp  !< maximum aerosol radius
     REAL(wp) ::  rmin = 0.005e-6_wp !< minimum aerosol radius
-    REAL(wp) ::  rmax = 10.0e-6_wp  !< maximum aerosol radius
+    REAL(wp) ::  r_l                !< left radius of bin
     REAL(wp) ::  r_mid              !< mean radius of bin
-    REAL(wp) ::  r_l                !< left radius of bin
     REAL(wp) ::  r_r                !< right radius of bin
     REAL(wp) ::  sigma              !< surface tension
     REAL(wp) ::  t_int              !< temperature
 
-    INTEGER(iwp), DIMENSION(nzb:nzt+1,nysg:nyng,nxlg:nxrg), INTENT(IN) ::  local_start !<
-
-    INTEGER(iwp) ::  n              !<
-    INTEGER(iwp) ::  ip             !<
-    INTEGER(iwp) ::  jp             !<
-    INTEGER(iwp) ::  kp             !<
 
 !
 !-- Set constants for different aerosol species
     IF ( TRIM( aero_species ) == 'nacl' )  THEN
-       molecular_weight_of_solute = 0.05844_wp 
+       molecular_weight_of_solute = 0.05844_wp
        rho_s                      = 2165.0_wp
        vanthoff                   = 2.0_wp
     ELSEIF ( TRIM( aero_species ) == 'c3h4o4' )  THEN
-       molecular_weight_of_solute = 0.10406_wp 
+       molecular_weight_of_solute = 0.10406_wp
        rho_s                      = 1600.0_wp
        vanthoff                   = 1.37_wp
     ELSEIF ( TRIM( aero_species ) == 'nh4o3' )  THEN
-       molecular_weight_of_solute = 0.08004_wp 
+       molecular_weight_of_solute = 0.08004_wp
        rho_s                      = 1720.0_wp
        vanthoff                   = 2.31_wp
     ELSE
-       WRITE( message_string, * ) 'unknown aerosol species ',   &
-                                'aero_species = "', TRIM( aero_species ), '"'
+       WRITE( message_string, * ) 'unknown aerosol species ',                                      &
+                                  'aero_species = "', TRIM( aero_species ), '"'
        CALL message( 'lpm_init', 'PA0470', 1, 2, 0, 6, 0 )
     ENDIF
@@ -1771 +1724 @@
        CONTINUE
     ELSE
-       WRITE( message_string, * ) 'unknown aerosol type ',   &
-                                'aero_type = "', TRIM( aero_type ), '"'
+       WRITE( message_string, * ) 'unknown aerosol type ',                                         &
+                                  'aero_type = "', TRIM( aero_type ), '"'
        CALL message( 'lpm_init', 'PA0459', 1, 2, 0, 6, 0 )
     ENDIF
@@ -1787 +1740 @@
              particles => grid_particles(kp,jp,ip)%particles(1:number_of_particles)
 
-             dlogr   = ( LOG10(rmax) - LOG10(rmin) ) / ( number_of_particles - local_start(kp,jp,ip) + 1 )
-!
-!--          Initialize the aerosols with a predefined spectral distribution
-!--          of the dry radius (logarithmically increasing bins) and a varying
-!--          weighting factor
+             dlogr   = ( LOG10( rmax ) - LOG10( rmin ) ) /                                         &
+                       ( number_of_particles - local_start(kp,jp,ip) + 1 )
+!
+!--          Initialize the aerosols with a predefined spectral distribution of the dry radius
+!--          (logarithmically increasing bins) and a varying weighting factor.
              DO  n = local_start(kp,jp,ip), number_of_particles  !only new particles
 
@@ -1799 +1752 @@
 
                 particles(n)%aux1          = r_mid
-                particles(n)%weight_factor =                                           &
-                   ( na(1) / ( SQRT( 2.0_wp * pi ) * log_sigma(1) ) *                     &
-                     EXP( - LOG10( r_mid / rm(1) )**2 / ( 2.0_wp * log_sigma(1)**2 ) ) +  &
-                     na(2) / ( SQRT( 2.0_wp * pi ) * log_sigma(2) ) *                     &
-                     EXP( - LOG10( r_mid / rm(2) )**2 / ( 2.0_wp * log_sigma(2)**2 ) ) +  &
-                     na(3) / ( SQRT( 2.0_wp * pi ) * log_sigma(3) ) *                     &
-                     EXP( - LOG10( r_mid / rm(3) )**2 / ( 2.0_wp * log_sigma(3)**2 ) )    &
-                   ) * ( LOG10(r_r) - LOG10(r_l) ) * ( dx * dy * dzw(kp) )
-
-!
-!--             Multiply weight_factor with the namelist parameter aero_weight
-!--             to increase or decrease the number of simulated aerosols
+                particles(n)%weight_factor =                                                       &
+                   ( na(1) / ( SQRT( 2.0_wp * pi ) * log_sigma(1) ) *                              &
+                     EXP( - LOG10( r_mid / rm(1) )**2 / ( 2.0_wp * log_sigma(1)**2 ) ) +           &
+                     na(2) / ( SQRT( 2.0_wp * pi ) * log_sigma(2) ) *                              &
+                     EXP( - LOG10( r_mid / rm(2) )**2 / ( 2.0_wp * log_sigma(2)**2 ) ) +           &
+                     na(3) / ( SQRT( 2.0_wp * pi ) * log_sigma(3) ) *                              &
+                     EXP( - LOG10( r_mid / rm(3) )**2 / ( 2.0_wp * log_sigma(3)**2 ) )             &
+                   ) * ( LOG10( r_r ) - LOG10( r_l ) ) * ( dx * dy * dzw(kp) )
+
+!
+!--             Multiply weight_factor with the namelist parameter aero_weight to increase or
+!--             decrease the number of simulated aerosols
                 particles(n)%weight_factor = particles(n)%weight_factor * aero_weight
 !
 !--             Create random numver with parallel number generator
                 CALL random_number_parallel( random_dummy )
-                IF ( particles(n)%weight_factor - FLOOR(particles(n)%weight_factor,KIND=wp) &
+                IF ( particles(n)%weight_factor - FLOOR( particles(n)%weight_factor, KIND=wp )     &
                      > random_dummy )  THEN
-                   particles(n)%weight_factor = FLOOR(particles(n)%weight_factor,KIND=wp) + 1.0_wp
+                   particles(n)%weight_factor = FLOOR( particles(n)%weight_factor, KIND=wp )       &
+                                                + 1.0_wp
                 ELSE
-                   particles(n)%weight_factor = FLOOR(particles(n)%weight_factor,KIND=wp)
+                   particles(n)%weight_factor = FLOOR( particles(n)%weight_factor, KIND=wp )
                 ENDIF
 !
@@ -1827 +1781 @@
              ENDDO
 !
-!--          Set particle radius to equilibrium radius based on the environmental
-!--          supersaturation (Khvorostyanov and Curry, 2007, JGR). This avoids
-!--          the sometimes lengthy growth toward their equilibrium radius within
-!--          the simulation.
+!--          Set particle radius to equilibrium radius based on the environmental supersaturation
+!--          (Khvorostyanov and Curry, 2007, JGR). This avoids the sometimes lengthy growth toward
+!--          their equilibrium radius within the simulation.
              t_int  = pt(kp,jp,ip) * exner(kp)
 
@@ -1839 +1792 @@
              afactor = 2.0_wp * sigma / ( rho_l * r_v * t_int )
 
-             bfactor = vanthoff * molecular_weight_of_water *    &
+             bfactor = vanthoff * molecular_weight_of_water *                                      &
                        rho_s / ( molecular_weight_of_solute * rho_l )
 !
-!--          The formula is only valid for subsaturated environments. For
-!--          supersaturations higher than -5 %, the supersaturation is set to -5%.
+!--          The formula is only valid for subsaturated environments. For supersaturations higher
+!--          than -5 %, the supersaturation is set to -5%.
              IF ( e_a / e_s >= 0.95_wp )  e_a = 0.95_wp * e_s
 
@@ -1850 +1803 @@
 !--             For details on this equation, see Eq. (14) of Khvorostyanov and
 !--             Curry (2007, JGR)
-                particles(n)%radius = bfactor**0.3333333_wp *                  &
-                   particles(n)%aux1 / ( 1.0_wp - e_a / e_s )**0.3333333_wp / &
-                   ( 1.0_wp + ( afactor / ( 3.0_wp * bfactor**0.3333333_wp *   &
-                     particles(n)%aux1 ) ) /                                  &
-                     ( 1.0_wp - e_a / e_s )**0.6666666_wp                      &
-                   )
+                particles(n)%radius = bfactor**0.3333333_wp *                                      &
+                                      particles(n)%aux1 / ( 1.0_wp - e_a / e_s )**0.3333333_wp /   &
+                                      ( 1.0_wp + ( afactor / ( 3.0_wp * bfactor**0.3333333_wp *    &
+                                        particles(n)%aux1 ) ) /                                    &
+                                       ( 1.0_wp - e_a / e_s )**0.6666666_wp                        &
+                                      )
 
              ENDDO
@@ -1869 +1822 @@
 
 
-!------------------------------------------------------------------------------!
+!--------------------------------------------------------------------------------------------------!
 ! Description:
 ! ------------
-!> Calculates quantities required for considering the SGS velocity fluctuations
-!> in the particle transport by a stochastic approach. The respective
-!> quantities are: SGS-TKE gradients and horizontally averaged profiles of the
-!> SGS TKE and the resolved-scale velocity variances. 
-!------------------------------------------------------------------------------!
+!> Calculates quantities required for considering the SGS velocity fluctuations in the particle
+!> transport by a stochastic approach. The respective quantities are: SGS-TKE gradients and
+!> horizontally averaged profiles of the SGS TKE and the resolved-scale velocity variances.
+!--------------------------------------------------------------------------------------------------!
  SUBROUTINE lpm_init_sgs_tke
 
-    USE exchange_horiz_mod,                                                    &
+    USE exchange_horiz_mod,                                                                        &
         ONLY:  exchange_horiz
 
-    USE statistics,                                                            &
+    USE statistics,                                                                                &
         ONLY:  flow_statistics_called, hom, sums, sums_l
 
@@ -1888 +1840 @@
     INTEGER(iwp) ::  j      !< index variable along y
     INTEGER(iwp) ::  k      !< index variable along z
-    INTEGER(iwp) ::  m      !< running index for the surface elements 
+    INTEGER(iwp) ::  m      !< running index for the surface elements
 
     REAL(wp) ::  flag1      !< flag to mask topography
@@ -1898 +1850 @@
           DO  k = nzb, nzt+1
 
-             IF ( .NOT. BTEST( wall_flags_total_0(k,j,i-1), 0 )  .AND.         &
-                        BTEST( wall_flags_total_0(k,j,i), 0   )  .AND.         &
-                        BTEST( wall_flags_total_0(k,j,i+1), 0 ) )              &
+             IF ( .NOT. BTEST( wall_flags_total_0(k,j,i-1), 0 )  .AND.                             &
+                        BTEST( wall_flags_total_0(k,j,i), 0   )  .AND.                             &
+                        BTEST( wall_flags_total_0(k,j,i+1), 0 ) )                                  &
              THEN
-                de_dx(k,j,i) = 2.0_wp * sgs_wf_part *                          &
-                               ( e(k,j,i+1) - e(k,j,i) ) * ddx
-             ELSEIF ( BTEST( wall_flags_total_0(k,j,i-1), 0 )  .AND.           &
-                      BTEST( wall_flags_total_0(k,j,i), 0   )  .AND.           &
-                .NOT. BTEST( wall_flags_total_0(k,j,i+1), 0 ) )                &
+                de_dx(k,j,i) = 2.0_wp * sgs_wf_part * ( e(k,j,i+1) - e(k,j,i) ) * ddx
+             ELSEIF ( BTEST( wall_flags_total_0(k,j,i-1), 0 )  .AND.                               &
+                      BTEST( wall_flags_total_0(k,j,i), 0   )  .AND.                               &
+                .NOT. BTEST( wall_flags_total_0(k,j,i+1), 0 ) )                                    &
              THEN
-                de_dx(k,j,i) = 2.0_wp * sgs_wf_part *                          &
-                               ( e(k,j,i) - e(k,j,i-1) ) * ddx
-             ELSEIF ( .NOT. BTEST( wall_flags_total_0(k,j,i), 22   )  .AND.    &
-                      .NOT. BTEST( wall_flags_total_0(k,j,i+1), 22 ) )         &   
+                de_dx(k,j,i) = 2.0_wp * sgs_wf_part * ( e(k,j,i) - e(k,j,i-1) ) * ddx
+             ELSEIF ( .NOT. BTEST( wall_flags_total_0(k,j,i), 22   )  .AND.                        &
+                      .NOT. BTEST( wall_flags_total_0(k,j,i+1), 22 ) )                             &
              THEN
                 de_dx(k,j,i) = 0.0_wp
-             ELSEIF ( .NOT. BTEST( wall_flags_total_0(k,j,i-1), 22 )  .AND.    &
-                      .NOT. BTEST( wall_flags_total_0(k,j,i), 22   ) )         &
+             ELSEIF ( .NOT. BTEST( wall_flags_total_0(k,j,i-1), 22 )  .AND.                        &
+                      .NOT. BTEST( wall_flags_total_0(k,j,i), 22   ) )                             &
              THEN
                 de_dx(k,j,i) = 0.0_wp
@@ -1922 +1872 @@
              ENDIF
 
-             IF ( .NOT. BTEST( wall_flags_total_0(k,j-1,i), 0 )  .AND.         &
-                        BTEST( wall_flags_total_0(k,j,i), 0   )  .AND.         &
-                        BTEST( wall_flags_total_0(k,j+1,i), 0 ) )              &
+             IF ( .NOT. BTEST( wall_flags_total_0(k,j-1,i), 0 )  .AND.                             &
+                        BTEST( wall_flags_total_0(k,j,i), 0   )  .AND.                             &
+                        BTEST( wall_flags_total_0(k,j+1,i), 0 ) )                                  &
              THEN
-                de_dy(k,j,i) = 2.0_wp * sgs_wf_part *                          &
-                               ( e(k,j+1,i) - e(k,j,i) ) * ddy
-             ELSEIF ( BTEST( wall_flags_total_0(k,j-1,i), 0 )  .AND.           &
-                      BTEST( wall_flags_total_0(k,j,i), 0   )  .AND.           &
-                .NOT. BTEST( wall_flags_total_0(k,j+1,i), 0 ) )                &
+                de_dy(k,j,i) = 2.0_wp * sgs_wf_part * ( e(k,j+1,i) - e(k,j,i) ) * ddy
+             ELSEIF ( BTEST( wall_flags_total_0(k,j-1,i), 0 )  .AND.                               &
+                      BTEST( wall_flags_total_0(k,j,i), 0   )  .AND.                               &
+                .NOT. BTEST( wall_flags_total_0(k,j+1,i), 0 ) )                                    &
              THEN
-                de_dy(k,j,i) = 2.0_wp * sgs_wf_part *                          &
-                               ( e(k,j,i) - e(k,j-1,i) ) * ddy
-             ELSEIF ( .NOT. BTEST( wall_flags_total_0(k,j,i), 22   )  .AND.    &
-                      .NOT. BTEST( wall_flags_total_0(k,j+1,i), 22 ) )         &   
+                de_dy(k,j,i) = 2.0_wp * sgs_wf_part * ( e(k,j,i) - e(k,j-1,i) ) * ddy
+             ELSEIF ( .NOT. BTEST( wall_flags_total_0(k,j,i), 22   )  .AND.                        &
+                      .NOT. BTEST( wall_flags_total_0(k,j+1,i), 22 ) )                             &
              THEN
                 de_dy(k,j,i) = 0.0_wp
-             ELSEIF ( .NOT. BTEST( wall_flags_total_0(k,j-1,i), 22 )  .AND.    &
-                      .NOT. BTEST( wall_flags_total_0(k,j,i), 22   ) )         &
+             ELSEIF ( .NOT. BTEST( wall_flags_total_0(k,j-1,i), 22 )  .AND.                        &
+                      .NOT. BTEST( wall_flags_total_0(k,j,i), 22   ) )                             &
              THEN
                 de_dy(k,j,i) = 0.0_wp
@@ -1959 +1907 @@
              flag1 = MERGE( 1.0_wp, 0.0_wp, BTEST( wall_flags_total_0(k,j,i), 0  ) )
 
-             de_dz(k,j,i) = 2.0_wp * sgs_wf_part *                             &
-                           ( e(k+1,j,i) - e(k-1,j,i) ) / ( zu(k+1) - zu(k-1) ) &
-                                                 * flag1 
+             de_dz(k,j,i) = 2.0_wp * sgs_wf_part *                                                 &
+                           ( e(k+1,j,i) - e(k-1,j,i) ) / ( zu(k+1) - zu(k-1) ) * flag1
           ENDDO
 !
@@ -1967 +1914 @@
           DO  m = bc_h(0)%start_index(j,i), bc_h(0)%end_index(j,i)
              k            = bc_h(0)%k(m)
-             de_dz(k,j,i) = 2.0_wp * sgs_wf_part *                             &
-                           ( e(k+1,j,i) - e(k,j,i)   ) / ( zu(k+1) - zu(k) )
+             de_dz(k,j,i) = 2.0_wp * sgs_wf_part * ( e(k+1,j,i) - e(k,j,i) ) / ( zu(k+1) - zu(k) )
           ENDDO
 !
@@ -1974 +1920 @@
           DO  m = bc_h(1)%start_index(j,i), bc_h(1)%end_index(j,i)
              k            = bc_h(1)%k(m)
-             de_dz(k,j,i) = 2.0_wp * sgs_wf_part *                             &
-                           ( e(k,j,i) - e(k-1,j,i)   ) / ( zu(k) - zu(k-1) )
+             de_dz(k,j,i) = 2.0_wp * sgs_wf_part * ( e(k,j,i) - e(k-1,j,i) ) / ( zu(k) - zu(k-1) )
           ENDDO
 
@@ -1990 +1935 @@
     CALL exchange_horiz( diss, nbgp  )
 !
-!-- Set boundary conditions at non-periodic boundaries. Note, at non-period
-!-- boundaries zero-gradient boundary conditions are set for the subgrid TKE.
-!-- Thus, TKE gradients normal to the respective lateral boundaries are zero, 
-!-- while tangetial TKE gradients then must be the same as within the prognostic
-!-- domain.  
+!-- Set boundary conditions at non-periodic boundaries. Note, at non-period boundaries zero-gradient
+!-- boundary conditions are set for the subgrid TKE.
+!-- Thus, TKE gradients normal to the respective lateral boundaries are zero,
+!-- while tangetial TKE gradients then must be the same as within the prognostic domain.
     IF ( bc_dirichlet_l )  THEN
        de_dx(:,:,-1) = 0.0_wp
-       de_dy(:,:,-1) = de_dy(:,:,0) 
+       de_dy(:,:,-1) = de_dy(:,:,0)
        de_dz(:,:,-1) = de_dz(:,:,0)
     ENDIF
     IF ( bc_dirichlet_r )  THEN
        de_dx(:,:,nxr+1) = 0.0_wp
-       de_dy(:,:,nxr+1) = de_dy(:,:,nxr) 
+       de_dy(:,:,nxr+1) = de_dy(:,:,nxr)
        de_dz(:,:,nxr+1) = de_dz(:,:,nxr)
     ENDIF
     IF ( bc_dirichlet_n )  THEN
        de_dx(:,nyn+1,:) = de_dx(:,nyn,:)
-       de_dy(:,nyn+1,:) = 0.0_wp 
+       de_dy(:,nyn+1,:) = 0.0_wp
        de_dz(:,nyn+1,:) = de_dz(:,nyn,:)
     ENDIF
     IF ( bc_dirichlet_s )  THEN
        de_dx(:,nys-1,:) = de_dx(:,nys,:)
-       de_dy(:,nys-1,:) = 0.0_wp 
+       de_dy(:,nys-1,:) = 0.0_wp
        de_dz(:,nys-1,:) = de_dz(:,nys,:)
-    ENDIF  
-!
-!-- Calculate the horizontally averaged profiles of SGS TKE and resolved
-!-- velocity variances (they may have been already calculated in routine
-!-- flow_statistics).
+    ENDIF
+!
+!-- Calculate the horizontally averaged profiles of SGS TKE and resolved velocity variances (they
+!-- may have been already calculated in routine flow_statistics).
     IF ( .NOT. flow_statistics_called )  THEN
 
 !
-!--    First calculate horizontally averaged profiles of the horizontal
-!--    velocities.
+!--    First calculate horizontally averaged profiles of the horizontal velocities.
        sums_l(:,1,0) = 0.0_wp
        sums_l(:,2,0) = 0.0_wp
@@ -2044 +1986 @@
 !--    Compute total sum from local sums
        IF ( collective_wait )  CALL MPI_BARRIER( comm2d, ierr )
-       CALL MPI_ALLREDUCE( sums_l(nzb,1,0), sums(nzb,1), nzt+2-nzb, &
-                           MPI_REAL, MPI_SUM, comm2d, ierr )
+       CALL MPI_ALLREDUCE( sums_l(nzb,1,0), sums(nzb,1), nzt+2-nzb, MPI_REAL, MPI_SUM, comm2d,     &
+                           ierr )
        IF ( collective_wait )  CALL MPI_BARRIER( comm2d, ierr )
-       CALL MPI_ALLREDUCE( sums_l(nzb,2,0), sums(nzb,2), nzt+2-nzb, &
-                              MPI_REAL, MPI_SUM, comm2d, ierr )
+       CALL MPI_ALLREDUCE( sums_l(nzb,2,0), sums(nzb,2), nzt+2-nzb, MPI_REAL, MPI_SUM, comm2d,     &
+                           ierr )
 #else
        sums(:,1) = sums_l(:,1,0)
@@ -2055 +1997 @@
 
 !
-!--    Final values are obtained by division by the total number of grid
-!--    points used for the summation.
+!--    Final values are obtained by division by the total number of grid points used for the
+!--    summation.
        hom(:,1,1,0) = sums(:,1) / ngp_2dh_outer(:,0)   ! u
        hom(:,1,2,0) = sums(:,2) / ngp_2dh_outer(:,0)   ! v
 
 !
-!--    Now calculate the profiles of SGS TKE and the resolved-scale
-!--    velocity variances
+!--    Now calculate the profiles of SGS TKE and the resolved-scale velocity variances
        sums_l(:,8,0)  = 0.0_wp
        sums_l(:,30,0) = 0.0_wp
@@ -2086 +2027 @@
 !--    Compute total sum from local sums
        IF ( collective_wait )  CALL MPI_BARRIER( comm2d, ierr )
-       CALL MPI_ALLREDUCE( sums_l(nzb,8,0), sums(nzb,8), nzt+2-nzb, &
-                           MPI_REAL, MPI_SUM, comm2d, ierr )
+       CALL MPI_ALLREDUCE( sums_l(nzb,8,0), sums(nzb,8), nzt+2-nzb, MPI_REAL, MPI_SUM, comm2d,     &
+                           ierr )
        IF ( collective_wait )  CALL MPI_BARRIER( comm2d, ierr )
-       CALL MPI_ALLREDUCE( sums_l(nzb,30,0), sums(nzb,30), nzt+2-nzb, &
-                           MPI_REAL, MPI_SUM, comm2d, ierr )
+       CALL MPI_ALLREDUCE( sums_l(nzb,30,0), sums(nzb,30), nzt+2-nzb, MPI_REAL, MPI_SUM, comm2d,   &
+                           ierr )
        IF ( collective_wait )  CALL MPI_BARRIER( comm2d, ierr )
-       CALL MPI_ALLREDUCE( sums_l(nzb,31,0), sums(nzb,31), nzt+2-nzb, &
-                           MPI_REAL, MPI_SUM, comm2d, ierr )
+       CALL MPI_ALLREDUCE( sums_l(nzb,31,0), sums(nzb,31), nzt+2-nzb, MPI_REAL, MPI_SUM, comm2d,   &
+                           ierr )
        IF ( collective_wait )  CALL MPI_BARRIER( comm2d, ierr )
-       CALL MPI_ALLREDUCE( sums_l(nzb,32,0), sums(nzb,32), nzt+2-nzb, &
-                           MPI_REAL, MPI_SUM, comm2d, ierr )
+       CALL MPI_ALLREDUCE( sums_l(nzb,32,0), sums(nzb,32), nzt+2-nzb, MPI_REAL, MPI_SUM, comm2d,   &
+                           ierr )
 
 #else
@@ -2106 +2047 @@
 
 !
-!--    Final values are obtained by division by the total number of grid
-!--    points used for the summation.
+!--    Final values are obtained by division by the total number of grid points used for the
+!--    summation.
        hom(:,1,8,0)  = sums(:,8)  / ngp_2dh_outer(:,0)   ! e
        hom(:,1,30,0) = sums(:,30) / ngp_2dh_outer(:,0)   ! u*2
-       hom(:,1,31,0) = sums(:,31) / ngp_2dh_outer(:,0)   ! v*2 
+       hom(:,1,31,0) = sums(:,31) / ngp_2dh_outer(:,0)   ! v*2
        hom(:,1,32,0) = sums(:,32) / ngp_2dh_outer(:,0)   ! w*2
 
@@ -2116 +2057 @@
 
  END SUBROUTINE lpm_init_sgs_tke
- 
- 
-!------------------------------------------------------------------------------!
+
+
+!--------------------------------------------------------------------------------------------------!
 ! Description:
 ! ------------
-!> Sobroutine control lpm actions, i.e. all actions during one time step. 
-!------------------------------------------------------------------------------!  
+!> Sobroutine control lpm actions, i.e. all actions during one time step.
+!--------------------------------------------------------------------------------------------------!
  SUBROUTINE lpm_actions( location )
 
-    USE exchange_horiz_mod,                                                    &
+    USE exchange_horiz_mod,                                                                        &
         ONLY:  exchange_horiz
 
@@ -2152 +2093 @@
 !--       The particle model is executed if particle advection start is reached and only at the end
 !--       of the intermediate time step loop.
-          IF ( time_since_reference_point >= particle_advection_start   &
+          IF ( time_since_reference_point >= particle_advection_start                              &
                .AND.  intermediate_timestep_count == intermediate_timestep_count_max )             &
           THEN
@@ -2158 +2099 @@
 !
 !--          Write particle data at current time on file.
-!--          This has to be done here, before particles are further processed,
-!--          because they may be deleted within this timestep (in case that
-!--          dt_write_particle_data = dt_prel = particle_maximum_age).
+!--          This has to be done here, before particles are further processed, because they may be
+!--          deleted within this timestep (in case that dt_write_particle_data = dt_prel =
+!--          particle_maximum_age).
              time_write_particle_data = time_write_particle_data + dt_3d
              IF ( time_write_particle_data >= dt_write_particle_data )  THEN
@@ -2166 +2107 @@
                 CALL lpm_data_output_particles
 !
-!--          The MOD function allows for changes in the output interval with restart
-!--          runs.
-                time_write_particle_data = MOD( time_write_particle_data, &
+!--          The MOD function allows for changes in the output interval with restart runs.
+                time_write_particle_data = MOD( time_write_particle_data,                          &
                                            MAX( dt_write_particle_data, dt_3d ) )
              ENDIF
 
 !
-!--          Initialize arrays for marking those particles to be deleted after the
-!--          (sub-) timestep
+!--          Initialize arrays for marking those particles to be deleted after the (sub-) timestep.
              deleted_particles = 0
 
 !
-!--          Initialize variables used for accumulating the number of particles
-!--          xchanged between the subdomains during all sub-timesteps (if sgs
-!--          velocities are included). These data are output further below on the
-!--          particle statistics file.
+!--          Initialize variables used for accumulating the number of particles exchanged between
+!--          the subdomains during all sub-timesteps (if sgs velocities are included). These data
+!--          are output further below on the particle statistics file.
              trlp_count_sum      = 0
              trlp_count_recv_sum = 0
@@ -2195 +2133 @@
              DO  m = 1, number_of_particle_groups
                 IF ( particle_groups(m)%density_ratio /= 0.0_wp )  THEN
-                   particle_groups(m)%exp_arg  =                                        &
-                             4.5_wp * particle_groups(m)%density_ratio *                &
-                             molecular_viscosity / ( particle_groups(m)%radius )**2
-
-                   particle_groups(m)%exp_term = EXP( -particle_groups(m)%exp_arg *     &
-                             dt_3d )
+                   particle_groups(m)%exp_arg  = 4.5_wp * particle_groups(m)%density_ratio *       &
+                                                 molecular_viscosity /                             &
+                                                 ( particle_groups(m)%radius )**2
+
+                   particle_groups(m)%exp_term = EXP( -particle_groups(m)%exp_arg * dt_3d )
                 ENDIF
              ENDDO
 !
 !--          If necessary, release new set of particles
-             IF ( ( simulated_time - last_particle_release_time ) >= dt_prel  .AND.     &
+             IF ( ( simulated_time - last_particle_release_time ) >= dt_prel  .AND.                &
                     end_time_prel > simulated_time )  THEN
                 DO WHILE ( ( simulated_time - last_particle_release_time ) >= dt_prel )
-                   CALL lpm_create_particle( PHASE_RELEASE )
+                   CALL lpm_create_particle( phase_release )
                    last_particle_release_time = last_particle_release_time + dt_prel
                 ENDDO
@@ -2224 +2161 @@
 !
 !--          Timestep loop for particle advection.
-!--          This loop has to be repeated until the advection time of every particle
-!--          (within the total domain!) has reached the LES timestep (dt_3d).
-!--          In case of including the SGS velocities, the particle timestep may be
-!--          smaller than the LES timestep (because of the Lagrangian timescale
-!--          restriction) and particles may require to undergo several particle
-!--          timesteps, before the LES timestep is reached. Because the number of these
-!--          particle timesteps to be carried out is unknown at first, these steps are
-!--          carried out in the following infinite loop with exit condition.
+!--          This loop has to be repeated until the advection time of every particle (within the
+!--          total domain!) has reached the LES timestep (dt_3d).
+!--          In case of including the SGS velocities, the particle timestep may be smaller than the
+!--          LES timestep (because of the Lagrangian timescale restriction) and particles may
+!--          require to undergo several particle timesteps, before the LES timestep is reached.
+!--          Because the number of these particle timesteps to be carried out is unknown at first,
+!--          these steps are carried out in the following infinite loop with exit condition.
              DO
                 CALL cpu_log( log_point_s(44), 'lpm_advec', 'start' )
@@ -2237 +2173 @@
 
 !
-!--             If particle advection includes SGS velocity components, calculate the
-!--             required SGS quantities (i.e. gradients of the TKE, as well as
-!--             horizontally averaged profiles of the SGS TKE and the resolved-scale
-!--             velocity variances)
+!--             If particle advection includes SGS velocity components, calculate the required SGS
+!--             quantities (i.e. gradients of the TKE, as well as horizontally averaged profiles of
+!--             the SGS TKE and the resolved-scale velocity variances)
                 IF ( use_sgs_for_particles  .AND.  .NOT. cloud_droplets )  THEN
                    CALL lpm_init_sgs_tke
                 ENDIF
 !
-!--             In case SGS-particle speed is considered, particles may carry out
-!--             several particle timesteps. In order to prevent unnecessary
-!--             treatment of particles that already reached the final time level,
-!--             particles are sorted into contiguous blocks of finished and
-!--             not-finished particles, in addition to their already sorting
+!--             In case SGS-particle speed is considered, particles may carry out several particle
+!--             timesteps. In order to prevent unnecessary treatment of particles that already
+!--             reached the final time level, particles are sorted into contiguous blocks of
+!--             finished and not-finished particles, in addition to their already sorting
 !--             according to their sub-boxes.
-                IF ( .NOT. first_loop_stride  .AND.  use_sgs_for_particles )            &
+                IF ( .NOT. first_loop_stride  .AND.  use_sgs_for_particles )                       &
                    CALL lpm_sort_timeloop_done
                 DO  i = nxl, nxr
@@ -2276 +2210 @@
                          particles(1:number_of_particles)%particle_mask = .TRUE.
 !
-!--                      Initialize the variable storing the total time that a particle
-!--                      has advanced within the timestep procedure
+!--                      Initialize the variable storing the total time that a particle has advanced
+!--                      within the timestep procedure.
                          IF ( first_loop_stride )  THEN
                             particles(1:number_of_particles)%dt_sum = 0.0_wp
                          ENDIF
 !
-!--                      Particle (droplet) growth by condensation/evaporation and
-!--                      collision
+!--                      Particle (droplet) growth by condensation/evaporation and collision
                          IF ( cloud_droplets  .AND.  first_loop_stride)  THEN
 !
@@ -2296 +2229 @@
                          ENDIF
 !
-!--                      Initialize the switch used for the loop exit condition checked
-!--                      at the end of this loop. If at least one particle has failed to
-!--                      reach the LES timestep, this switch will be set false in
-!--                      lpm_advec.
+!--                      Initialize the switch used for the loop exit condition checked at the end
+!--                      of this loop. If at least one particle has failed to reach the LES
+!--                      timestep, this switch will be set false in lpm_advec.
                          dt_3d_reached_l = .TRUE.
 
@@ -2306 +2238 @@
                          CALL lpm_advec( i, j, k )
 !
-!--                      Particle reflection from walls. Only applied if the particles
-!--                      are in the vertical range of the topography. (Here, some
-!--                      optimization is still possible.)
+!--                      Particle reflection from walls. Only applied if the particles are in the
+!--                      vertical range of the topography. (Here, some optimization is still
+!--                      possible.)
                          IF ( topography /= 'flat'  .AND.  k < nzb_max + 2 )  THEN
                             CALL  lpm_boundary_conds( 'walls', i, j, k )
                          ENDIF
 !
-!--                      User-defined actions after the calculation of the new particle
-!--                      position
+!--                      User-defined actions after the calculation of the new particle position
                          CALL user_lpm_advec( i, j, k )
 !
-!--                      Apply boundary conditions to those particles that have crossed
-!--                      the top or bottom boundary and delete those particles, which are
-!--                      older than allowed
+!--                      Apply boundary conditions to those particles that have crossed the top or
+!--                      bottom boundary and delete those particles, which are older than allowed
                          CALL lpm_boundary_conds( 'bottom/top', i, j, k )
 !
-!---                     If not all particles of the actual grid cell have reached the
-!--                      LES timestep, this cell has to do another loop iteration. Due to
-!--                      the fact that particles can move into neighboring grid cells,
-!--                      these neighbor cells also have to perform another loop iteration.
-!--                      Please note, this realization does not work properly if
-!--                      particles move into another subdomain.
+!---                     If not all particles of the actual grid cell have reached the LES timestep,
+!--                      this cell has to do another loop iteration. Due to the fact that particles
+!--                      can move into neighboring grid cells, these neighbor cells also have to
+!--                      perform another loop iteration.
+!--                      Please note, this realization does not work properly if particles move into
+!--                      another subdomain.
                          IF ( .NOT. dt_3d_reached_l )  THEN
                             ks = MAX(nzb+1,k-1)
@@ -2350 +2280 @@
                 dt_3d_reached_l = ALL(grid_particles(:,:,:)%time_loop_done)
 !
-!--             Find out, if all particles on every PE have completed the LES timestep
-!--             and set the switch corespondingly
+!--             Find out, if all particles on every PE have completed the LES timestep and set the
+!--             switch corespondingly
 #if defined( __parallel )
                 IF ( collective_wait )  CALL MPI_BARRIER( comm2d, ierr )
-                CALL MPI_ALLREDUCE( dt_3d_reached_l, dt_3d_reached, 1, MPI_LOGICAL, &
-                                    MPI_LAND, comm2d, ierr )
+                CALL MPI_ALLREDUCE( dt_3d_reached_l, dt_3d_reached, 1, MPI_LOGICAL, MPI_LAND,      &
+                                    comm2d, ierr )
 #else
                 dt_3d_reached = dt_3d_reached_l
@@ -2382 +2312 @@
                 IF ( .NOT. dt_3d_reached  .OR.  .NOT. nested_run )   THEN
 !
-!--                Pack particles (eliminate those marked for deletion),
-!--                determine new number of particles
+!--                Pack particles (eliminate those marked for deletion), determine new number of
+!--                particles
                    CALL lpm_sort_and_delete
 
-!--                Initialize variables for the next (sub-) timestep, i.e., for marking
-!--                those particles to be deleted after the timestep
+!--                Initialize variables for the next (sub-) timestep, i.e., for marking those
+!--                particles to be deleted after the timestep
                    deleted_particles = 0
                 ENDIF
@@ -2398 +2328 @@
 #if defined( __parallel )
 !
-!--          in case of nested runs do the transfer of particles after every full model time step
+!--          In case of nested runs do the transfer of particles after every full model time step
              IF ( nested_run )   THEN
                 CALL particles_from_parent_to_child
@@ -2433 +2363 @@
 
 !
-!--          Write particle statistics (in particular the number of particles
-!--          exchanged between the subdomains) on file
+!--          Write particle statistics (in particular the number of particles exchanged between the
+!--          subdomains) on file
              IF ( write_particle_statistics )  CALL lpm_write_exchange_statistics
 !
-!--          Execute Interactions of condnesation and evaporation to humidity and
-!--          temperature field
+!--          Execute Interactions of condnesation and evaporation to humidity and temperature field
              IF ( cloud_droplets )  THEN
                 CALL lpm_interaction_droplets_ptq
@@ -2465 +2394 @@
        CASE ( 'after_integration' )
 !
-!--       Call at the end of timestep routine to save particle velocities fields
-!--       for the next timestep
+!--       Call at the end of timestep routine to save particle velocities fields for the next
+!--       timestep
           CALL lpm_swap_timelevel_for_particle_advection
 
@@ -2475 +2404 @@
 
  END SUBROUTINE lpm_actions
- 
+
 
 #if defined( __parallel )
-!------------------------------------------------------------------------------!
+!--------------------------------------------------------------------------------------------------!
 ! Description:
 ! ------------
 !
-!------------------------------------------------------------------------------!
+!--------------------------------------------------------------------------------------------------!
  SUBROUTINE particles_from_parent_to_child
 
@@ -2492 +2421 @@
  END SUBROUTINE particles_from_parent_to_child
 
- 
-!------------------------------------------------------------------------------!
+
+!--------------------------------------------------------------------------------------------------!
 ! Description:
 ! ------------
 !
-!------------------------------------------------------------------------------!
+!--------------------------------------------------------------------------------------------------!
  SUBROUTINE particles_from_child_to_parent
 
@@ -2507 +2436 @@
  END SUBROUTINE particles_from_child_to_parent
 #endif
- 
-!------------------------------------------------------------------------------!
+
+!--------------------------------------------------------------------------------------------------!
 ! Description:
 ! ------------
-!> This routine write exchange statistics of the lpm in a ascii file. 
-!------------------------------------------------------------------------------!
+!> This routine write exchange statistics of the lpm in a ascii file.
+!--------------------------------------------------------------------------------------------------!
  SUBROUTINE lpm_write_exchange_statistics
 
@@ -2526 +2455 @@
        DO  jp = nys, nyn
           DO  kp = nzb+1, nzt
-             number_of_particles = number_of_particles                         &
-                                     + prt_count(kp,jp,ip)
+             number_of_particles = number_of_particles + prt_count(kp,jp,ip)
           ENDDO
        ENDDO
@@ -2534 +2462 @@
     CALL check_open( 80 )
 #if defined( __parallel )
-    WRITE ( 80, 8000 )  current_timestep_number+1, simulated_time+dt_3d, &
-                        number_of_particles, pleft, trlp_count_sum,      &
-                        trlp_count_recv_sum, pright, trrp_count_sum,     &
-                        trrp_count_recv_sum, psouth, trsp_count_sum,     &
-                        trsp_count_recv_sum, pnorth, trnp_count_sum,     &
-                        trnp_count_recv_sum
+    WRITE ( 80, 8000 )  current_timestep_number+1, simulated_time+dt_3d, number_of_particles,      &
+                        pleft, trlp_count_sum, trlp_count_recv_sum, pright, trrp_count_sum,        &
+                        trrp_count_recv_sum, psouth, trsp_count_sum, trsp_count_recv_sum, pnorth,  &
+                        trnp_count_sum, trnp_count_recv_sum
 #else
-    WRITE ( 80, 8000 )  current_timestep_number+1, simulated_time+dt_3d, &
-                        number_of_particles
+    WRITE ( 80, 8000 )  current_timestep_number+1, simulated_time+dt_3d, number_of_particles
 #endif
     CALL close_file( 80 )
 
     IF ( number_of_particles > 0 )  THEN
-        WRITE(9,*) 'number_of_particles ', number_of_particles,                &
-                    current_timestep_number + 1, simulated_time + dt_3d
+        WRITE(9,*) 'number_of_particles ', number_of_particles, current_timestep_number + 1,       &
+                   simulated_time + dt_3d
     ENDIF
 
 #if defined( __parallel )
-    CALL MPI_ALLREDUCE( number_of_particles, tot_number_of_particles, 1,       &
-                        MPI_INTEGER, MPI_SUM, comm2d, ierr )
+    CALL MPI_ALLREDUCE( number_of_particles, tot_number_of_particles, 1, MPI_INTEGER, MPI_SUM,     &
+                        comm2d, ierr )
 #else
     tot_number_of_particles = number_of_particles
@@ -2560 +2485 @@
 #if defined( __parallel )
     IF ( nested_run )  THEN
-       CALL pmcp_g_print_number_of_particles( simulated_time+dt_3d,            &
-                                              tot_number_of_particles)
+       CALL pmcp_g_print_number_of_particles( simulated_time + dt_3d, tot_number_of_particles)
     ENDIF
 #endif
@@ -2571 +2495 @@
 
  END SUBROUTINE lpm_write_exchange_statistics
- 
-
-!------------------------------------------------------------------------------! 
+
+
+!--------------------------------------------------------------------------------------------------!
 ! Description:
 ! ------------
-!> Write particle data in FORTRAN binary and/or netCDF format 
-!------------------------------------------------------------------------------!
+!> Write particle data in FORTRAN binary and/or netCDF format
+!--------------------------------------------------------------------------------------------------!
  SUBROUTINE lpm_data_output_particles
- 
+
     INTEGER(iwp) ::  ip !<
     INTEGER(iwp) ::  jp !<
@@ -2587 +2511 @@
 
 !
-!-- Attention: change version number for unit 85 (in routine check_open)
-!--            whenever the output format for this unit is changed!
+!-- Attention: change version number for unit 85 (in routine check_open) whenever the output format
+!--            for this unit is changed!
     CALL check_open( 85 )
 
@@ -2612 +2536 @@
 ! !-- Output in netCDF format
 !     CALL check_open( 108 )
-! 
+!
 ! !
 ! !-- Update the NetCDF time axis
 !     prt_time_count = prt_time_count + 1
-! 
+!
 !     nc_stat = NF90_PUT_VAR( id_set_prt, id_var_time_prt, &
 !                             (/ simulated_time /),        &
 !                             start = (/ prt_time_count /), count = (/ 1 /) )
 !     CALL netcdf_handle_error( 'lpm_data_output_particles', 1 )
-! 
+!
 ! !
 ! !-- Output the real number of particles used
@@ -2628 +2552 @@
 !                             start = (/ prt_time_count /), count = (/ 1 /) )
 !     CALL netcdf_handle_error( 'lpm_data_output_particles', 2 )
-! 
+!
 ! !
 ! !-- Output all particle attributes
@@ -2635 +2559 @@
 !                             count = (/ maximum_number_of_particles /) )
 !     CALL netcdf_handle_error( 'lpm_data_output_particles', 3 )
-! 
+!
 !     nc_stat = NF90_PUT_VAR( id_set_prt, id_var_prt(2), particles%user,     &
 !                             start = (/ 1, prt_time_count /),               &
 !                             count = (/ maximum_number_of_particles /) )
 !     CALL netcdf_handle_error( 'lpm_data_output_particles', 4 )
-! 
+!
 !     nc_stat = NF90_PUT_VAR( id_set_prt, id_var_prt(3), particles%origin_x, &
 !                             start = (/ 1, prt_time_count /),               &
 !                             count = (/ maximum_number_of_particles /) )
 !     CALL netcdf_handle_error( 'lpm_data_output_particles', 5 )
-! 
+!
 !     nc_stat = NF90_PUT_VAR( id_set_prt, id_var_prt(4), particles%origin_y, &
 !                             start = (/ 1, prt_time_count /),               &
 !                             count = (/ maximum_number_of_particles /) )
 !     CALL netcdf_handle_error( 'lpm_data_output_particles', 6 )
-! 
+!
 !     nc_stat = NF90_PUT_VAR( id_set_prt, id_var_prt(5), particles%origin_z, &
 !                             start = (/ 1, prt_time_count /),               &
 !                             count = (/ maximum_number_of_particles /) )
 !     CALL netcdf_handle_error( 'lpm_data_output_particles', 7 )
-! 
+!
 !     nc_stat = NF90_PUT_VAR( id_set_prt, id_var_prt(6), particles%radius,   &
 !                             start = (/ 1, prt_time_count /),               &
 !                             count = (/ maximum_number_of_particles /) )
 !     CALL netcdf_handle_error( 'lpm_data_output_particles', 8 )
-! 
+!
 !     nc_stat = NF90_PUT_VAR( id_set_prt, id_var_prt(7), particles%speed_x,  &
 !                             start = (/ 1, prt_time_count /),               &
 !                             count = (/ maximum_number_of_particles /) )
 !     CALL netcdf_handle_error( 'lpm_data_output_particles', 9 )
-! 
+!
 !     nc_stat = NF90_PUT_VAR( id_set_prt, id_var_prt(8), particles%speed_y,  &
 !                             start = (/ 1, prt_time_count /),               &
 !                             count = (/ maximum_number_of_particles /) )
 !     CALL netcdf_handle_error( 'lpm_data_output_particles', 10 )
-! 
+!
 !     nc_stat = NF90_PUT_VAR( id_set_prt, id_var_prt(9), particles%speed_z,  &
 !                             start = (/ 1, prt_time_count /),               &
 !                             count = (/ maximum_number_of_particles /) )
 !     CALL netcdf_handle_error( 'lpm_data_output_particles', 11 )
-! 
+!
 !     nc_stat = NF90_PUT_VAR( id_set_prt,id_var_prt(10),                     &
 !                             particles%weight_factor,                       &
@@ -2681 +2605 @@
 !                             count = (/ maximum_number_of_particles /) )
 !     CALL netcdf_handle_error( 'lpm_data_output_particles', 12 )
-! 
+!
 !     nc_stat = NF90_PUT_VAR( id_set_prt, id_var_prt(11), particles%x,       &
 !                             start = (/ 1, prt_time_count /),               &
 !                             count = (/ maximum_number_of_particles /) )
 !     CALL netcdf_handle_error( 'lpm_data_output_particles', 13 )
-! 
+!
 !     nc_stat = NF90_PUT_VAR( id_set_prt, id_var_prt(12), particles%y,       &
 !                             start = (/ 1, prt_time_count /),               &
 !                             count = (/ maximum_number_of_particles /) )
 !     CALL netcdf_handle_error( 'lpm_data_output_particles', 14 )
-! 
+!
 !     nc_stat = NF90_PUT_VAR( id_set_prt, id_var_prt(13), particles%z,       &
 !                             start = (/ 1, prt_time_count /),               &
 !                             count = (/ maximum_number_of_particles /) )
 !     CALL netcdf_handle_error( 'lpm_data_output_particles', 15 )
-! 
+!
 !     nc_stat = NF90_PUT_VAR( id_set_prt, id_var_prt(14), particles%class,   &
 !                             start = (/ 1, prt_time_count /),               &
 !                             count = (/ maximum_number_of_particles /) )
 !     CALL netcdf_handle_error( 'lpm_data_output_particles', 16 )
-! 
+!
 !     nc_stat = NF90_PUT_VAR( id_set_prt, id_var_prt(15), particles%group,   &
 !                             start = (/ 1, prt_time_count /),               &
 !                             count = (/ maximum_number_of_particles /) )
 !     CALL netcdf_handle_error( 'lpm_data_output_particles', 17 )
-! 
+!
 !     nc_stat = NF90_PUT_VAR( id_set_prt, id_var_prt(16),                    &
 !                             particles%id2,                                 &
@@ -2712 +2636 @@
 !                             count = (/ maximum_number_of_particles /) )
 !     CALL netcdf_handle_error( 'lpm_data_output_particles', 18 )
-! 
+!
 !     nc_stat = NF90_PUT_VAR( id_set_prt, id_var_prt(17), particles%id1,     &
 !                             start = (/ 1, prt_time_count /),               &
 !                             count = (/ maximum_number_of_particles /) )
 !     CALL netcdf_handle_error( 'lpm_data_output_particles', 19 )
-! 
+!
 #endif
 
@@ -2723 +2647 @@
 
  END SUBROUTINE lpm_data_output_particles
- 
-!------------------------------------------------------------------------------!
+
+!--------------------------------------------------------------------------------------------------!
 ! Description:
 ! ------------
 !> This routine calculates and provide particle timeseries output.
-!------------------------------------------------------------------------------!
+!--------------------------------------------------------------------------------------------------!
  SUBROUTINE lpm_data_output_ptseries
- 
+
     INTEGER(iwp) ::  i    !<
     INTEGER(iwp) ::  inum !<
@@ -2752 +2676 @@
 !
 !--    Update the particle time series time axis
-       nc_stat = NF90_PUT_VAR( id_set_pts, id_var_time_pts,      &
-                               (/ time_since_reference_point /), &
+       nc_stat = NF90_PUT_VAR( id_set_pts, id_var_time_pts, (/ time_since_reference_point /),      &
                                start = (/ dopts_time_count /), count = (/ 1 /) )
        CALL netcdf_handle_error( 'data_output_ptseries', 391 )
@@ -2760 +2683 @@
     ENDIF
 
-    ALLOCATE( pts_value(0:number_of_particle_groups,dopts_num), &
+    ALLOCATE( pts_value(0:number_of_particle_groups,dopts_num),                                    &
               pts_value_l(0:number_of_particle_groups,dopts_num) )
 
@@ -2767 +2690 @@
 
 !
-!-- Calculate or collect the particle time series quantities for all particles
-!-- and seperately for each particle group (if there is more than one group)
+!-- Calculate or collect the particle time series quantities for all particles and seperately for
+!-- each particle group (if there is more than one group)
     DO  i = nxl, nxr
        DO  j = nys, nyn
@@ -2779 +2702 @@
                 IF ( particles(n)%particle_mask )  THEN  ! Restrict analysis to active particles
 
-                   pts_value_l(0,1)  = pts_value_l(0,1) + 1.0_wp  ! total # of particles
-                   pts_value_l(0,2)  = pts_value_l(0,2) +                      &
-                          ( particles(n)%x - particles(n)%origin_x )  ! mean x
-                   pts_value_l(0,3)  = pts_value_l(0,3) +                      &
-                          ( particles(n)%y - particles(n)%origin_y )  ! mean y
-                   pts_value_l(0,4)  = pts_value_l(0,4) +                      &
-                          ( particles(n)%z - particles(n)%origin_z )  ! mean z
-                   pts_value_l(0,5)  = pts_value_l(0,5) + particles(n)%z        ! mean z (absolute)
-                   pts_value_l(0,6)  = pts_value_l(0,6) + particles(n)%speed_x  ! mean u
-                   pts_value_l(0,7)  = pts_value_l(0,7) + particles(n)%speed_y  ! mean v
-                   pts_value_l(0,8)  = pts_value_l(0,8) + particles(n)%speed_z  ! mean w
-                   pts_value_l(0,9)  = pts_value_l(0,9)  + particles(n)%rvar1 ! mean sgsu
-                   pts_value_l(0,10) = pts_value_l(0,10) + particles(n)%rvar2 ! mean sgsv
-                   pts_value_l(0,11) = pts_value_l(0,11) + particles(n)%rvar3 ! mean sgsw
+                   pts_value_l(0,1)  = pts_value_l(0,1) + 1.0_wp                   ! total # of particles
+                   pts_value_l(0,2)  = pts_value_l(0,2) +                                          &
+                                       ( particles(n)%x - particles(n)%origin_x )  ! mean x
+                   pts_value_l(0,3)  = pts_value_l(0,3) +                                          &
+                                       ( particles(n)%y - particles(n)%origin_y )  ! mean y
+                   pts_value_l(0,4)  = pts_value_l(0,4) +                                          &
+                                       ( particles(n)%z - particles(n)%origin_z )  ! mean z
+                   pts_value_l(0,5)  = pts_value_l(0,5) + particles(n)%z           ! mean z (absolute)
+                   pts_value_l(0,6)  = pts_value_l(0,6) + particles(n)%speed_x     ! mean u
+                   pts_value_l(0,7)  = pts_value_l(0,7) + particles(n)%speed_y     ! mean v
+                   pts_value_l(0,8)  = pts_value_l(0,8) + particles(n)%speed_z     ! mean w
+                   pts_value_l(0,9)  = pts_value_l(0,9)  + particles(n)%rvar1      ! mean sgsu
+                   pts_value_l(0,10) = pts_value_l(0,10) + particles(n)%rvar2      ! mean sgsv
+                   pts_value_l(0,11) = pts_value_l(0,11) + particles(n)%rvar3      ! mean sgsw
                    IF ( particles(n)%speed_z > 0.0_wp )  THEN
-                      pts_value_l(0,12) = pts_value_l(0,12) + 1.0_wp  ! # of upward moving prts
-                      pts_value_l(0,13) = pts_value_l(0,13) +                  &
-                                              particles(n)%speed_z ! mean w upw.
+                      pts_value_l(0,12) = pts_value_l(0,12) + 1.0_wp                ! # of upward moving prts
+                      pts_value_l(0,13) = pts_value_l(0,13) +  particles(n)%speed_z ! mean w upw.
                    ELSE
-                      pts_value_l(0,14) = pts_value_l(0,14) +                  &
-                                              particles(n)%speed_z ! mean w down
+                      pts_value_l(0,14) = pts_value_l(0,14) + particles(n)%speed_z  ! mean w down
                    ENDIF
-                   pts_value_l(0,15) = pts_value_l(0,15) + particles(n)%radius ! mean rad
+                   pts_value_l(0,15) = pts_value_l(0,15) + particles(n)%radius       ! mean rad
                    pts_value_l(0,16) = MIN( pts_value_l(0,16), particles(n)%radius ) ! minrad
                    pts_value_l(0,17) = MAX( pts_value_l(0,17), particles(n)%radius ) ! maxrad
@@ -2812 +2733 @@
 
                       pts_value_l(jg,1)  = pts_value_l(jg,1) + 1.0_wp
-                      pts_value_l(jg,2)  = pts_value_l(jg,2) +                   &
-                           ( particles(n)%x - particles(n)%origin_x )
-                      pts_value_l(jg,3)  = pts_value_l(jg,3) +                   &
-                           ( particles(n)%y - particles(n)%origin_y )
-                      pts_value_l(jg,4)  = pts_value_l(jg,4) +                   &
-                           ( particles(n)%z - particles(n)%origin_z )
+                      pts_value_l(jg,2)  = pts_value_l(jg,2) +                                     &
+                                           ( particles(n)%x  - particles(n)%origin_x )
+                      pts_value_l(jg,3)  = pts_value_l(jg,3) +                                     &
+                                           ( particles(n)%y  - particles(n)%origin_y )
+                      pts_value_l(jg,4)  = pts_value_l(jg,4) +                                     &
+                                           ( particles(n)%z  - particles(n)%origin_z )
                       pts_value_l(jg,5)  = pts_value_l(jg,5) + particles(n)%z
                       pts_value_l(jg,6)  = pts_value_l(jg,6) + particles(n)%speed_x
@@ -2853 +2774 @@
 
     IF ( collective_wait )  CALL MPI_BARRIER( comm2d, ierr )
-    CALL MPI_ALLREDUCE( pts_value_l(0,1), pts_value(0,1), 15*inum, MPI_REAL, &
-                        MPI_SUM, comm2d, ierr )
+    CALL MPI_ALLREDUCE( pts_value_l(0,1), pts_value(0,1), 15*inum, MPI_REAL, MPI_SUM, comm2d, ierr )
     IF ( collective_wait )  CALL MPI_BARRIER( comm2d, ierr )
-    CALL MPI_ALLREDUCE( pts_value_l(0,16), pts_value(0,16), inum, MPI_REAL, &
-                        MPI_MIN, comm2d, ierr )
+    CALL MPI_ALLREDUCE( pts_value_l(0,16), pts_value(0,16), inum, MPI_REAL, MPI_MIN, comm2d, ierr )
     IF ( collective_wait )  CALL MPI_BARRIER( comm2d, ierr )
-    CALL MPI_ALLREDUCE( pts_value_l(0,17), pts_value(0,17), inum, MPI_REAL, &
-                        MPI_MAX, comm2d, ierr )
+    CALL MPI_ALLREDUCE( pts_value_l(0,17), pts_value(0,17), inum, MPI_REAL, MPI_MAX, comm2d, ierr )
     IF ( collective_wait )  CALL MPI_BARRIER( comm2d, ierr )
-    CALL MPI_ALLREDUCE( pts_value_l(0,18), pts_value(0,18), inum, MPI_REAL, &
-                        MPI_MAX, comm2d, ierr )
+    CALL MPI_ALLREDUCE( pts_value_l(0,18), pts_value(0,18), inum, MPI_REAL, MPI_MAX, comm2d, ierr )
     IF ( collective_wait )  CALL MPI_BARRIER( comm2d, ierr )
-    CALL MPI_ALLREDUCE( pts_value_l(0,19), pts_value(0,19), inum, MPI_REAL, &
-                        MPI_MIN, comm2d, ierr )
+    CALL MPI_ALLREDUCE( pts_value_l(0,19), pts_value(0,19), inum, MPI_REAL, MPI_MIN, comm2d, ierr )
 #else
     pts_value(:,1:19) = pts_value_l(:,1:19)
@@ -2872 +2788 @@
 
 !
-!-- Normalize the above calculated quantities (except min/max values) with the
-!-- total number of particles
+!-- Normalize the above calculated quantities (except min/max values) with the total number of
+!-- particles
     IF ( number_of_particle_groups > 1 )  THEN
        inum = number_of_particle_groups
@@ -2899 +2815 @@
 
 !
-!-- Calculate higher order moments of particle time series quantities,
-!-- seperately for each particle group (if there is more than one group)
+!-- Calculate higher order moments of particle time series quantities, seperately for each particle
+!-- group (if there is more than one group)
     DO  i = nxl, nxr
        DO  j = nys, nyn
@@ -2909 +2825 @@
              DO  n = 1, number_of_particles
 
-                pts_value_l(0,20) = pts_value_l(0,20) + ( particles(n)%x - &
-                                    particles(n)%origin_x - pts_value(0,2) )**2 ! x*2
-                pts_value_l(0,21) = pts_value_l(0,21) + ( particles(n)%y - &
-                                    particles(n)%origin_y - pts_value(0,3) )**2 ! y*2
-                pts_value_l(0,22) = pts_value_l(0,22) + ( particles(n)%z - &
-                                    particles(n)%origin_z - pts_value(0,4) )**2 ! z*2
-                pts_value_l(0,23) = pts_value_l(0,23) + ( particles(n)%speed_x - &
-                                                         pts_value(0,6) )**2   ! u*2
-                pts_value_l(0,24) = pts_value_l(0,24) + ( particles(n)%speed_y - &
-                                                          pts_value(0,7) )**2   ! v*2
-                pts_value_l(0,25) = pts_value_l(0,25) + ( particles(n)%speed_z - &
-                                                          pts_value(0,8) )**2   ! w*2
-                pts_value_l(0,26) = pts_value_l(0,26) + ( particles(n)%rvar1 - &
-                                                          pts_value(0,9) )**2   ! u"2
-                pts_value_l(0,27) = pts_value_l(0,27) + ( particles(n)%rvar2 - &
-                                                          pts_value(0,10) )**2  ! v"2
-                pts_value_l(0,28) = pts_value_l(0,28) + ( particles(n)%rvar3 - &
+                pts_value_l(0,20) = pts_value_l(0,20) + ( particles(n)%x -                         &
+                                       particles(n)%origin_x - pts_value(0,2) )**2 ! x*2
+                pts_value_l(0,21) = pts_value_l(0,21) + ( particles(n)%y -                         &
+                                       particles(n)%origin_y - pts_value(0,3) )**2 ! y*2
+                pts_value_l(0,22) = pts_value_l(0,22) + ( particles(n)%z -                         &
+                                       particles(n)%origin_z - pts_value(0,4) )**2 ! z*2
+                pts_value_l(0,23) = pts_value_l(0,23) + ( particles(n)%speed_x -                   &
+                                                          pts_value(0,6) )**2      ! u*2
+                pts_value_l(0,24) = pts_value_l(0,24) + ( particles(n)%speed_y -                   &
+                                                          pts_value(0,7) )**2      ! v*2
+                pts_value_l(0,25) = pts_value_l(0,25) + ( particles(n)%speed_z -                   &
+                                                          pts_value(0,8) )**2      ! w*2
+                pts_value_l(0,26) = pts_value_l(0,26) + ( particles(n)%rvar1 -                     &
+                                                          pts_value(0,9) )**2      ! u"2
+                pts_value_l(0,27) = pts_value_l(0,27) + ( particles(n)%rvar2 -                     &
+                                                          pts_value(0,10) )**2     ! v"2
+                pts_value_l(0,28) = pts_value_l(0,28) + ( particles(n)%rvar3 -                     &
                                                           pts_value(0,11) )**2  ! w"2
 !
@@ -2932 +2848 @@
                    jg = particles(n)%group
 
-                   pts_value_l(jg,20) = pts_value_l(jg,20) + ( particles(n)%x - &
-                                       particles(n)%origin_x - pts_value(jg,2) )**2
-                   pts_value_l(jg,21) = pts_value_l(jg,21) + ( particles(n)%y - &
-                                       particles(n)%origin_y - pts_value(jg,3) )**2
-                   pts_value_l(jg,22) = pts_value_l(jg,22) + ( particles(n)%z - &
-                                       particles(n)%origin_z - pts_value(jg,4) )**2
-                   pts_value_l(jg,23) = pts_value_l(jg,23) + ( particles(n)%speed_x - &
-                                                             pts_value(jg,6) )**2
-                   pts_value_l(jg,24) = pts_value_l(jg,24) + ( particles(n)%speed_y - &
-                                                             pts_value(jg,7) )**2
-                   pts_value_l(jg,25) = pts_value_l(jg,25) + ( particles(n)%speed_z - &
-                                                             pts_value(jg,8) )**2
-                   pts_value_l(jg,26) = pts_value_l(jg,26) + ( particles(n)%rvar1 - &
-                                                             pts_value(jg,9) )**2
-                   pts_value_l(jg,27) = pts_value_l(jg,27) + ( particles(n)%rvar2 - &
-                                                             pts_value(jg,10) )**2
-                   pts_value_l(jg,28) = pts_value_l(jg,28) + ( particles(n)%rvar3 - &
-                                                             pts_value(jg,11) )**2
+                   pts_value_l(jg,20) = pts_value_l(jg,20) + ( particles(n)%x -                    &
+                                           particles(n)%origin_x - pts_value(jg,2) )**2
+                   pts_value_l(jg,21) = pts_value_l(jg,21) + ( particles(n)%y -                    &
+                                           particles(n)%origin_y - pts_value(jg,3) )**2
+                   pts_value_l(jg,22) = pts_value_l(jg,22) + ( particles(n)%z -                    &
+                                           particles(n)%origin_z - pts_value(jg,4) )**2
+                   pts_value_l(jg,23) = pts_value_l(jg,23) + ( particles(n)%speed_x -              &
+                                                               pts_value(jg,6) )**2
+                   pts_value_l(jg,24) = pts_value_l(jg,24) + ( particles(n)%speed_y -              &
+                                                               pts_value(jg,7) )**2
+                   pts_value_l(jg,25) = pts_value_l(jg,25) + ( particles(n)%speed_z -              &
+                                                               pts_value(jg,8) )**2
+                   pts_value_l(jg,26) = pts_value_l(jg,26) + ( particles(n)%rvar1 -                &
+                                                               pts_value(jg,9) )**2
+                   pts_value_l(jg,27) = pts_value_l(jg,27) + ( particles(n)%rvar2 -                &
+                                                               pts_value(jg,10) )**2
+                   pts_value_l(jg,28) = pts_value_l(jg,28) + ( particles(n)%rvar3 -                &
+                                                               pts_value(jg,11) )**2
                 ENDIF
 
@@ -2961 +2877 @@
     IF ( number_of_particle_groups > 1 )  THEN
        DO  j = 1, number_of_particle_groups
-          pts_value_l(j,29) = ( pts_value_l(j,1) - &
-                                pts_value(j,1) / numprocs )**2
+          pts_value_l(j,29) = ( pts_value_l(j,1) - pts_value(j,1) / numprocs )**2
        ENDDO
     ENDIF
@@ -2972 +2887 @@
 
     IF ( collective_wait )  CALL MPI_BARRIER( comm2d, ierr )
-    CALL MPI_ALLREDUCE( pts_value_l(0,20), pts_value(0,20), inum*10, MPI_REAL, &
-                        MPI_SUM, comm2d, ierr )
+    CALL MPI_ALLREDUCE( pts_value_l(0,20), pts_value(0,20), inum*10, MPI_REAL, MPI_SUM, comm2d,    &
+                        ierr )
 #else
     pts_value(:,20:29) = pts_value_l(:,20:29)
@@ -2979 +2894 @@
 
 !
-!-- Normalize the above calculated quantities with the total number of
-!-- particles
+!-- Normalize the above calculated quantities with the total number of particles
     IF ( number_of_particle_groups > 1 )  THEN
        inum = number_of_particle_groups
@@ -3002 +2916 @@
        DO  j = 0, inum
           DO  i = 1, dopts_num
-             nc_stat = NF90_PUT_VAR( id_set_pts, id_var_dopts(i,j),  &
-                                     (/ pts_value(j,i) /),           &
-                                     start = (/ dopts_time_count /), &
+             nc_stat = NF90_PUT_VAR( id_set_pts, id_var_dopts(i,j),                                &
+                                     (/ pts_value(j,i) /),                                         &
+                                     start = (/ dopts_time_count /),                               &
                                      count = (/ 1 /) )
              CALL netcdf_handle_error( 'data_output_ptseries', 392 )
@@ -3018 +2932 @@
 END SUBROUTINE lpm_data_output_ptseries
 
- 
-!------------------------------------------------------------------------------!
+
+!--------------------------------------------------------------------------------------------------!
 ! Description:
 ! ------------
 !> This routine reads the respective restart data for the lpm.
-!------------------------------------------------------------------------------!
+!--------------------------------------------------------------------------------------------------!
  SUBROUTINE lpm_rrd_local_particles
 
@@ -3048 +2962 @@
 !--    First open the input unit.
        IF ( myid_char == '' )  THEN
-          OPEN ( 90, FILE='PARTICLE_RESTART_DATA_IN'//myid_char,                  &
-                     FORM='UNFORMATTED' )
+          OPEN ( 90, FILE='PARTICLE_RESTART_DATA_IN'//myid_char, FORM='UNFORMATTED' )
        ELSE
-          OPEN ( 90, FILE='PARTICLE_RESTART_DATA_IN/'//myid_char,                 &
-                     FORM='UNFORMATTED' )
+          OPEN ( 90, FILE='PARTICLE_RESTART_DATA_IN/'//myid_char, FORM='UNFORMATTED' )
        ENDIF
 
@@ -3060 +2972 @@
        particle_binary_version = '4.0'
        IF ( TRIM( version_on_file ) /= TRIM( particle_binary_version ) )  THEN
-          message_string = 'version mismatch concerning data from prior ' //      &
-                           'run &version on file = "' //                          &
-                                         TRIM( version_on_file ) //               &
-                           '&version in program = "' //                           &
+          message_string = 'version mismatch concerning data from prior ' //                       &
+                           'run &version on file = "' //                                           &
+                                         TRIM( version_on_file ) //                                &
+                           '&version in program = "' //                                            &
                                          TRIM( particle_binary_version ) // '"'
           CALL message( 'lpm_read_restart_file', 'PA0214', 1, 2, 0, 6, 0 )
@@ -3069 +2981 @@
 
 !
-!--    If less particles are stored on the restart file than prescribed by
-!--    1, the remainder is initialized by zero_particle to avoid
-!--    errors.
-       zero_particle = particle_type( 0.0_wp, 0.0_wp, 0.0_wp, 0.0_wp, 0.0_wp,     &
-                                      0.0_wp, 0.0_wp, 0.0_wp, 0.0_wp, 0.0_wp,     &
-                                      0.0_wp, 0.0_wp, 0.0_wp, 0.0_wp, 0.0_wp,     &
-                                      0.0_wp, 0.0_wp, 0.0_wp, 0.0_wp, 0.0_wp,     &
+!--    If less particles are stored on the restart file than prescribed by 1, the remainder is
+!--    initialized by zero_particle to avoid errors.
+       zero_particle = particle_type( 0.0_wp, 0.0_wp, 0.0_wp, 0.0_wp, 0.0_wp,                      &
+                                      0.0_wp, 0.0_wp, 0.0_wp, 0.0_wp, 0.0_wp,                      &
+                                      0.0_wp, 0.0_wp, 0.0_wp, 0.0_wp, 0.0_wp,                      &
+                                      0.0_wp, 0.0_wp, 0.0_wp, 0.0_wp, 0.0_wp,                      &
                                       0, 0, 0_idp, .FALSE., -1, -1 )
 !
-!--    Read some particle parameters and the size of the particle arrays,
-!--    allocate them and read their contents.
-       READ ( 90 )  bc_par_b, bc_par_lr, bc_par_ns, bc_par_t,                     &
-                    last_particle_release_time, number_of_particle_groups,        &
-                    particle_groups, time_write_particle_data
-
-       ALLOCATE( prt_count(nzb:nzt+1,nysg:nyng,nxlg:nxrg),                        &
+!--    Read some particle parameters and the size of the particle arrays, allocate them and read
+!--    their contents.
+       READ ( 90 )  bc_par_b, bc_par_lr, bc_par_ns, bc_par_t, last_particle_release_time,          &
+                    number_of_particle_groups, particle_groups, time_write_particle_data
+
+       ALLOCATE( prt_count(nzb:nzt+1,nysg:nyng,nxlg:nxrg),                                         &
                  grid_particles(nzb:nzt+1,nysg:nyng,nxlg:nxrg) )
 
@@ -3095 +3005 @@
                 number_of_particles = prt_count(kp,jp,ip)
                 IF ( number_of_particles > 0 )  THEN
-                   alloc_size = MAX( INT( number_of_particles *                   &
-                                ( 1.0_wp + alloc_factor / 100.0_wp ) ),           &
-                                1 )
+                   alloc_size = MAX( INT( number_of_particles *                                    &
+                                          ( 1.0_wp + alloc_factor / 100.0_wp ) ),                  &
+                                     1 )
                 ELSE
                    alloc_size = 1
@@ -3110 +3020 @@
                    DEALLOCATE( tmp_particles )
                    IF ( number_of_particles < alloc_size )  THEN
-                      grid_particles(kp,jp,ip)%particles(number_of_particles+1:alloc_size) &
+                      grid_particles(kp,jp,ip)%particles(number_of_particles+1:alloc_size)         &
                          = zero_particle
                    ENDIF
@@ -3128 +3038 @@
        FLUSH(9)
 
-       ALLOCATE( prt_count(nzb:nzt+1,nysg:nyng,nxlg:nxrg),                        &
+       ALLOCATE( prt_count(nzb:nzt+1,nysg:nyng,nxlg:nxrg),                                         &
                  grid_particles(nzb:nzt+1,nysg:nyng,nxlg:nxrg) )
 
        ALLOCATE( prt_global_index(nzb:nzt+1,nysg:nyng,nxlg:nxrg) )
 !
-!--    Open restart file for read, if not already open, and do not allow usage of
-!--    shared-memory I/O
+!--    Open restart file for read, if not already open, and do not allow usage of shared-memory I/O
        IF ( .NOT. rd_mpi_io_check_open() )  THEN
           save_restart_data_format_input = restart_data_format_input
@@ -3156 +3065 @@
                 number_of_particles = prt_count(kp,jp,ip)
                 IF ( number_of_particles > 0 )  THEN
-                   alloc_size = MAX( INT( number_of_particles *                   &
-                      ( 1.0_wp + alloc_factor / 100.0_wp ) ),           &
-                      1 )
+                   alloc_size = MAX( INT( number_of_particles *                                    &
+                                          ( 1.0_wp + alloc_factor / 100.0_wp ) ),                  &
+                                     1 )
                 ELSE
                    alloc_size = 1
@@ -3186 +3095 @@
     ENDIF
 !
-!-- Must be called to sort particles into blocks, which is needed for a fast
-!-- interpolation of the LES fields on the particle position.
+!-- Must be called to sort particles into blocks, which is needed for a fast interpolation of the
+!-- LES fields on the particle position.
     CALL lpm_sort_and_delete
 
  END SUBROUTINE lpm_rrd_local_particles
- 
- 
-!------------------------------------------------------------------------------!
+
+
+!--------------------------------------------------------------------------------------------------!
 ! Description:
 ! ------------
 !> Read module-specific local restart data arrays (Fortran binary format).
-!------------------------------------------------------------------------------!
- SUBROUTINE lpm_rrd_local_ftn( k, nxlf, nxlc, nxl_on_file, nxrf, nxrc,          &
-                               nxr_on_file, nynf, nync, nyn_on_file, nysf,  &
-                               nysc, nys_on_file, tmp_3d, found )
-
-
-   USE control_parameters,                                                 &
+!--------------------------------------------------------------------------------------------------!
+ SUBROUTINE lpm_rrd_local_ftn( k, nxlf, nxlc, nxl_on_file, nxrf, nxrc, nxr_on_file, nynf, nync,    &
+                               nyn_on_file, nysf, nysc, nys_on_file, tmp_3d, found )
+
+
+   USE control_parameters,                                                                         &
        ONLY: length, restart_string
 
@@ -3220 +3128 @@
     INTEGER(iwp) ::  nys_on_file     !<
 
+    INTEGER(isp), DIMENSION(:,:,:), ALLOCATABLE ::  tmp_2d_seq_random_particles  !< temporary array for storing random generator
+                                                                                 !< data for the lpm
+
     LOGICAL, INTENT(OUT)  ::  found
-
-    INTEGER(isp), DIMENSION(:,:,:), ALLOCATABLE ::  tmp_2d_seq_random_particles  !< temporary array for storing random generator data for the lpm
 
     REAL(wp), DIMENSION(nzb:nzt+1,nys_on_file-nbgp:nyn_on_file+nbgp,nxl_on_file-nbgp:nxr_on_file+nbgp) ::  tmp_3d   !<
@@ -3236 +3145 @@
            ENDIF
            IF ( k == 1 )  READ ( 13 )  tmp_3d
-           pc_av(:,nysc-nbgp:nync+nbgp,nxlc-nbgp:nxrc+nbgp) =          &
+           pc_av(:,nysc-nbgp:nync+nbgp,nxlc-nbgp:nxrc+nbgp) =                                      &
               tmp_3d(:,nysf-nbgp:nynf+nbgp,nxlf-nbgp:nxrf+nbgp)
 
@@ -3244 +3153 @@
            ENDIF
            IF ( k == 1 )  READ ( 13 )  tmp_3d
-           pr_av(:,nysc-nbgp:nync+nbgp,nxlc-nbgp:nxrc+nbgp) =          &
+           pr_av(:,nysc-nbgp:nync+nbgp,nxlc-nbgp:nxrc+nbgp) =                                      &
               tmp_3d(:,nysf-nbgp:nynf+nbgp,nxlf-nbgp:nxrf+nbgp)
- 
+
          CASE ( 'ql_c_av' )
             IF ( .NOT. ALLOCATED( ql_c_av ) )  THEN
@@ -3252 +3161 @@
             ENDIF
             IF ( k == 1 )  READ ( 13 )  tmp_3d
-            ql_c_av(:,nysc-nbgp:nync+nbgp,nxlc-nbgp:nxrc+nbgp) =        &
+            ql_c_av(:,nysc-nbgp:nync+nbgp,nxlc-nbgp:nxrc+nbgp) =                                   &
                tmp_3d(:,nysf-nbgp:nynf+nbgp,nxlf-nbgp:nxrf+nbgp)
 
@@ -3260 +3169 @@
             ENDIF
             IF ( k == 1 )  READ ( 13 )  tmp_3d
-            ql_v_av(:,nysc-nbgp:nync+nbgp,nxlc-nbgp:nxrc+nbgp) =        &
+            ql_v_av(:,nysc-nbgp:nync+nbgp,nxlc-nbgp:nxrc+nbgp) =                                   &
                tmp_3d(:,nysf-nbgp:nynf+nbgp,nxlf-nbgp:nxrf+nbgp)
 
@@ -3268 +3177 @@
             ENDIF
             IF ( k == 1 )  READ ( 13 )  tmp_3d
-            ql_vp_av(:,nysc-nbgp:nync+nbgp,nxlc-nbgp:nxrc+nbgp) =       &
+            ql_vp_av(:,nysc-nbgp:nync+nbgp,nxlc-nbgp:nxrc+nbgp) =                                  &
                tmp_3d(:,nysf-nbgp:nynf+nbgp,nxlf-nbgp:nxrf+nbgp)
 
          CASE ( 'seq_random_array_particles' )
-             ALLOCATE( tmp_2d_seq_random_particles(5,nys_on_file:nyn_on_file,nxl_on_file:nxr_on_file) )
-             IF ( .NOT. ALLOCATED( seq_random_array_particles ) )  THEN
-                ALLOCATE( seq_random_array_particles(5,nys:nyn,nxl:nxr) )
-             ENDIF
-             IF ( k == 1 )  READ ( 13 )  tmp_2d_seq_random_particles
-             seq_random_array_particles(:,nysc:nync,nxlc:nxrc) =                                   &
-                                                  tmp_2d_seq_random_particles(:,nysf:nynf,nxlf:nxrf)
-             DEALLOCATE( tmp_2d_seq_random_particles )
+            ALLOCATE( tmp_2d_seq_random_particles(5,nys_on_file:nyn_on_file,nxl_on_file:nxr_on_file) )
+            IF ( .NOT. ALLOCATED( seq_random_array_particles ) )  THEN
+               ALLOCATE( seq_random_array_particles(5,nys:nyn,nxl:nxr) )
+            ENDIF
+            IF ( k == 1 )  READ ( 13 )  tmp_2d_seq_random_particles
+            seq_random_array_particles(:,nysc:nync,nxlc:nxrc) =                                    &
+                                                 tmp_2d_seq_random_particles(:,nysf:nynf,nxlf:nxrf)
+            DEALLOCATE( tmp_2d_seq_random_particles )
 
           CASE DEFAULT
@@ -3289 +3198 @@
  END SUBROUTINE lpm_rrd_local_ftn
 
- 
-!------------------------------------------------------------------------------!
+
+!--------------------------------------------------------------------------------------------------!
 ! Description:
 ! ------------
 !> Read module-specific local restart data arrays (MPI-IO).
-!------------------------------------------------------------------------------!
+!--------------------------------------------------------------------------------------------------!
  SUBROUTINE lpm_rrd_local_mpi
 
@@ -3349 +3258 @@
 
 
-!------------------------------------------------------------------------------!
+!--------------------------------------------------------------------------------------------------!
 ! Description:
 ! ------------
 !> This routine writes the respective restart data for the lpm.
-!------------------------------------------------------------------------------!
+!--------------------------------------------------------------------------------------------------!
  SUBROUTINE lpm_wrd_local
- 
+
     CHARACTER (LEN=10) ::  particle_binary_version   !<
     CHARACTER (LEN=32) ::  tmp_name                  !< temporary variable
@@ -3364 +3273 @@
     INTEGER(iwp) ::  jp                              !<
     INTEGER(iwp) ::  k                               !< loop index
-    INTEGER(iwp) ::  kp                              !< 
+    INTEGER(iwp) ::  kp                              !<
 
 #if defined( __parallel )
@@ -3382 +3291 @@
 !--    First open the output unit.
        IF ( myid_char == '' )  THEN
-          OPEN ( 90, FILE='PARTICLE_RESTART_DATA_OUT'//myid_char, &
-                     FORM='UNFORMATTED')
+          OPEN ( 90, FILE='PARTICLE_RESTART_DATA_OUT'//myid_char, FORM='UNFORMATTED')
        ELSE
           IF ( myid == 0 )  CALL local_system( 'mkdir PARTICLE_RESTART_DATA_OUT' )
 #if defined( __parallel )
 !
-!--       Set a barrier in order to allow that thereafter all other processors
-!--       in the directory created by PE0 can open their file
+!--       Set a barrier in order to allow that thereafter all other processors in the directory
+!--       created by PE0 can open their file
           CALL MPI_BARRIER( comm2d, ierr )
 #endif
-          OPEN ( 90, FILE='PARTICLE_RESTART_DATA_OUT/'//myid_char, &
-                     FORM='UNFORMATTED' )
+          OPEN ( 90, FILE='PARTICLE_RESTART_DATA_OUT/'//myid_char, FORM='UNFORMATTED' )
        ENDIF
 
 !
 !--    Write the version number of the binary format.
-!--    Attention: After changes to the following output commands the version
-!--    ---------  number of the variable particle_binary_version must be
-!--               changed! Also, the version number and the list of arrays
-!--               to be read in lpm_read_restart_file must be adjusted
-!--               accordingly.
+!--    Attention: After changes to the following output commands the version number of the variable
+!--    ---------  particle_binary_version must be changed! Also, the version number and the list of
+!--               arrays to be read in lpm_read_restart_file must be adjusted accordingly.
        particle_binary_version = '4.0'
        WRITE ( 90 )  particle_binary_version
@@ -3408 +3313 @@
 !
 !--    Write some particle parameters, the size of the particle arrays
-       WRITE ( 90 )  bc_par_b, bc_par_lr, bc_par_ns, bc_par_t,                    &
-                     last_particle_release_time, number_of_particle_groups,       &
-                     particle_groups, time_write_particle_data
+       WRITE ( 90 )  bc_par_b, bc_par_lr, bc_par_ns, bc_par_t, last_particle_release_time,         &
+                     number_of_particle_groups, particle_groups, time_write_particle_data
 
        WRITE ( 90 )  prt_count
-          
+
        DO  ip = nxl, nxr
           DO  jp = nys, nyn
@@ -3465 +3369 @@
 
 #if defined( __parallel )
-       CALL MPI_ALLREDUCE( nr_particles_local, nr_particles_global, numprocs, MPI_INTEGER,         &
-                           MPI_SUM, comm2d, ierr )
+       CALL MPI_ALLREDUCE( nr_particles_local, nr_particles_global, numprocs, MPI_INTEGER, MPI_SUM,&
+                           comm2d, ierr )
 #else
        nr_particles_global = nr_particles_local
@@ -3500 +3404 @@
 
 
-!------------------------------------------------------------------------------!
+!--------------------------------------------------------------------------------------------------!
 ! Description:
 ! ------------
 !> This routine writes the respective restart data for the lpm.
-!------------------------------------------------------------------------------! 
+!--------------------------------------------------------------------------------------------------!
  SUBROUTINE lpm_wrd_global
 
@@ -3513 +3417 @@
     REAL(wp), DIMENSION(4,max_number_of_particle_groups) ::  particle_groups_array  !<
 
- 
+
     IF ( TRIM( restart_data_format_output ) == 'fortran_binary' )  THEN
 
@@ -3569 +3473 @@
 
  END SUBROUTINE lpm_wrd_global
- 
-
-!------------------------------------------------------------------------------!
+
+
+!--------------------------------------------------------------------------------------------------!
 ! Description:
 ! ------------
 !> Read module-specific global restart data (Fortran binary format).
-!------------------------------------------------------------------------------! 
+!--------------------------------------------------------------------------------------------------!
  SUBROUTINE lpm_rrd_global_ftn( found )
- 
-    USE control_parameters,                            &
+
+    USE control_parameters,                                                                        &
         ONLY: length, restart_string
 
@@ -3603 +3507 @@
           found = .FALSE.
 
-    END SELECT 
-    
+    END SELECT
+
  END SUBROUTINE lpm_rrd_global_ftn
 
 
-!------------------------------------------------------------------------------!
+!--------------------------------------------------------------------------------------------------!
 ! Description:
 ! ------------
 !> Read module-specific global restart data (MPI-IO).
-!------------------------------------------------------------------------------!
+!--------------------------------------------------------------------------------------------------!
  SUBROUTINE lpm_rrd_global_mpi
 
@@ -3661 +3565 @@
 
 
-!------------------------------------------------------------------------------!
+!--------------------------------------------------------------------------------------------------!
 ! Description:
 ! ------------
-!> This is a submodule of the lagrangian particle model. It contains all 
-!> dynamic processes of the lpm. This includes the advection (resolved and sub-
-!> grid scale) as well as the boundary conditions of particles. As a next step
-!> this submodule should be excluded as an own file. 
-!------------------------------------------------------------------------------!
+!> This is a submodule of the lagrangian particle model. It contains all dynamic processes of the
+!> lpm. This includes the advection (resolved and sub-grid scale) as well as the boundary conditions
+!> of particles. As a next step this submodule should be excluded as an own file.
+!--------------------------------------------------------------------------------------------------!
  SUBROUTINE lpm_advec (ip,jp,kp)
 
-    LOGICAL ::  subbox_at_wall !< flag to see if the current subgridbox is adjacent to a wall
+    REAL(wp), PARAMETER ::  a_rog = 9.65_wp      !< parameter for fall velocity
+    REAL(wp), PARAMETER ::  b_rog = 10.43_wp     !< parameter for fall velocity
+    REAL(wp), PARAMETER ::  c_rog = 0.6_wp       !< parameter for fall velocity
+    REAL(wp), PARAMETER ::  k_cap_rog = 4.0_wp   !< parameter for fall velocity
+    REAL(wp), PARAMETER ::  k_low_rog = 12.0_wp  !< parameter for fall velocity
+    REAL(wp), PARAMETER ::  d0_rog = 0.745_wp    !< separation diameter
 
     INTEGER(iwp) ::  i                           !< index variable along x
@@ -3681 +3589 @@
     INTEGER(iwp) ::  jp                          !< index variable along y
     INTEGER(iwp) ::  k                           !< index variable along z
-    INTEGER(iwp) ::  k_wall                      !< vertical index of topography top 
+    INTEGER(iwp) ::  k_wall                      !< vertical index of topography top
     INTEGER(iwp) ::  kp                          !< index variable along z
     INTEGER(iwp) ::  k_next                      !< index variable along z
@@ -3687 +3595 @@
     INTEGER(iwp) ::  kkw                         !< index variable along z
     INTEGER(iwp) ::  n                           !< loop variable over all particles in a grid box
+    INTEGER(iwp) ::  nn                          !< loop variable over iterations steps
     INTEGER(iwp) ::  nb                          !< block number particles are sorted in
     INTEGER(iwp) ::  particle_end                !< end index for partilce loop
@@ -3692 +3601 @@
     INTEGER(iwp) ::  subbox_end                  !< end index for loop over subboxes in particle advection
     INTEGER(iwp) ::  subbox_start                !< start index for loop over subboxes in particle advection
-    INTEGER(iwp) ::  nn                          !< loop variable over iterations steps
-
+
+    INTEGER(iwp), DIMENSION(0:7) ::  end_index   !< start particle index for current block
     INTEGER(iwp), DIMENSION(0:7) ::  start_index !< start particle index for current block
-    INTEGER(iwp), DIMENSION(0:7) ::  end_index   !< start particle index for current block
+
+    LOGICAL ::  subbox_at_wall !< flag to see if the current subgridbox is adjacent to a wall
 
     REAL(wp) ::  aa                 !< dummy argument for horizontal particle interpolation
     REAL(wp) ::  alpha              !< interpolation facor for x-direction
-
     REAL(wp) ::  bb                 !< dummy argument for horizontal particle interpolation
     REAL(wp) ::  beta               !< interpolation facor for y-direction
     REAL(wp) ::  cc                 !< dummy argument for horizontal particle interpolation
-    REAL(wp) ::  d_z_p_z0           !< inverse of interpolation length for logarithmic interpolation 
-    REAL(wp) ::  dd                 !< dummy argument for horizontal particle interpolation 
+    REAL(wp) ::  d_z_p_z0           !< inverse of interpolation length for logarithmic interpolation
+    REAL(wp) ::  dd                 !< dummy argument for horizontal particle interpolation
     REAL(wp) ::  de_dx_int_l        !< x/y-interpolated TKE gradient (x) at particle position at lower vertical level
     REAL(wp) ::  de_dx_int_u        !< x/y-interpolated TKE gradient (x) at particle position at upper vertical level
@@ -3724 +3633 @@
     REAL(wp) ::  exp_term           !< exponent term
     REAL(wp) ::  gamma              !< interpolation facor for z-direction
-    REAL(wp) ::  gg                 !< dummy argument for horizontal particle interpolation 
+    REAL(wp) ::  gg                 !< dummy argument for horizontal particle interpolation
     REAL(wp) ::  height_p           !< dummy argument for logarithmic interpolation
     REAL(wp) ::  log_z_z0_int       !< logarithmus used for surface_layer interpolation
-    REAL(wp) ::  RL                 !< Lagrangian autocorrelation coefficient
+    REAL(wp) ::  rl                 !< Lagrangian autocorrelation coefficient
     REAL(wp) ::  rg1                !< Gaussian distributed random number
     REAL(wp) ::  rg2                !< Gaussian distributed random number
@@ -3739 +3648 @@
     REAL(wp) ::  v_int_u            !< x/y-interpolated v-component at particle position at upper vertical level
     REAL(wp) ::  vnext              !< calculated particle v-velocity of corrector step
-    REAL(wp) ::  vv_int             !< dummy to compute interpolated mean SGS TKE, used to scale SGS advection 
+    REAL(wp) ::  vv_int             !< dummy to compute interpolated mean SGS TKE, used to scale SGS advection
     REAL(wp) ::  w_int_l            !< x/y-interpolated w-component at particle position at lower vertical level
     REAL(wp) ::  w_int_u            !< x/y-interpolated w-component at particle position at upper vertical level
     REAL(wp) ::  wnext              !< calculated particle w-velocity of corrector step
     REAL(wp) ::  w_s                !< terminal velocity of droplets
-    REAL(wp) ::  x                  !< dummy argument for horizontal particle interpolation 
+    REAL(wp) ::  x                  !< dummy argument for horizontal particle interpolation
     REAL(wp) ::  xp                 !< calculated particle position in x of predictor step
     REAL(wp) ::  y                  !< dummy argument for horizontal particle interpolation
@@ -3751 +3660 @@
     REAL(wp) ::  zp                 !< calculated particle position in z of predictor step
 
-    REAL(wp), PARAMETER ::  a_rog = 9.65_wp      !< parameter for fall velocity
-    REAL(wp), PARAMETER ::  b_rog = 10.43_wp     !< parameter for fall velocity
-    REAL(wp), PARAMETER ::  c_rog = 0.6_wp       !< parameter for fall velocity
-    REAL(wp), PARAMETER ::  k_cap_rog = 4.0_wp   !< parameter for fall velocity
-    REAL(wp), PARAMETER ::  k_low_rog = 12.0_wp  !< parameter for fall velocity
-    REAL(wp), PARAMETER ::  d0_rog = 0.745_wp    !< separation diameter
-
-    REAL(wp), DIMENSION(number_of_particles) ::  term_1_2       !< flag to communicate whether a particle is near topography or not
-    REAL(wp), DIMENSION(number_of_particles) ::  dens_ratio     !< ratio between the density of the fluid and the density of the particles 
     REAL(wp), DIMENSION(number_of_particles) ::  de_dx_int      !< horizontal TKE gradient along x at particle position
     REAL(wp), DIMENSION(number_of_particles) ::  de_dy_int      !< horizontal TKE gradient along y at particle position
     REAL(wp), DIMENSION(number_of_particles) ::  de_dz_int      !< horizontal TKE gradient along z at particle position
+    REAL(wp), DIMENSION(number_of_particles) ::  dens_ratio     !< ratio between the density of the fluid and the density of the
+                                                                !< particles
     REAL(wp), DIMENSION(number_of_particles) ::  diss_int       !< dissipation at particle position
     REAL(wp), DIMENSION(number_of_particles) ::  dt_gap         !< remaining time until particle time integration reaches LES time
@@ -3772 +3674 @@
     REAL(wp), DIMENSION(number_of_particles) ::  rvar2_temp     !< SGS particle velocity - v-component
     REAL(wp), DIMENSION(number_of_particles) ::  rvar3_temp     !< SGS particle velocity - w-component
+    REAL(wp), DIMENSION(number_of_particles) ::  term_1_2       !< flag to communicate whether a particle is near topography or not
     REAL(wp), DIMENSION(number_of_particles) ::  u_int          !< u-component of particle speed
-    REAL(wp), DIMENSION(number_of_particles) ::  v_int          !< v-component of particle speed 
+    REAL(wp), DIMENSION(number_of_particles) ::  v_int          !< v-component of particle speed
     REAL(wp), DIMENSION(number_of_particles) ::  w_int          !< w-component of particle speed
     REAL(wp), DIMENSION(number_of_particles) ::  xv             !< x-position
@@ -3783 +3686 @@
     CALL cpu_log( log_point_s(44), 'lpm_advec', 'continue' )
 !
-!-- Determine height of Prandtl layer and distance between Prandtl-layer
-!-- height and horizontal mean roughness height, which are required for
-!-- vertical logarithmic interpolation of horizontal particle speeds
-!-- (for particles below first vertical grid level).
+!-- Determine height of Prandtl layer and distance between Prandtl-layer height and horizontal mean
+!-- roughness height, which are required for vertical logarithmic interpolation of horizontal
+!-- particle speeds (for particles below first vertical grid level).
     z_p      = zu(nzb+1) - zw(nzb)
     d_z_p_z0 = 1.0_wp / ( z_p - z0_av_global )
@@ -3796 +3698 @@
 
 !
-!-- This case uses a simple interpolation method for the particle velocites,
-!-- and applying a predictor-corrector method. @note the current time divergence
-!-- free time step is denoted with u_t etc.; the velocities of the time level of
-!-- t+1 wit u,v, and w, as the model is called after swap timelevel
+!-- This case uses a simple interpolation method for the particle velocites, and applying a
+!-- predictor-corrector method. @note the current time divergence free time step is denoted with
+!-- u_t etc.; the velocities of the time level of t+1 wit u,v, and w, as the model is called after
+!-- swap timelevel
 !-- @attention: for the corrector step the velocities of t(n+1) are required.
-!-- Therefore the particle code is executed at the end of the time intermediate
-!-- timestep routine. This interpolation method is described in more detail
-!-- in Grabowski et al., 2018 (GMD).
+!-- Therefore the particle code is executed at the end of the time intermediate timestep routine.
+!-- This interpolation method is described in more detail in Grabowski et al., 2018 (GMD).
     IF ( interpolation_simple_corrector )  THEN
 !
@@ -3816 +3717 @@
           v_int(n) = v_t(kp,jp,ip) * ( 1.0_wp - beta ) + v_t(kp,jp+1,ip) * beta
 
-          gamma = MAX( MIN( ( particles(n)%z - zw(kkw) ) /                   &
-                            ( zw(kkw+1) - zw(kkw) ), 1.0_wp ), 0.0_wp )
+          gamma = MAX( MIN( ( particles(n)%z - zw(kkw) ) / ( zw(kkw+1) - zw(kkw) ), 1.0_wp ),      &
+                       0.0_wp )
           w_int(n) = w_t(kkw,jp,ip) * ( 1.0_wp - gamma ) + w_t(kkw+1,jp,ip) * gamma
 
@@ -3845 +3746 @@
 !--          z_direction
              k_next = MAX( MIN( FLOOR( zp / (zw(kkw+1)-zw(kkw)) + offset_ocean_nzt ), nzt ), 0)
-             gamma = MAX( MIN( ( zp - zw(k_next) ) /                      &
+             gamma = MAX( MIN( ( zp - zw(k_next) ) /                                               &
                                ( zw(k_next+1) - zw(k_next) ), 1.0_wp ), 0.0_wp )
 !
 !--          Calculate part of the corrector step
-             unext = u(k_next+1, j_next, i_next) * ( 1.0_wp - alpha ) +    &
+             unext = u(k_next+1, j_next, i_next) * ( 1.0_wp - alpha ) +                            &
                      u(k_next+1, j_next,   i_next+1) * alpha
 
-             vnext = v(k_next+1, j_next, i_next) * ( 1.0_wp - beta  ) +    &
+             vnext = v(k_next+1, j_next, i_next) * ( 1.0_wp - beta  ) +                            &
                      v(k_next+1, j_next+1, i_next  ) * beta
 
-             wnext = w(k_next,   j_next, i_next) * ( 1.0_wp - gamma ) +    &
+             wnext = w(k_next,   j_next, i_next) * ( 1.0_wp - gamma ) +                            &
                      w(k_next+1, j_next, i_next  ) * gamma
 
 !
-!--          Calculate interpolated particle velocity with predictor
-!--          corrector step. u_int, v_int and w_int describes the part of
-!--          the predictor step. unext, vnext and wnext is the part of the
-!--          corrector step. The resulting new position is set below. The
-!--          implementation is based on Grabowski et al., 2018 (GMD).
+!--          Calculate interpolated particle velocity with predictor corrector step. u_int, v_int
+!--          and w_int describes the part of the predictor step. unext, vnext and wnext is the part
+!--          of the corrector step. The resulting new position is set below. The implementation is
+!--          based on Grabowski et al., 2018 (GMD).
              u_int(n) = 0.5_wp * ( u_int(n) + unext )
              v_int(n) = 0.5_wp * ( v_int(n) + vnext )
@@ -3871 +3771 @@
        ENDDO
 !
-!-- This case uses a simple interpolation method for the particle velocites,
-!-- and applying a predictor.
+!-- This case uses a simple interpolation method for the particle velocites, and applying a
+!-- predictor.
     ELSEIF ( interpolation_simple_predictor )  THEN
 !
@@ -3886 +3786 @@
           v_int(n) = v(kp,jp,ip) * ( 1.0_wp - beta ) + v(kp,jp+1,ip) * beta
 
-          gamma    = MAX( MIN( ( particles(n)%z - zw(kkw) ) /                   &
-                               ( zw(kkw+1) - zw(kkw) ), 1.0_wp ), 0.0_wp )
+          gamma    = MAX( MIN( ( particles(n)%z - zw(kkw) ) / ( zw(kkw+1) - zw(kkw) ), 1.0_wp ),   &
+                          0.0_wp )
           w_int(n) = w(kkw,jp,ip) * ( 1.0_wp - gamma ) + w(kkw+1,jp,ip) * gamma
        ENDDO
@@ -3907 +3807 @@
 !
 !--          Interpolation of the u velocity component onto particle position.
-!--          Particles are interpolation bi-linearly in the horizontal and a
-!--          linearly in the vertical. An exception is made for particles below
-!--          the first vertical grid level in case of a prandtl layer. In this
-!--          case the horizontal particle velocity components are determined using
-!--          Monin-Obukhov relations (if branch).
-!--          First, check if particle is located below first vertical grid level
-!--          above topography (Prandtl-layer height)
+!--          Particles are interpolation bi-linearly in the horizontal and a linearly in the
+!--          vertical. An exception is made for particles below the first vertical grid level in
+!--          case of a prandtl layer. In this case the horizontal particle velocity components are
+!--          determined using Monin-Obukhov relations (if branch).
+!--          First, check if particle is located below first vertical grid level above topography
+!--          (Prandtl-layer height).
 !--          Determine vertical index of topography top
              k_wall = topo_top_ind(jp,ip,0)
@@ -3925 +3824 @@
 !
 !--                Determine the sublayer. Further used as index.
-                   height_p = ( zv(n) - zw(k_wall) - z0_av_global )            &
-                                        * REAL( number_of_sublayers, KIND=wp ) &
+                   height_p = ( zv(n) - zw(k_wall) - z0_av_global )                                &
+                                        * REAL( number_of_sublayers, KIND=wp )                     &
                                         * d_z_p_z0
 !
 !--                Calculate LOG(z/z0) for exact particle height. Therefore,
 !--                interpolate linearly between precalculated logarithm.
-                   log_z_z0_int = log_z_z0(INT(height_p))                      &
-                                    + ( height_p - INT(height_p) )             &
-                                    * ( log_z_z0(INT(height_p)+1)              &
-                                         - log_z_z0(INT(height_p))             &
-                                      )
+                   log_z_z0_int = log_z_z0( INT( height_p ) ) + ( height_p - INT( height_p ) ) *   &
+                                  ( log_z_z0( INT( height_p ) + 1 ) - log_z_z0( INT( height_p ) ) )
 !
 !--                Compute u*-portion for u-component based on mean roughness.
-!--                Note, neutral solution is applied for all situations, e.g. also for
-!--                unstable and stable situations. Even though this is not exact
-!--                this saves a lot of CPU time since several calls of intrinsic
-!--                FORTRAN procedures (LOG, ATAN) are avoided, This is justified
-!--                as sensitivity studies revealed no significant effect of
-!--                using the neutral solution also for un/stable situations. Based on the u*
-!--                recalculate the velocity at height z_particle. Since the analytical solution
-!--                only yields absolute values, include the sign using the intrinsic SIGN function.
+!--                Note, neutral solution is applied for all situations, e.g. also for unstable and
+!--                stable situations. Even though this is not exact this saves a lot of CPU time
+!--                since several calls of intrinsic FORTRAN procedures (LOG, ATAN) are avoided. This
+!--                is justified as sensitivity studies revealed no significant effect of using the
+!--                neutral solution also for un/stable situations. Based on the u* recalculate the
+!--                velocity at height z_particle. Since the analytical solution only yields absolute
+!--                values, include the sign using the intrinsic SIGN function.
                    us_int   = kappa * 0.5_wp * ABS( u(k_wall+1,jp,ip) + u(k_wall+1,jp,ip+1) ) /    &
                               log_z_z0(number_of_sublayers)
@@ -3953 +3848 @@
                 ENDIF
 !
-!--          Particle above the first grid level. Bi-linear interpolation in the
-!--          horizontal and linear interpolation in the vertical direction.
+!--          Particle above the first grid level. Bi-linear interpolation in the horizontal and
+!--          linear interpolation in the vertical direction.
              ELSE
                 x  = xv(n) - i * dx
@@ -3964 +3859 @@
                 gg = aa + bb + cc + dd
 
-                u_int_l = ( ( gg - aa ) * u(k,j,i)   + ( gg - bb ) * u(k,j,i+1)   &
-                            + ( gg - cc ) * u(k,j+1,i) + ( gg - dd ) *            &
-                            u(k,j+1,i+1) ) / ( 3.0_wp * gg ) - u_gtrans
+                u_int_l = ( ( gg - aa ) * u(k,j,i)   + ( gg - bb ) * u(k,j,i+1)                    &
+                            + ( gg - cc ) * u(k,j+1,i) + ( gg - dd ) * u(k,j+1,i+1) )              &
+                          / ( 3.0_wp * gg ) - u_gtrans
 
                 IF ( k == nzt )  THEN
                    u_int(n) = u_int_l
                 ELSE
-                   u_int_u = ( ( gg-aa ) * u(k+1,j,i) + ( gg-bb ) * u(k+1,j,i+1)  &
-                               + ( gg-cc ) * u(k+1,j+1,i) + ( gg-dd ) *           &
-                               u(k+1,j+1,i+1) ) / ( 3.0_wp * gg ) - u_gtrans
-                   u_int(n) = u_int_l + ( zv(n) - zu(k) ) / dzw(k+1) *            &
-                              ( u_int_u - u_int_l )
+                   u_int_u = ( ( gg-aa ) * u(k+1,j,i) + ( gg-bb ) * u(k+1,j,i+1)                   &
+                               + ( gg-cc ) * u(k+1,j+1,i) + ( gg-dd ) * u(k+1,j+1,i+1) )           &
+                             / ( 3.0_wp * gg ) - u_gtrans
+                   u_int(n) = u_int_l + ( zv(n) - zu(k) ) / dzw(k+1) * ( u_int_u - u_int_l )
                 ENDIF
              ENDIF
@@ -3998 +3892 @@
 !
 !--                Determine the sublayer. Further used as index.
-                   height_p = ( zv(n) - zw(k_wall) - z0_av_global )            &
-                                        * REAL( number_of_sublayers, KIND=wp ) &
+                   height_p = ( zv(n) - zw(k_wall) - z0_av_global )                                &
+                                        * REAL( number_of_sublayers, KIND=wp )                     &
                                         * d_z_p_z0
 !
-!--                Calculate LOG(z/z0) for exact particle height. Therefore,
-!--                interpolate linearly between precalculated logarithm.
-                   log_z_z0_int = log_z_z0(INT(height_p))                      &
-                                    + ( height_p - INT(height_p) )             &
-                                    * ( log_z_z0(INT(height_p)+1)              &
-                                         - log_z_z0(INT(height_p))             &
+!--                Calculate LOG(z/z0) for exact particle height. Therefore, interpolate linearly
+!--                between precalculated logarithm.
+                   log_z_z0_int = log_z_z0(INT(height_p))                                          &
+                                    + ( height_p - INT(height_p) )                                 &
+                                    * ( log_z_z0(INT(height_p)+1) - log_z_z0(INT(height_p))        &
                                       )
 !
 !--                Compute u*-portion for v-component based on mean roughness.
-!--                Note, neutral solution is applied for all situations, e.g. also for
-!--                unstable and stable situations. Even though this is not exact
-!--                this saves a lot of CPU time since several calls of intrinsic
-!--                FORTRAN procedures (LOG, ATAN) are avoided, This is justified
-!--                as sensitivity studies revealed no significant effect of
-!--                using the neutral solution also for un/stable situations. Based on the u*
-!--                recalculate the velocity at height z_particle. Since the analytical solution
-!--                only yields absolute values, include the sign using the intrinsic SIGN function.
+!--                Note, neutral solution is applied for all situations, e.g. also for unstable and
+!--                stable situations. Even though this is not exact this saves a lot of CPU time
+!--                since several calls of intrinsic FORTRAN procedures (LOG, ATAN) are avoided, This
+!--                is justified as sensitivity studies revealed no significant effect of using the
+!--                neutral solution also for un/stable situations. Based on the u* recalculate the
+!--                velocity at height z_particle. Since the analytical solution only yields absolute
+!--                values, include the sign using the intrinsic SIGN function.
                    us_int   = kappa * 0.5_wp * ABS( v(k_wall+1,jp,ip) + v(k_wall+1,jp+1,ip) ) /    &
                               log_z_z0(number_of_sublayers)
@@ -4034 +3926 @@
                 gg = aa + bb + cc + dd
 
-                v_int_l = ( ( gg - aa ) * v(k,j,i)   + ( gg - bb ) * v(k,j,i+1)   &
-                          + ( gg - cc ) * v(k,j+1,i) + ( gg - dd ) * v(k,j+1,i+1) &
+                v_int_l = ( ( gg - aa ) * v(k,j,i)   + ( gg - bb ) * v(k,j,i+1)                    &
+                          + ( gg - cc ) * v(k,j+1,i) + ( gg - dd ) * v(k,j+1,i+1)                  &
                           ) / ( 3.0_wp * gg ) - v_gtrans
 
@@ -4041 +3933 @@
                    v_int(n) = v_int_l
                 ELSE
-                   v_int_u = ( ( gg-aa ) * v(k+1,j,i)   + ( gg-bb ) * v(k+1,j,i+1)   &
-                             + ( gg-cc ) * v(k+1,j+1,i) + ( gg-dd ) * v(k+1,j+1,i+1) &
+                   v_int_u = ( ( gg-aa ) * v(k+1,j,i)   + ( gg-bb ) * v(k+1,j,i+1)                 &
+                             + ( gg-cc ) * v(k+1,j+1,i) + ( gg-dd ) * v(k+1,j+1,i+1)               &
                              ) / ( 3.0_wp * gg ) - v_gtrans
-                   v_int(n) = v_int_l + ( zv(n) - zu(k) ) / dzw(k+1) *               &
-                                     ( v_int_u - v_int_l )
+                   v_int(n) = v_int_l + ( zv(n) - zu(k) ) / dzw(k+1) * ( v_int_u - v_int_l )
                 ENDIF
              ENDIF
@@ -4065 +3956 @@
                 gg = aa + bb + cc + dd
 
-                w_int_l = ( ( gg - aa ) * w(k,j,i)   + ( gg - bb ) * w(k,j,i+1)   &
-                          + ( gg - cc ) * w(k,j+1,i) + ( gg - dd ) * w(k,j+1,i+1) &
+                w_int_l = ( ( gg - aa ) * w(k,j,i)   + ( gg - bb ) * w(k,j,i+1)                    &
+                          + ( gg - cc ) * w(k,j+1,i) + ( gg - dd ) * w(k,j+1,i+1)                  &
                           ) / ( 3.0_wp * gg )
 
@@ -4072 +3963 @@
                    w_int(n) = w_int_l
                 ELSE
-                   w_int_u = ( ( gg-aa ) * w(k+1,j,i)   + &
-                               ( gg-bb ) * w(k+1,j,i+1) + &
-                               ( gg-cc ) * w(k+1,j+1,i) + &
-                               ( gg-dd ) * w(k+1,j+1,i+1) &
+                   w_int_u = ( ( gg-aa ) * w(k+1,j,i)   +                                          &
+                               ( gg-bb ) * w(k+1,j,i+1) +                                          &
+                               ( gg-cc ) * w(k+1,j+1,i) +                                          &
+                               ( gg-dd ) * w(k+1,j+1,i+1)                                          &
                              ) / ( 3.0_wp * gg )
-                   w_int(n) = w_int_l + ( zv(n) - zw(k) ) / dzw(k+1) *            &
-                              ( w_int_u - w_int_l )
+                   w_int(n) = w_int_l + ( zv(n) - zw(k) ) / dzw(k+1) * ( w_int_u - w_int_l )
                 ENDIF
              ELSE
@@ -4087 +3977 @@
     ENDIF
 
-!-- Interpolate and calculate quantities needed for calculating the SGS
-!-- velocities
+!-- Interpolate and calculate quantities needed for calculating the SGS velocities
     IF ( use_sgs_for_particles  .AND.  .NOT. cloud_droplets )  THEN
 
@@ -4100 +3989 @@
              j = jp + MERGE( -1_iwp , 1_iwp, BTEST( nb, 1 ) )
              k = kp + MERGE( -1_iwp , 1_iwp, BTEST( nb, 0 ) )
-             IF ( .NOT. BTEST(wall_flags_total_0(k,  jp, ip), 0) .OR.             &
-                  .NOT. BTEST(wall_flags_total_0(kp, j,  ip), 0) .OR.             &
-                  .NOT. BTEST(wall_flags_total_0(kp, jp, i ), 0) )                &
+             IF ( .NOT. BTEST(wall_flags_total_0(k,  jp, ip), 0) .OR.                              &
+                  .NOT. BTEST(wall_flags_total_0(kp, j,  ip), 0) .OR.                              &
+                  .NOT. BTEST(wall_flags_total_0(kp, jp, i ), 0) )                                 &
              THEN
                 subbox_at_wall = .TRUE.
@@ -4108 +3997 @@
           ENDIF
           IF ( subbox_at_wall )  THEN
-             e_int(start_index(nb):end_index(nb))     = e(kp,jp,ip) 
+             e_int(start_index(nb):end_index(nb))     = e(kp,jp,ip)
              diss_int(start_index(nb):end_index(nb))  = diss(kp,jp,ip)
              de_dx_int(start_index(nb):end_index(nb)) = de_dx(kp,jp,ip)
@@ -4132 +4021 @@
                 gg = aa + bb + cc + dd
 
-                e_int_l = ( ( gg-aa ) * e(k,j,i)   + ( gg-bb ) * e(k,j,i+1)   &
-                          + ( gg-cc ) * e(k,j+1,i) + ( gg-dd ) * e(k,j+1,i+1) &
+                e_int_l = ( ( gg-aa ) * e(k,j,i)   + ( gg-bb ) * e(k,j,i+1)                        &
+                          + ( gg-cc ) * e(k,j+1,i) + ( gg-dd ) * e(k,j+1,i+1)                      &
                           ) / ( 3.0_wp * gg )
 
@@ -4144 +4033 @@
                                ( gg - dd ) * e(k+1,j+1,i+1) &
                             ) / ( 3.0_wp * gg )
-                   e_int(n) = e_int_l + ( zv(n) - zu(k) ) / dzw(k+1) *            &
-                                     ( e_int_u - e_int_l )
+                   e_int(n) = e_int_l + ( zv(n) - zu(k) ) / dzw(k+1) * ( e_int_u - e_int_l )
                 ENDIF
 !
-!--             Needed to avoid NaN particle velocities (this might not be
-!--             required any more)
+!--             Needed to avoid NaN particle velocities (this might not be required any more)
                 IF ( e_int(n) <= 0.0_wp )  THEN
                    e_int(n) = 1.0E-20_wp
                 ENDIF
 !
-!--             Interpolate the TKE gradient along x (adopt incides i,j,k and
-!--             all position variables from above (TKE))
-                de_dx_int_l = ( ( gg - aa ) * de_dx(k,j,i)   + &
-                                ( gg - bb ) * de_dx(k,j,i+1) + &
-                                ( gg - cc ) * de_dx(k,j+1,i) + &
-                                ( gg - dd ) * de_dx(k,j+1,i+1) &
+!--             Interpolate the TKE gradient along x (adopt incides i,j,k and all position variables
+!--             from above (TKE))
+                de_dx_int_l = ( ( gg - aa ) * de_dx(k,j,i)   +                                     &
+                                ( gg - bb ) * de_dx(k,j,i+1) +                                     &
+                                ( gg - cc ) * de_dx(k,j+1,i) +                                     &
+                                ( gg - dd ) * de_dx(k,j+1,i+1)                                     &
                                ) / ( 3.0_wp * gg )
 
@@ -4165 +4052 @@
                    de_dx_int(n) = de_dx_int_l
                 ELSE
-                   de_dx_int_u = ( ( gg - aa ) * de_dx(k+1,j,i)   + &
-                                   ( gg - bb ) * de_dx(k+1,j,i+1) + &
-                                   ( gg - cc ) * de_dx(k+1,j+1,i) + &
-                                   ( gg - dd ) * de_dx(k+1,j+1,i+1) &
+                   de_dx_int_u = ( ( gg - aa ) * de_dx(k+1,j,i)   +                                &
+                                   ( gg - bb ) * de_dx(k+1,j,i+1) +                                &
+                                   ( gg - cc ) * de_dx(k+1,j+1,i) +                                &
+                                   ( gg - dd ) * de_dx(k+1,j+1,i+1)                                &
                                   ) / ( 3.0_wp * gg )
-                   de_dx_int(n) = de_dx_int_l + ( zv(n) - zu(k) ) / dzw(k+1) *    &
+                   de_dx_int(n) = de_dx_int_l + ( zv(n) - zu(k) ) / dzw(k+1) *                     &
                                               ( de_dx_int_u - de_dx_int_l )
                 ENDIF
 !
 !--             Interpolate the TKE gradient along y
-                de_dy_int_l = ( ( gg - aa ) * de_dy(k,j,i)   + &
-                                ( gg - bb ) * de_dy(k,j,i+1) + &
-                                ( gg - cc ) * de_dy(k,j+1,i) + &
-                                ( gg - dd ) * de_dy(k,j+1,i+1) &
+                de_dy_int_l = ( ( gg - aa ) * de_dy(k,j,i)   +                                     &
+                                ( gg - bb ) * de_dy(k,j,i+1) +                                     &
+                                ( gg - cc ) * de_dy(k,j+1,i) +                                     &
+                                ( gg - dd ) * de_dy(k,j+1,i+1)                                     &
                                ) / ( 3.0_wp * gg )
                 IF ( ( k+1 == nzt+1 )  .OR.  ( k == nzb ) )  THEN
                    de_dy_int(n) = de_dy_int_l
                 ELSE
-                   de_dy_int_u = ( ( gg - aa ) * de_dy(k+1,j,i)   + &
-                                   ( gg - bb ) * de_dy(k+1,j,i+1) + &
-                                   ( gg - cc ) * de_dy(k+1,j+1,i) + &
-                                   ( gg - dd ) * de_dy(k+1,j+1,i+1) &
+                   de_dy_int_u = ( ( gg - aa ) * de_dy(k+1,j,i)   +                                &
+                                   ( gg - bb ) * de_dy(k+1,j,i+1) +                                &
+                                   ( gg - cc ) * de_dy(k+1,j+1,i) +                                &
+                                   ( gg - dd ) * de_dy(k+1,j+1,i+1)                                &
                                   ) / ( 3.0_wp * gg )
-                      de_dy_int(n) = de_dy_int_l + ( zv(n) - zu(k) ) / dzw(k+1) * &
+                      de_dy_int(n) = de_dy_int_l + ( zv(n) - zu(k) ) / dzw(k+1) *                  &
                                                  ( de_dy_int_u - de_dy_int_l )
                 ENDIF
@@ -4197 +4084 @@
                    de_dz_int(n) = 0.0_wp
                 ELSE
-                   de_dz_int_l = ( ( gg - aa ) * de_dz(k,j,i)   + &
-                                   ( gg - bb ) * de_dz(k,j,i+1) + &
-                                   ( gg - cc ) * de_dz(k,j+1,i) + &
-                                   ( gg - dd ) * de_dz(k,j+1,i+1) &
+                   de_dz_int_l = ( ( gg - aa ) * de_dz(k,j,i)   +                                  &
+                                   ( gg - bb ) * de_dz(k,j,i+1) +                                  &
+                                   ( gg - cc ) * de_dz(k,j+1,i) +                                  &
+                                   ( gg - dd ) * de_dz(k,j+1,i+1)                                  &
                                   ) / ( 3.0_wp * gg )
 
@@ -4206 +4093 @@
                       de_dz_int(n) = de_dz_int_l
                    ELSE
-                      de_dz_int_u = ( ( gg - aa ) * de_dz(k+1,j,i)   + &
-                                      ( gg - bb ) * de_dz(k+1,j,i+1) + &
-                                      ( gg - cc ) * de_dz(k+1,j+1,i) + &
-                                      ( gg - dd ) * de_dz(k+1,j+1,i+1) &
+                      de_dz_int_u = ( ( gg - aa ) * de_dz(k+1,j,i)   +                             &
+                                      ( gg - bb ) * de_dz(k+1,j,i+1) +                             &
+                                      ( gg - cc ) * de_dz(k+1,j+1,i) +                             &
+                                      ( gg - dd ) * de_dz(k+1,j+1,i+1)                             &
                                      ) / ( 3.0_wp * gg )
-                      de_dz_int(n) = de_dz_int_l + ( zv(n) - zu(k) ) / dzw(k+1) * &
+                      de_dz_int(n) = de_dz_int_l + ( zv(n) - zu(k) ) / dzw(k+1) *                  &
                                                  ( de_dz_int_u - de_dz_int_l )
                    ENDIF
@@ -4218 +4105 @@
 !
 !--             Interpolate the dissipation of TKE
-                diss_int_l = ( ( gg - aa ) * diss(k,j,i)   + &
-                               ( gg - bb ) * diss(k,j,i+1) + &
-                               ( gg - cc ) * diss(k,j+1,i) + &
-                               ( gg - dd ) * diss(k,j+1,i+1) &
+                diss_int_l = ( ( gg - aa ) * diss(k,j,i)   +                                       &
+                               ( gg - bb ) * diss(k,j,i+1) +                                       &
+                               ( gg - cc ) * diss(k,j+1,i) +                                       &
+                               ( gg - dd ) * diss(k,j+1,i+1)                                       &
                                ) / ( 3.0_wp * gg )
 
@@ -4227 +4114 @@
                    diss_int(n) = diss_int_l
                 ELSE
-                   diss_int_u = ( ( gg - aa ) * diss(k+1,j,i)   + &
-                                  ( gg - bb ) * diss(k+1,j,i+1) + &
-                                  ( gg - cc ) * diss(k+1,j+1,i) + &
-                                  ( gg - dd ) * diss(k+1,j+1,i+1) &
+                   diss_int_u = ( ( gg - aa ) * diss(k+1,j,i)   +                                  &
+                                  ( gg - bb ) * diss(k+1,j,i+1) +                                  &
+                                  ( gg - cc ) * diss(k+1,j+1,i) +                                  &
+                                  ( gg - dd ) * diss(k+1,j+1,i+1)                                  &
                                  ) / ( 3.0_wp * gg )
-                   diss_int(n) = diss_int_l + ( zv(n) - zu(k) ) / dzw(k+1) *      &
+                   diss_int(n) = diss_int_l + ( zv(n) - zu(k) ) / dzw(k+1) *                       &
                                             ( diss_int_u - diss_int_l )
                 ENDIF
@@ -4250 +4137 @@
           DO  n = start_index(nb), end_index(nb)
 !
-!--          Vertical interpolation of the horizontally averaged SGS TKE and
-!--          resolved-scale velocity variances and use the interpolated values
-!--          to calculate the coefficient fs, which is a measure of the ratio
-!--          of the subgrid-scale turbulent kinetic energy to the total amount
+!--          Vertical interpolation of the horizontally averaged SGS TKE and resolved-scale velocity
+!--          variances and use the interpolated values to calculate the coefficient fs, which is a
+!--          measure of the ratio of the subgrid-scale turbulent kinetic energy to the total amount
 !--          of turbulent kinetic energy.
              IF ( k == 0 )  THEN
                 e_mean_int = hom(0,1,8,0)
              ELSE
-                e_mean_int = hom(k,1,8,0) +                                    &
-                                           ( hom(k+1,1,8,0) - hom(k,1,8,0) ) / &
-                                           ( zu(k+1) - zu(k) ) *               &
-                                           ( zv(n) - zu(k) )
+                e_mean_int = hom(k,1,8,0) + ( hom(k+1,1,8,0) - hom(k,1,8,0) ) /                    &
+                                            ( zu(k+1) - zu(k) ) *                                  &
+                                            ( zv(n) - zu(k) )
              ENDIF
 
@@ -4274 +4159 @@
                                          ( 1.0_wp * ( zw(kw+1) - zw(kw) ) ) )
              ELSE
-                aa  = hom(k,1,30,0) + ( hom(k+1,1,30,0) - hom(k,1,30,0) ) *    &
+                aa  = hom(k,1,30,0) + ( hom(k+1,1,30,0) - hom(k,1,30,0) ) *                        &
                            ( ( zv(n) - zu(k) ) / ( zu(k+1) - zu(k) ) )
-                bb  = hom(k,1,31,0) + ( hom(k+1,1,31,0) - hom(k,1,31,0) ) *    &
+                bb  = hom(k,1,31,0) + ( hom(k+1,1,31,0) - hom(k,1,31,0) ) *                        &
                            ( ( zv(n) - zu(k) ) / ( zu(k+1) - zu(k) ) )
-                cc  = hom(kw,1,32,0) + ( hom(kw+1,1,32,0)-hom(kw,1,32,0) ) *   &
+                cc  = hom(kw,1,32,0) + ( hom(kw+1,1,32,0)-hom(kw,1,32,0) ) *                       &
                            ( ( zv(n) - zw(kw) ) / ( zw(kw+1)-zw(kw) ) )
              ENDIF
@@ -4284 +4169 @@
              vv_int = ( 1.0_wp / 3.0_wp ) * ( aa + bb + cc )
 !
-!--          Needed to avoid NaN particle velocities. The value of 1.0 is just
-!--          an educated guess for the given case.
+!--          Needed to avoid NaN particle velocities. The value of 1.0 is just an educated guess for
+!--          the given case.
              IF ( vv_int + ( 2.0_wp / 3.0_wp ) * e_mean_int == 0.0_wp )  THEN
                 fs_int(n) = 1.0_wp
              ELSE
-                fs_int(n) = ( 2.0_wp / 3.0_wp ) * e_mean_int /                 &
+                fs_int(n) = ( 2.0_wp / 3.0_wp ) * e_mean_int /                                     &
                             ( vv_int + ( 2.0_wp / 3.0_wp ) * e_mean_int )
              ENDIF
@@ -4312 +4197 @@
 !
 !--          Calculate the Lagrangian timescale according to Weil et al. (2004).
-             lagr_timescale(n) = ( 4.0_wp * e_int(n) + 1E-20_wp ) / &
-                              ( 3.0_wp * fs_int(n) * c_0 * diss_int(n) + 1E-20_wp )
-
-!
-!--          Calculate the next particle timestep. dt_gap is the time needed to
-!--          complete the current LES timestep.
+             lagr_timescale(n) = ( 4.0_wp * e_int(n) + 1E-20_wp ) /                                &
+                                 ( 3.0_wp * fs_int(n) * c_0 * diss_int(n) + 1E-20_wp )
+
+!
+!--          Calculate the next particle timestep. dt_gap is the time needed to complete the current
+!--          LES timestep.
              dt_gap(n) = dt_3d - particles(n)%dt_sum
              dt_particle(n) = MIN( dt_3d, 0.025_wp * lagr_timescale(n), dt_gap(n) )
@@ -4323 +4208 @@
              particles(n)%aux2 = dt_gap(n)
 !
-!--          The particle timestep should not be too small in order to prevent
-!--          the number of particle timesteps of getting too large
+!--          The particle timestep should not be too small in order to prevent the number of
+!--          particle timesteps of getting too large
              IF ( dt_particle(n) < dt_min_part )  THEN
                 IF ( dt_min_part < dt_gap(n) )  THEN
@@ -4340 +4225 @@
              IF ( particles(n)%age == 0.0_wp )  THEN
 !
-!--             For new particles the SGS components are derived from the SGS
-!--             TKE. Limit the Gaussian random number to the interval
-!--             [-5.0*sigma, 5.0*sigma] in order to prevent the SGS velocities
-!--             from becoming unrealistically large.
-                rvar1_temp(n) = SQRT( 2.0_wp * sgs_wf_part * e_int(n)          &
-                                          + 1E-20_wp ) * rg(n,1)
-                rvar2_temp(n) = SQRT( 2.0_wp * sgs_wf_part * e_int(n)          &
-                                          + 1E-20_wp ) * rg(n,2)
-                rvar3_temp(n) = SQRT( 2.0_wp * sgs_wf_part * e_int(n)          &
-                                          + 1E-20_wp ) * rg(n,3)
+!--             For new particles the SGS components are derived from the SGS TKE. Limit the
+!--             Gaussian random number to the interval [-5.0*sigma, 5.0*sigma] in order to prevent
+!--             the SGS velocities from becoming unrealistically large.
+                rvar1_temp(n) = SQRT( 2.0_wp * sgs_wf_part * e_int(n) + 1E-20_wp ) * rg(n,1)
+                rvar2_temp(n) = SQRT( 2.0_wp * sgs_wf_part * e_int(n) + 1E-20_wp ) * rg(n,2)
+                rvar3_temp(n) = SQRT( 2.0_wp * sgs_wf_part * e_int(n) + 1E-20_wp ) * rg(n,3)
              ELSE
 !
-!--             Restriction of the size of the new timestep: compared to the 
+!--             Restriction of the size of the new timestep: compared to the
 !--             previous timestep the increase must not exceed 200%. First,
 !--             check if age > age_m, in order to prevent that particles get zero
 !--             timestep.
-                dt_particle_m = MERGE( dt_particle(n),                         &
-                                       particles(n)%age - particles(n)%age_m,  &
-                                       particles(n)%age - particles(n)%age_m < &
-                                       1E-8_wp )
+                dt_particle_m = MERGE( dt_particle(n),                                             &
+                                       particles(n)%age - particles(n)%age_m,                      &
+                                       particles(n)%age - particles(n)%age_m < 1E-8_wp )
                 IF ( dt_particle(n) > 2.0_wp * dt_particle_m )  THEN
                    dt_particle(n) = 2.0_wp * dt_particle_m
                 ENDIF
 
-!--             For old particles the SGS components are correlated with the
-!--             values from the previous timestep. Random numbers have also to
-!--             be limited (see above).
-!--             As negative values for the subgrid TKE are not allowed, the
-!--             change of the subgrid TKE with time cannot be smaller than
-!--             -e_int(n)/dt_particle. This value is used as a lower boundary
-!--             value for the change of TKE 
+!--             For old particles the SGS components are correlated with the values from the
+!--             previous timestep. Random numbers have also to be limited (see above).
+!--             As negative values for the subgrid TKE are not allowed, the change of the subgrid
+!--             TKE with time cannot be smaller than -e_int(n)/dt_particle. This value is used as a
+!--             lower boundary value for the change of TKE
                 de_dt_min = - e_int(n) / dt_particle(n)
 
@@ -4379 +4257 @@
                 ENDIF
 
-                CALL weil_stochastic_eq( rvar1_temp(n), fs_int(n), e_int(n),    &
-                                        de_dx_int(n), de_dt, diss_int(n),       &
-                                        dt_particle(n), rg(n,1), term_1_2(n) )
-
-                CALL weil_stochastic_eq( rvar2_temp(n), fs_int(n), e_int(n),    &
-                                        de_dy_int(n), de_dt, diss_int(n),       &
-                                        dt_particle(n), rg(n,2), term_1_2(n) )
-
-                CALL weil_stochastic_eq( rvar3_temp(n), fs_int(n), e_int(n),    &
-                                        de_dz_int(n), de_dt, diss_int(n),       &
-                                        dt_particle(n), rg(n,3), term_1_2(n) )
+                CALL weil_stochastic_eq( rvar1_temp(n), fs_int(n), e_int(n), de_dx_int(n), de_dt,  &
+                                         diss_int(n), dt_particle(n), rg(n,1), term_1_2(n) )
+
+                CALL weil_stochastic_eq( rvar2_temp(n), fs_int(n), e_int(n), de_dy_int(n), de_dt,  &
+                                         diss_int(n), dt_particle(n), rg(n,2), term_1_2(n) )
+
+                CALL weil_stochastic_eq( rvar3_temp(n), fs_int(n), e_int(n), de_dz_int(n), de_dt,  &
+                                         diss_int(n), dt_particle(n), rg(n,3), term_1_2(n) )
 
              ENDIF
@@ -4396 +4271 @@
        ENDDO
 !
-!--    Check if the added SGS velocities result in a violation of the CFL-
-!--    criterion. If yes, limt the SGS particle speed to match the
-!--    CFL criterion. Note, a re-calculation of the SGS particle speed with
-!--    smaller timestep does not necessarily fulfill the CFL criterion as the 
-!--    new SGS speed can be even larger (due to the random term with scales with
-!--    the square-root of dt_particle, for small dt the random contribution increases).
-!--    Thus, we would need to re-calculate the SGS speeds as long as they would
-!--    fulfill the requirements, which could become computationally expensive, 
+!--    Check if the added SGS velocities result in a violation of the CFL-criterion. If yes, limt
+!--    the SGS particle speed to match the CFL criterion. Note, a re-calculation of the SGS particle
+!--    speed with smaller timestep does not necessarily fulfill the CFL criterion as the new SGS
+!--    speed can be even larger (due to the random term with scales with the square-root of
+!--    dt_particle, for small dt the random contribution increases).
+!--    Thus, we would need to re-calculate the SGS speeds as long as they would fulfill the
+!--    requirements, which could become computationally expensive,
 !--    Hence, we just limit them.
        dz_temp = zw(kp)-zw(kp-1)
@@ -4409 +4283 @@
        DO  nb = 0, 7
           DO  n = start_index(nb), end_index(nb)
-             IF ( ABS( u_int(n) + rvar1_temp(n) ) > ( dx      / dt_particle(n) )  .OR.   &
-                  ABS( v_int(n) + rvar2_temp(n) ) > ( dy      / dt_particle(n) )  .OR.   &
+             IF ( ABS( u_int(n) + rvar1_temp(n) ) > ( dx      / dt_particle(n) )  .OR.             &
+                  ABS( v_int(n) + rvar2_temp(n) ) > ( dy      / dt_particle(n) )  .OR.             &
                   ABS( w_int(n) + rvar3_temp(n) ) > ( dz_temp / dt_particle(n) ) )  THEN
 !
-!--             If total speed exceeds the allowed speed according to CFL 
+!--             If total speed exceeds the allowed speed according to CFL
 !--             criterion, limit the SGS speed to
 !--             dx_i / dt_particle - u_resolved_i, considering a safty factor.
-                rvar1_temp(n) = MERGE( rvar1_temp(n),                          &
-                                       0.9_wp *                                &
-                                       SIGN( dx / dt_particle(n)               &
-                                           - ABS( u_int(n) ), rvar1_temp(n) ), &
-                                       ABS( u_int(n) + rvar1_temp(n) ) <       &
+                rvar1_temp(n) = MERGE( rvar1_temp(n),                                              &
+                                       0.9_wp *                                                    &
+                                       SIGN( dx / dt_particle(n)                                   &
+                                             - ABS( u_int(n) ), rvar1_temp(n) ),                   &
+                                       ABS( u_int(n) + rvar1_temp(n) ) <                           &
                                        ( dx / dt_particle(n) ) )
-                rvar2_temp(n) = MERGE( rvar2_temp(n),                          &
-                                       0.9_wp *                                &
-                                       SIGN( dy / dt_particle(n)               &
-                                           - ABS( v_int(n) ), rvar2_temp(n) ), &
-                                       ABS( v_int(n) + rvar2_temp(n) ) <       &
+                rvar2_temp(n) = MERGE( rvar2_temp(n),                                              &
+                                       0.9_wp *                                                    &
+                                       SIGN( dy / dt_particle(n)                                   &
+                                             - ABS( v_int(n) ), rvar2_temp(n) ),                   &
+                                       ABS( v_int(n) + rvar2_temp(n) ) <                           &
                                        ( dy / dt_particle(n) ) )
-                rvar3_temp(n) = MERGE( rvar3_temp(n),                          &
-                                       0.9_wp *                                &
-                                       SIGN( zw(kp)-zw(kp-1) / dt_particle(n)  &
-                                           - ABS( w_int(n) ), rvar3_temp(n) ), &
-                                       ABS( w_int(n) + rvar3_temp(n) ) <       &
+                rvar3_temp(n) = MERGE( rvar3_temp(n),                                              &
+                                       0.9_wp *                                                    &
+                                       SIGN( zw(kp)-zw(kp-1) / dt_particle(n)                      &
+                                             - ABS( w_int(n) ), rvar3_temp(n) ),                   &
+                                       ABS( w_int(n) + rvar3_temp(n) ) <                           &
                                        ( zw(kp)-zw(kp-1) / dt_particle(n) ) )
              ENDIF
 !
-!--          Update particle velocites 
+!--          Update particle velocites
              particles(n)%rvar1 = rvar1_temp(n)
              particles(n)%rvar2 = rvar2_temp(n)
@@ -4444 +4318 @@
              w_int(n) = w_int(n) + particles(n)%rvar3
 !
-!--          Store the SGS TKE of the current timelevel which is needed for
-!--          for calculating the SGS particle velocities at the next timestep
+!--          Store the SGS TKE of the current timelevel which is needed for for calculating the SGS
+!--          particle velocities at the next timestep
              particles(n)%e_m = e_int(n)
           ENDDO
@@ -4452 +4326 @@
     ELSE
 !
-!--    If no SGS velocities are used, only the particle timestep has to
-!--    be set
+!--    If no SGS velocities are used, only the particle timestep has to be set
        dt_particle = dt_3d
 
@@ -4461 +4334 @@
     IF ( ANY( dens_ratio == 0.0_wp ) )  THEN
 !
-!--    Decide whether the particle loop runs over the subboxes or only over 1,
-!--    number_of_particles. This depends on the selected interpolation method.
-!--    If particle interpolation method is not trilinear, then the sorting within
-!--    subboxes is not required. However, therefore the index start_index(nb) and
-!--    end_index(nb) are not defined and the loops are still over
-!--    number_of_particles. @todo find a more generic way to write this loop or
-!--    delete trilinear interpolation
+!--    Decide whether the particle loop runs over the subboxes or only over 1, number_of_particles.
+!--    This depends on the selected interpolation method.
+!--    If particle interpolation method is not trilinear, then the sorting within subboxes is not
+!--    required. However, therefore the index start_index(nb) and end_index(nb) are not defined and
+!--    the loops are still over number_of_particles. @todo find a more generic way to write this
+!--    loop or delete trilinear interpolation
        IF ( interpolation_trilinear )  THEN
           subbox_start = 0
@@ -4476 +4348 @@
        ENDIF
 !
-!--    loop over subboxes. In case of simple interpolation scheme no subboxes
-!--    are introduced, as they are not required. Accordingly, this loops goes
-!--    from 1 to 1.
+!--    loop over subboxes. In case of simple interpolation scheme no subboxes are introduced, as
+!--    they are not required. Accordingly, this loop goes from 1 to 1.
        DO  nb = subbox_start, subbox_end
           IF ( interpolation_trilinear )  THEN
@@ -4507 +4378 @@
 !
 !--             Transport of particles with inertia
-                particles(n)%x = particles(n)%x + particles(n)%speed_x * &
-                                                  dt_particle(n)
-                particles(n)%y = particles(n)%y + particles(n)%speed_y * &
-                                                  dt_particle(n)
-                particles(n)%z = particles(n)%z + particles(n)%speed_z * &
-                                                  dt_particle(n)
+                particles(n)%x = particles(n)%x + particles(n)%speed_x * dt_particle(n)
+                particles(n)%y = particles(n)%y + particles(n)%speed_y * dt_particle(n)
+                particles(n)%z = particles(n)%z + particles(n)%speed_z * dt_particle(n)
 
 !
@@ -4532 +4400 @@
                    IF ( use_sgs_for_particles )  THEN
                       lagr_timescale(n) = km(kp,jp,ip) / MAX( e(kp,jp,ip), 1.0E-20_wp )
-                      RL             = EXP( -1.0_wp * dt_3d / MAX( lagr_timescale(n), &
-                                             1.0E-20_wp ) )
-                      sigma          = SQRT( e(kp,jp,ip) )
+                      rl    = EXP( -1.0_wp * dt_3d / MAX( lagr_timescale(n), 1.0E-20_wp ) )
+                      sigma = SQRT( e(kp,jp,ip) )
 !
 !--                   Calculate random component of particle sgs velocity using parallel
@@ -4545 +4412 @@
                       rg3 = random_dummy
 
-                      particles(n)%rvar1 = RL * particles(n)%rvar1 +              &
-                                           SQRT( 1.0_wp - RL**2 ) * sigma * rg1
-                      particles(n)%rvar2 = RL * particles(n)%rvar2 +              &
-                                           SQRT( 1.0_wp - RL**2 ) * sigma * rg2
-                      particles(n)%rvar3 = RL * particles(n)%rvar3 +              &
-                                           SQRT( 1.0_wp - RL**2 ) * sigma * rg3
+                      particles(n)%rvar1 = rl * particles(n)%rvar1 +                               &
+                                           SQRT( 1.0_wp - rl**2 ) * sigma * rg1
+                      particles(n)%rvar2 = rl * particles(n)%rvar2 +                               &
+                                           SQRT( 1.0_wp - rl**2 ) * sigma * rg2
+                      particles(n)%rvar3 = rl * particles(n)%rvar3 +                               &
+                                           SQRT( 1.0_wp - rl**2 ) * sigma * rg3
 
                       particles(n)%speed_x = u_int(n) + particles(n)%rvar1
@@ -4570 +4437 @@
                       exp_term = particle_groups(particles(n)%group)%exp_term
                    ENDIF
-                   particles(n)%speed_x = particles(n)%speed_x * exp_term +         &
+                   particles(n)%speed_x = particles(n)%speed_x * exp_term +                        &
                                           u_int(n) * ( 1.0_wp - exp_term )
-                   particles(n)%speed_y = particles(n)%speed_y * exp_term +         &
+                   particles(n)%speed_y = particles(n)%speed_y * exp_term +                        &
                                           v_int(n) * ( 1.0_wp - exp_term )
-                   particles(n)%speed_z = particles(n)%speed_z * exp_term +         &
-                                          ( w_int(n) - ( 1.0_wp - dens_ratio(n) ) * &
+                   particles(n)%speed_z = particles(n)%speed_z * exp_term +                        &
+                                          ( w_int(n) - ( 1.0_wp - dens_ratio(n) ) *                &
                                           g / exp_arg ) * ( 1.0_wp - exp_term )
                 ENDIF
@@ -4585 +4452 @@
     ELSE
 !
-!--    Decide whether the particle loop runs over the subboxes or only over 1,
-!--    number_of_particles. This depends on the selected interpolation method.
+!--    Decide whether the particle loop runs over the subboxes or only over 1, number_of_particles.
+!--    This depends on the selected interpolation method.
        IF ( interpolation_trilinear )  THEN
           subbox_start = 0
@@ -4594 +4461 @@
           subbox_end   = 1
        ENDIF
-!--    loop over subboxes. In case of simple interpolation scheme no subboxes
-!--    are introduced, as they are not required. Accordingly, this loops goes
-!--    from 1 to 1.
+!--    loop over subboxes. In case of simple interpolation scheme no subboxes are introduced, as
+!--    they are not required. Accordingly, this loop goes from 1 to 1.
        DO  nb = subbox_start, subbox_end
           IF ( interpolation_trilinear )  THEN
@@ -4618 +4484 @@
              IF ( cloud_droplets )  THEN
 !
-!--             Terminal velocity is computed for vertical direction (Rogers et al.,
-!--             1993, J. Appl. Meteorol.)
+!--             Terminal velocity is computed for vertical direction (Rogers et al., 1993,
+!--             J. Appl. Meteorol.)
                 diameter = particles(n)%radius * 2000.0_wp !diameter in mm
                 IF ( diameter <= d0_rog )  THEN
@@ -4632 +4498 @@
                 IF ( use_sgs_for_particles )  THEN
                     lagr_timescale(n) = km(kp,jp,ip) / MAX( e(kp,jp,ip), 1.0E-20_wp )
-                     RL             = EXP( -1.0_wp * dt_3d / MAX( lagr_timescale(n), &
-                                             1.0E-20_wp ) )
-                    sigma          = SQRT( e(kp,jp,ip) )
-
-!
-!--                 Calculate random component of particle sgs velocity using parallel
-!--                 random generator
+                    rl    = EXP( -1.0_wp * dt_3d / MAX( lagr_timescale(n), 1.0E-20_wp ) )
+                    sigma = SQRT( e(kp,jp,ip) )
+
+!
+!--                 Calculate random component of particle sgs velocity using parallel random
+!--                 generator
                     CALL random_number_parallel_gauss( random_dummy )
                     rg1 = random_dummy
@@ -4646 +4511 @@
                     rg3 = random_dummy
 
-                    particles(n)%rvar1 = RL * particles(n)%rvar1 +                &
-                                         SQRT( 1.0_wp - RL**2 ) * sigma * rg1
-                    particles(n)%rvar2 = RL * particles(n)%rvar2 +                &
-                                         SQRT( 1.0_wp - RL**2 ) * sigma * rg2
-                    particles(n)%rvar3 = RL * particles(n)%rvar3 +                &
-                                         SQRT( 1.0_wp - RL**2 ) * sigma * rg3
+                    particles(n)%rvar1 = rl * particles(n)%rvar1 +                                 &
+                                         SQRT( 1.0_wp - rl**2 ) * sigma * rg1
+                    particles(n)%rvar2 = rl * particles(n)%rvar2 +                                 &
+                                         SQRT( 1.0_wp - rl**2 ) * sigma * rg2
+                    particles(n)%rvar3 = rl * particles(n)%rvar3 +                                 &
+                                         SQRT( 1.0_wp - rl**2 ) * sigma * rg3
 
                     particles(n)%speed_x = u_int(n) + particles(n)%rvar1
@@ -4671 +4536 @@
                    exp_term = particle_groups(particles(n)%group)%exp_term
                 ENDIF
-                particles(n)%speed_x = particles(n)%speed_x * exp_term +             &
+                particles(n)%speed_x = particles(n)%speed_x * exp_term +                           &
                                        u_int(n) * ( 1.0_wp - exp_term )
-                particles(n)%speed_y = particles(n)%speed_y * exp_term +             &
+                particles(n)%speed_y = particles(n)%speed_y * exp_term +                           &
                                        v_int(n) * ( 1.0_wp - exp_term )
-                particles(n)%speed_z = particles(n)%speed_z * exp_term +             &
-                                       ( w_int(n) - ( 1.0_wp - dens_ratio(n) ) * g / &
+                particles(n)%speed_z = particles(n)%speed_z * exp_term +                           &
+                                       ( w_int(n) - ( 1.0_wp - dens_ratio(n) ) * g /               &
                                        exp_arg ) * ( 1.0_wp - exp_term )
              ENDIF
@@ -4685 +4550 @@
 
 !
-!-- Store the old age of the particle ( needed to prevent that a
-!-- particle crosses several PEs during one timestep, and for the
-!-- evaluation of the subgrid particle velocity fluctuations )
+!-- Store the old age of the particle ( needed to prevent that a particle crosses several PEs during
+!-- one timestep, and for the evaluation of the subgrid particle velocity fluctuations )
     particles(1:number_of_particles)%age_m = particles(1:number_of_particles)%age
 
 !
-!--    loop over subboxes. In case of simple interpolation scheme no subboxes
-!--    are introduced, as they are not required. Accordingly, this loops goes
-!--    from 1 to 1.
-!
-!-- Decide whether the particle loop runs over the subboxes or only over 1,
-!-- number_of_particles. This depends on the selected interpolation method.
+!--    loop over subboxes. In case of simple interpolation scheme no subboxes are introduced, as
+!--    they are not required. Accordingly, this loop goes from 1 to 1.
+!
+!-- Decide whether the particle loop runs over the subboxes or only over 1, number_of_particles.
+!-- This depends on the selected interpolation method.
     IF ( interpolation_trilinear )  THEN
        subbox_start = 0
@@ -4713 +4576 @@
        ENDIF
 !
-!--    Loop from particle start to particle end and increment the particle 
-!--    age and the total time that the particle has advanced within the 
-!--    particle timestep procedure.
+!--    Loop from particle start to particle end and increment the particle age and the total time
+!--    that the particle has advanced within the particle timestep procedure.
        DO  n = particle_start, particle_end
           particles(n)%age    = particles(n)%age    + dt_particle(n)
@@ -4722 +4584 @@
 !
 !--    Particles that leave the child domain during the SGS-timestep loop
-!--    must not continue timestepping until they are transferred to the 
+!--    must not continue timestepping until they are transferred to the
 !--    parent. Hence, set their dt_sum to dt.
        IF ( child_domain  .AND.  use_sgs_for_particles )  THEN
           DO  n = particle_start, particle_end
-             IF ( particles(n)%x < 0.0_wp         .OR.                         &
-                  particles(n)%y < 0.0_wp         .OR.                         &
-                  particles(n)%x > ( nx+1 ) * dx  .OR.                         &
+             IF ( particles(n)%x < 0.0_wp         .OR.                                             &
+                  particles(n)%y < 0.0_wp         .OR.                                             &
+                  particles(n)%x > ( nx+1 ) * dx  .OR.                                             &
                   particles(n)%y < ( ny+1 ) * dy )  THEN
                 particles(n)%dt_sum = dt_3d
@@ -4735 +4597 @@
        ENDIF
 !
-!--    Check whether there is still a particle that has not yet completed
-!--    the total LES timestep
+!--    Check whether there is still a particle that has not yet completed the total LES timestep
        DO  n = particle_start, particle_end
-          IF ( ( dt_3d - particles(n)%dt_sum ) > 1E-8_wp )                     &
-             dt_3d_reached_l = .FALSE.
+          IF ( ( dt_3d - particles(n)%dt_sum ) > 1E-8_wp )  dt_3d_reached_l = .FALSE.
        ENDDO
     ENDDO
@@ -4748 +4608 @@
  END SUBROUTINE lpm_advec
 
- 
-!------------------------------------------------------------------------------!  
+
+!--------------------------------------------------------------------------------------------------!
 ! Description:
 ! ------------
-!> Calculation of subgrid-scale particle speed using the stochastic model 
+!> Calculation of subgrid-scale particle speed using the stochastic model
 !> of Weil et al. (2004, JAS, 61, 2877-2887).
-!------------------------------------------------------------------------------! 
- SUBROUTINE weil_stochastic_eq( v_sgs, fs_n, e_n, dedxi_n, dedt_n, diss_n,     &
-                                dt_n, rg_n, fac )
+!--------------------------------------------------------------------------------------------------!
+ SUBROUTINE weil_stochastic_eq( v_sgs, fs_n, e_n, dedxi_n, dedt_n, diss_n, dt_n, rg_n, fac )
 
     REAL(wp) ::  a1      !< dummy argument
-    REAL(wp) ::  dedt_n  !< time derivative of TKE at particle position 
+    REAL(wp) ::  dedt_n  !< time derivative of TKE at particle position
     REAL(wp) ::  dedxi_n !< horizontal derivative of TKE at particle position
-    REAL(wp) ::  diss_n  !< dissipation at particle position 
+    REAL(wp) ::  diss_n  !< dissipation at particle position
     REAL(wp) ::  dt_n    !< particle timestep
     REAL(wp) ::  e_n     !< TKE at particle position
@@ -4770 +4629 @@
     REAL(wp) ::  term2   !< drift correction term
     REAL(wp) ::  term3   !< random term
-    REAL(wp) ::  v_sgs   !< subgrid-scale velocity component 
-
-!-- At first, limit TKE to a small non-zero number, in order to prevent 
-!-- the occurrence of extremely large SGS-velocities in case TKE is zero, 
-!-- (could occur at the simulation begin).
+    REAL(wp) ::  v_sgs   !< subgrid-scale velocity component
+
+!-- At first, limit TKE to a small non-zero number, in order to prevent the occurrence of extremely
+!-- large SGS-velocities in case TKE is zero, (could occur at the simulation begin).
     e_n = MAX( e_n, 1E-20_wp )
 !
-!-- Please note, terms 1 and 2 (drift and memory term, respectively) are 
-!-- multiplied by a flag to switch of both terms near topography. 
-!-- This is necessary, as both terms may cause a subgrid-scale velocity build up 
-!-- if particles are trapped in regions with very small TKE, e.g. in narrow street 
-!-- canyons resolved by only a few grid points. Hence, term 1 and term 2 are 
-!-- disabled if one of the adjacent grid points belongs to topography. 
-!-- Moreover, in this case, the  previous subgrid-scale component is also set
-!-- to zero.
+!-- Please note, terms 1 and 2 (drift and memory term, respectively) are multiplied by a flag to
+!-- switch of both terms near topography.
+!-- This is necessary, as both terms may cause a subgrid-scale velocity build up if particles are
+!-- trapped in regions with very small TKE, e.g. in narrow street canyons resolved by only a few
+!-- grid points. Hence, term 1 and term 2 are disabled if one of the adjacent grid points belongs to
+!-- topography.
+!-- Moreover, in this case, the  previous subgrid-scale component is also set to zero.
 
     a1 = fs_n * c_0 * diss_n
 !
 !-- Memory term
-    term1 = - a1 * v_sgs * dt_n / ( 4.0_wp * sgs_wf_part * e_n + 1E-20_wp )    &
-                 * fac
+    term1 = - a1 * v_sgs * dt_n / ( 4.0_wp * sgs_wf_part * e_n + 1E-20_wp ) * fac
 !
 !-- Drift correction term
-    term2 = ( ( dedt_n * v_sgs / e_n ) + dedxi_n ) * 0.5_wp * dt_n              &
-                 * fac
+    term2 = ( ( dedt_n * v_sgs / e_n ) + dedxi_n ) * 0.5_wp * dt_n * fac
 !
 !-- Random term
     term3 = SQRT( MAX( a1, 1E-20_wp ) ) * ( rg_n - 1.0_wp ) * SQRT( dt_n )
 !
-!-- In cese one of the adjacent grid-boxes belongs to topograhy, the previous
-!-- subgrid-scale velocity component is set to zero, in order to prevent a 
-!-- velocity build-up. 
-!-- This case, set also previous subgrid-scale component to zero. 
+!-- In case one of the adjacent grid-boxes belongs to topograhy, the previous subgrid-scale velocity
+!-- component is set to zero, in order to prevent a velocity build-up.
+!-- This case, set also previous subgrid-scale component to zero.
     v_sgs = v_sgs * fac + term1 + term2 + term3
 
@@ -4808 +4662 @@
 
 
-!------------------------------------------------------------------------------!
+!--------------------------------------------------------------------------------------------------!
 ! Description:
 ! ------------
 !> swap timelevel in case of particle advection interpolation 'simple-corrector'
-!> This routine is called at the end of one timestep, the velocities are then
-!> used for the next timestep
-!------------------------------------------------------------------------------!
+!> This routine is called at the end of one timestep, the velocities are then used for the next
+!> timestep
+!--------------------------------------------------------------------------------------------------!
  SUBROUTINE lpm_swap_timelevel_for_particle_advection
 
 !
-!-- save the divergence free velocites of t+1 to use them at the end of the
-!-- next time step
+!-- Save the divergence free velocites of t+1 to use them at the end of the next time step
     u_t = u
     v_t = v
@@ -4827 +4680 @@
 
 
-!------------------------------------------------------------------------------!  
+!--------------------------------------------------------------------------------------------------!
 ! Description:
 ! ------------
 !> Boundary conditions for the Lagrangian particles.
-!> The routine consists of two different parts. One handles the bottom (flat)
-!> and top boundary. In this part, also particles which exceeded their lifetime
-!> are deleted.
+!> The routine consists of two different parts. One handles the bottom (flat) and top boundary. In
+!> this part, also particles which exceeded their lifetime are deleted.
 !> The other part handles the reflection of particles from vertical walls.
 !> This part was developed by Jin Zhang during 2006-2007.
 !>
-!> To do: Code structure for finding the t_index values and for checking the
-!> -----  reflection conditions is basically the same for all four cases, so it
-!>        should be possible to further simplify/shorten it.
+!> To do: Code structure for finding the t_index values and for checking the reflection conditions
+!> ------ is basically the same for all four cases, so it should be possible to further
+!>        simplify/shorten it.
 !>
 !> THE WALLS PART OF THIS ROUTINE HAS NOT BEEN TESTED FOR OCEAN RUNS SO FAR!!!!
 !> (see offset_ocean_*)
-!------------------------------------------------------------------------------! 
+!--------------------------------------------------------------------------------------------------!
  SUBROUTINE lpm_boundary_conds( location_bc , i, j, k )
 
     CHARACTER (LEN=*), INTENT(IN) ::  location_bc !< general mode: boundary conditions at bottom/top of the model domain
-                                   !< or at vertical surfaces (buildings, terrain steps)    
+                                   !< or at vertical surfaces (buildings, terrain steps)
     INTEGER(iwp), INTENT(IN) ::  i !< grid index of particle box along x
     INTEGER(iwp), INTENT(IN) ::  j !< grid index of particle box along y
@@ -4919 +4771 @@
 
 !
-!--    Apply boundary conditions to those particles that have crossed the top or
-!--    bottom boundary and delete those particles, which are older than allowed
+!--    Apply boundary conditions to those particles that have crossed the top or bottom boundary and
+!--    delete those particles, which are older than allowed
        DO  n = 1, number_of_particles
 
 !
-!--       Stop if particles have moved further than the length of one 
-!--       PE subdomain (newly released particles have age = age_m!)
+!--       Stop if particles have moved further than the length of one PE subdomain (newly released
+!--       particles have age = age_m!)
           IF ( particles(n)%age /= particles(n)%age_m )  THEN
-             IF ( ABS(particles(n)%speed_x) >                                  &
-                  ((nxr-nxl+2)*dx)/(particles(n)%age-particles(n)%age_m)  .OR. &
-                  ABS(particles(n)%speed_y) >                                  &
+             IF ( ABS(particles(n)%speed_x) >                                                      &
+                  ((nxr-nxl+2)*dx)/(particles(n)%age-particles(n)%age_m)  .OR.                     &
+                  ABS(particles(n)%speed_y) >                                                      &
                   ((nyn-nys+2)*dy)/(particles(n)%age-particles(n)%age_m) )  THEN
 
-                  WRITE( message_string, * )  'particle too fast.  n = ',  n 
+                  WRITE( message_string, * )  'particle too fast.  n = ',  n
                   CALL message( 'lpm_boundary_conds', 'PA0148', 2, 2, -1, 6, 1 )
              ENDIF
           ENDIF
 
-          IF ( particles(n)%age > particle_maximum_age  .AND.  &
-               particles(n)%particle_mask )                              &
-          THEN
+          IF ( particles(n)%age > particle_maximum_age  .AND.  particles(n)%particle_mask )  THEN
              particles(n)%particle_mask  = .FALSE.
              deleted_particles = deleted_particles + 1
@@ -5026 +4876 @@
           k1 = k
 !
-!--       Determine horizontal as well as vertical walls at which particle can 
-!--       be potentially reflected. 
+!--       Determine horizontal as well as vertical walls at which particle can be potentially
+!--       reflected.
 !--       Start with walls aligned in yz layer.
-!--       Wall to the right 
+!--       Wall to the right
           IF ( prt_x > pos_x_old )  THEN
              xwall = ( i1 + 1 ) * dx
@@ -5074 +4924 @@
           z_wall_reached = .FALSE.
 !
-!--       Initialize time array 
+!--       Initialize time array
           t     = 0.0_wp
 !
-!--       Check if particle can reach any wall. This case, calculate the 
-!--       fractional time needed to reach this wall. Store this fractional
-!--       timestep in array t. Moreover, store indices for these grid
-!--       boxes where the respective wall belongs to.  
+!--       Check if particle can reach any wall. This case, calculate the fractional time needed to
+!--       reach this wall. Store this fractional timestep in array t. Moreover, store indices for
+!--       these grid boxes where the respective wall belongs to.
 !--       Start with x-direction.
           t_index    = 1
-          t(t_index) = ( xwall - pos_x_old )                                   &
-                     / MERGE( MAX( prt_x - pos_x_old,  1E-30_wp ),             &
-                              MIN( prt_x - pos_x_old, -1E-30_wp ),             &
-                              prt_x > pos_x_old )
+          t(t_index) = ( xwall - pos_x_old )                                                       &
+                       / MERGE( MAX( prt_x - pos_x_old,  1E-30_wp ),                               &
+                                MIN( prt_x - pos_x_old, -1E-30_wp ),                               &
+                                prt_x > pos_x_old )
           x_ind(t_index)   = i2
           y_ind(t_index)   = j1
@@ -5094 +4943 @@
           reach_z(t_index) = .FALSE.
 !
-!--       Store these values only if particle really reaches any wall. t must 
-!--       be in a interval between [0:1].
+!--       Store these values only if particle really reaches any wall. t must be in an interval
+!--       between [0:1].
           IF ( t(t_index) <= 1.0_wp  .AND.  t(t_index) >= 0.0_wp )  THEN
              t_index      = t_index + 1
@@ -5102 +4951 @@
 !
 !--       y-direction
-          t(t_index) = ( ywall - pos_y_old )                                   &
-                     / MERGE( MAX( prt_y - pos_y_old,  1E-30_wp ),             &
-                              MIN( prt_y - pos_y_old, -1E-30_wp ),             &
-                              prt_y > pos_y_old )
+          t(t_index) = ( ywall - pos_y_old )                                                       &
+                       / MERGE( MAX( prt_y - pos_y_old,  1E-30_wp ),                               &
+                                MIN( prt_y - pos_y_old, -1E-30_wp ),                               &
+                                prt_y > pos_y_old )
           x_ind(t_index)   = i1
           y_ind(t_index)   = j2
@@ -5118 +4967 @@
 !
 !--       z-direction
-          t(t_index) = (zwall - pos_z_old )                                    &
-                     / MERGE( MAX( prt_z - pos_z_old,  1E-30_wp ),             &
-                              MIN( prt_z - pos_z_old, -1E-30_wp ),             &
-                              prt_z > pos_z_old )
+          t(t_index) = (zwall - pos_z_old )                                                        &
+                       / MERGE( MAX( prt_z - pos_z_old,  1E-30_wp ),                               &
+                                MIN( prt_z - pos_z_old, -1E-30_wp ),                               &
+                                prt_z > pos_z_old )
 
           x_ind(t_index)   = i1
@@ -5139 +4988 @@
           IF ( cross_wall_x  .OR.  cross_wall_y  .OR.  cross_wall_z )  THEN
 !
-!--          Sort fractional timesteps in ascending order. Also sort the 
-!--          corresponding indices and flag according to the time interval a  
-!--          particle reaches the respective wall.
+!--          Sort fractional timesteps in ascending order. Also sort the corresponding indices and
+!--          flag according to the time interval a particle reaches the respective wall.
              inc = 1
              jr  = 1
@@ -5187 +5035 @@
 !--          Loop over all times a particle possibly moves into a new grid box
              t_old = 0.0_wp
-             DO t_index = 1, t_index_number 
-!
-!--             Calculate intermediate particle position according to the 
-!--             timesteps a particle reaches any wall.
-                pos_x = pos_x + ( t(t_index) - t_old ) * dt_particle           &
-                                                       * particles(n)%speed_x
-                pos_y = pos_y + ( t(t_index) - t_old ) * dt_particle           &
-                                                       * particles(n)%speed_y
-                pos_z = pos_z + ( t(t_index) - t_old ) * dt_particle           &
-                                                       * particles(n)%speed_z
-!
-!--             Obtain x/y grid indices for intermediate particle position from
-!--             sorted index array
+             DO t_index = 1, t_index_number
+!
+!--             Calculate intermediate particle position according to the timesteps a particle
+!--             reaches any wall.
+                pos_x = pos_x + ( t(t_index) - t_old ) * dt_particle * particles(n)%speed_x
+                pos_y = pos_y + ( t(t_index) - t_old ) * dt_particle * particles(n)%speed_y
+                pos_z = pos_z + ( t(t_index) - t_old ) * dt_particle * particles(n)%speed_z
+!
+!--             Obtain x/y grid indices for intermediate particle position from sorted index array
                 i3 = x_ind(t_index)
                 j3 = y_ind(t_index)
@@ -5205 +5049 @@
 !
 !--             Check which wall is already reached
-                IF ( .NOT. x_wall_reached )  x_wall_reached = reach_x(t_index) 
+                IF ( .NOT. x_wall_reached )  x_wall_reached = reach_x(t_index)
                 IF ( .NOT. y_wall_reached )  y_wall_reached = reach_y(t_index)
                 IF ( .NOT. z_wall_reached )  z_wall_reached = reach_z(t_index)
 !
-!--             Check if a particle needs to be reflected at any yz-wall. If 
-!--             necessary, carry out reflection. Please note, a security 
-!--             constant is required, as the particle position does not 
-!--             necessarily exactly match the wall location due to rounding 
-!--             errors.
-                IF ( reach_x(t_index)                      .AND.               & 
-                     ABS( pos_x - xwall ) < eps            .AND.               &
-                     .NOT. BTEST(wall_flags_total_0(k3,j3,i3),0) .AND.         &
+!--             Check if a particle needs to be reflected at any yz-wall. If necessary, carry out
+!--             reflection. Please note, a security constant is required, as the particle position
+!--             does not necessarily exactly match the wall location due to rounding  errors.
+                IF ( reach_x(t_index)                            .AND.                             &
+                     ABS( pos_x - xwall ) < eps                  .AND.                             &
+                     .NOT. BTEST(wall_flags_total_0(k3,j3,i3),0) .AND.                             &
                      .NOT. reflect_x )  THEN
-! 
-! 
-!--                Reflection in x-direction. 
-!--                Ensure correct reflection by MIN/MAX functions, depending on
-!--                direction of particle transport. 
-!--                Due to rounding errors pos_x does not exactly match the wall
-!--                location, leading to erroneous reflection.             
-                   pos_x = MERGE( MIN( 2.0_wp * xwall - pos_x, xwall ),        &
-                                  MAX( 2.0_wp * xwall - pos_x, xwall ),        &
+!
+!
+!--                Reflection in x-direction.
+!--                Ensure correct reflection by MIN/MAX functions, depending on direction of
+!--                particle transport.
+!--                Due to rounding errors pos_x does not exactly match the wall location, leading to
+!--                erroneous reflection.
+                   pos_x = MERGE( MIN( 2.0_wp * xwall - pos_x, xwall ),                            &
+                                  MAX( 2.0_wp * xwall - pos_x, xwall ),                            &
                                   particles(n)%x > xwall )
 !
-!--                Change sign of particle speed                     
+!--                Change sign of particle speed
                    particles(n)%speed_x = - particles(n)%speed_x
 !
@@ -5238 +5080 @@
                    reflect_x          = .TRUE.
 !
-!--                As the particle does not cross any further yz-wall during 
-!--                this timestep, set further x-indices to the current one.
+!--                As the particle does not cross any further yz-wall during this timestep, set
+!--                further x-indices to the current one.
                    x_ind(t_index:t_index_number) = i1
 !
-!--             If particle already reached the wall but was not reflected, 
-!--             set further x-indices to the new one.
-                ELSEIF ( x_wall_reached .AND. .NOT. reflect_x )  THEN
+!--             If particle already reached the wall but was not reflected, set further x-indices to
+!--             the new one.
+                ELSEIF ( x_wall_reached  .AND.  .NOT. reflect_x )  THEN
                     x_ind(t_index:t_index_number) = i2
-                ENDIF !particle reflection in x direction done
-
-!
-!--             Check if a particle needs to be reflected at any xz-wall. If 
-!--             necessary, carry out reflection. Please note, a security 
-!--             constant is required, as the particle position does not 
-!--             necessarily exactly match the wall location due to rounding 
-!--             errors. 
-                IF ( reach_y(t_index)                      .AND.               & 
-                     ABS( pos_y - ywall ) < eps            .AND.               &
-                     .NOT. BTEST(wall_flags_total_0(k3,j3,i3),0) .AND.         &
+                ENDIF  !particle reflection in x direction done
+
+!
+!--             Check if a particle needs to be reflected at any xz-wall. If necessary, carry out
+!--             reflection. Please note, a security constant is required, as the particle position
+!--             does not necessarily exactly match the wall location due to rounding errors.
+                IF ( reach_y(t_index)                            .AND.                             &
+                     ABS( pos_y - ywall ) < eps                  .AND.                             &
+                     .NOT. BTEST(wall_flags_total_0(k3,j3,i3),0) .AND.                             &
                      .NOT. reflect_y )  THEN
-! 
-! 
-!--                Reflection in y-direction. 
-!--                Ensure correct reflection by MIN/MAX functions, depending on
-!--                direction of particle transport. 
-!--                Due to rounding errors pos_y does not exactly match the wall
-!--                location, leading to erroneous reflection.             
-                   pos_y = MERGE( MIN( 2.0_wp * ywall - pos_y, ywall ),        &
-                                  MAX( 2.0_wp * ywall - pos_y, ywall ),        &
+!
+!
+!--                Reflection in y-direction.
+!--                Ensure correct reflection by MIN/MAX functions, depending on direction of
+!--                particle transport.
+!--                Due to rounding errors pos_y does not exactly match the wall location, leading to
+!--                erroneous reflection.
+                   pos_y = MERGE( MIN( 2.0_wp * ywall - pos_y, ywall ),                            &
+                                  MAX( 2.0_wp * ywall - pos_y, ywall ),                            &
                                   particles(n)%y > ywall )
 !
-!--                Change sign of particle speed                     
+!--                Change sign of particle speed
                    particles(n)%speed_y = - particles(n)%speed_y
 !
@@ -5278 +5118 @@
                    reflect_y          = .TRUE.
 !
-!--                As the particle does not cross any further xz-wall during 
-!--                this timestep, set further y-indices to the current one.
+!--                As the particle does not cross any further xz-wall during this timestep, set
+!--                further y-indices to the current one.
                    y_ind(t_index:t_index_number) = j1
 !
-!--             If particle already reached the wall but was not reflected, 
-!--             set further y-indices to the new one.
-                ELSEIF ( y_wall_reached .AND. .NOT. reflect_y )  THEN
+!--             If particle already reached the wall but was not reflected, set further y-indices to
+!--             the new one.
+                ELSEIF ( y_wall_reached  .AND.  .NOT. reflect_y )  THEN
                     y_ind(t_index:t_index_number) = j2
-                ENDIF !particle reflection in y direction done
-
-!
-!--             Check if a particle needs to be reflected at any xy-wall. If 
-!--             necessary, carry out reflection. Please note, a security 
-!--             constant is required, as the particle position does not 
-!--             necessarily exactly match the wall location due to rounding 
-!--             errors. 
-                IF ( reach_z(t_index)                      .AND.               & 
-                     ABS( pos_z - zwall ) < eps            .AND.               &
-                     .NOT. BTEST(wall_flags_total_0(k3,j3,i3),0) .AND.         &
+                ENDIF  !particle reflection in y direction done
+
+!
+!--             Check if a particle needs to be reflected at any xy-wall. If necessary, carry out
+!--             reflection. Please note, a security constant is required, as the particle position
+!--             does not necessarily exactly match the wall location due to rounding errors.
+                IF ( reach_z(t_index)                            .AND.                             &
+                     ABS( pos_z - zwall ) < eps                  .AND.                             &
+                     .NOT. BTEST(wall_flags_total_0(k3,j3,i3),0) .AND.                             &
                      .NOT. reflect_z )  THEN
-! 
-! 
-!--                Reflection in z-direction. 
-!--                Ensure correct reflection by MIN/MAX functions, depending on
-!--                direction of particle transport. 
-!--                Due to rounding errors pos_z does not exactly match the wall
-!--                location, leading to erroneous reflection.             
-                   pos_z = MERGE( MIN( 2.0_wp * zwall - pos_z, zwall ),        &
-                                  MAX( 2.0_wp * zwall - pos_z, zwall ),        &
+!
+!
+!--                Reflection in z-direction.
+!--                Ensure correct reflection by MIN/MAX functions, depending on direction of
+!--                particle transport.
+!--                Due to rounding errors pos_z does not exactly match the wall location, leading to
+!--                erroneous reflection.
+                   pos_z = MERGE( MIN( 2.0_wp * zwall - pos_z, zwall ),                            &
+                                  MAX( 2.0_wp * zwall - pos_z, zwall ),                            &
                                   particles(n)%z > zwall )
 !
-!--                Change sign of particle speed                     
+!--                Change sign of particle speed
                    particles(n)%speed_z = - particles(n)%speed_z
 !
@@ -5318 +5156 @@
                    reflect_z          = .TRUE.
 !
-!--                As the particle does not cross any further xy-wall during 
-!--                this timestep, set further z-indices to the current one.
+!--                As the particle does not cross any further xy-wall during this timestep, set
+!--                further z-indices to the current one.
                    z_ind(t_index:t_index_number) = k1
 !
-!--             If particle already reached the wall but was not reflected, 
-!--             set further z-indices to the new one.
-                ELSEIF ( z_wall_reached .AND. .NOT. reflect_z )  THEN
+!--             If particle already reached the wall but was not reflected, set further z-indices to
+!--             the new one.
+                ELSEIF ( z_wall_reached  .AND.  .NOT. reflect_z )  THEN
                     z_ind(t_index:t_index_number) = k2
-                ENDIF !particle reflection in z direction done                
+                ENDIF  !particle reflection in z direction done
 
 !
@@ -5334 +5172 @@
              ENDDO
 !
-!--          If a particle was reflected, calculate final position from last
-!--          intermediate position.
+!--          If a particle was reflected, calculate final position from last intermediate position.
              IF ( reflect_x  .OR.  reflect_y  .OR.  reflect_z )  THEN
 
-                particles(n)%x = pos_x + ( 1.0_wp - t_old ) * dt_particle      &
-                                                         * particles(n)%speed_x
-                particles(n)%y = pos_y + ( 1.0_wp - t_old ) * dt_particle      &
-                                                         * particles(n)%speed_y
-                particles(n)%z = pos_z + ( 1.0_wp - t_old ) * dt_particle      &
-                                                         * particles(n)%speed_z
+                particles(n)%x = pos_x + ( 1.0_wp - t_old ) * dt_particle * particles(n)%speed_x
+                particles(n)%y = pos_y + ( 1.0_wp - t_old ) * dt_particle * particles(n)%speed_y
+                particles(n)%z = pos_z + ( 1.0_wp - t_old ) * dt_particle * particles(n)%speed_z
 
              ENDIF
@@ -5358 +5192 @@
     END SELECT
 
- END SUBROUTINE lpm_boundary_conds 
-
-
-!------------------------------------------------------------------------------!
+ END SUBROUTINE lpm_boundary_conds
+
+
+!--------------------------------------------------------------------------------------------------!
 ! Description:
 ! ------------
-!> Calculates change in droplet radius by condensation/evaporation, using
-!> either an analytic formula or by numerically integrating the radius growth
-!> equation including curvature and solution effects using Rosenbrocks method
-!> (see Numerical recipes in FORTRAN, 2nd edition, p. 731).
+!> Calculates change in droplet radius by condensation/evaporation, using either an analytic formula
+!> or by numerically integrating the radius growth equation including curvature and solution effects
+!> using Rosenbrocks method (see Numerical recipes in FORTRAN, 2nd edition, p. 731).
 !> The analytical formula and growth equation follow those given in
 !> Rogers and Yau (A short course in cloud physics, 3rd edition, p. 102/103).
-!------------------------------------------------------------------------------!
+!--------------------------------------------------------------------------------------------------!
  SUBROUTINE lpm_droplet_condensation (i,j,k)
+
+!
+!-- Parameters for Rosenbrock method (see Verwer et al., 1999)
+    REAL(wp), PARAMETER ::  prec = 1.0E-3_wp     !< precision of Rosenbrock solution
+    REAL(wp), PARAMETER ::  q_increase = 1.5_wp  !< increase factor in timestep
+    REAL(wp), PARAMETER ::  q_decrease = 0.9_wp  !< decrease factor in timestep
+    REAL(wp), PARAMETER ::  gamma = 0.292893218814_wp !< = 1.0 - 1.0 / SQRT(2.0)
+!
+!-- Parameters for terminal velocity
+    REAL(wp), PARAMETER ::  a_rog = 9.65_wp      !< parameter for fall velocity
+    REAL(wp), PARAMETER ::  b_rog = 10.43_wp     !< parameter for fall velocity
+    REAL(wp), PARAMETER ::  c_rog = 0.6_wp       !< parameter for fall velocity
+    REAL(wp), PARAMETER ::  k_cap_rog = 4.0_wp   !< parameter for fall velocity
+    REAL(wp), PARAMETER ::  k_low_rog = 12.0_wp  !< parameter for fall velocity
+    REAL(wp), PARAMETER ::  d0_rog = 0.745_wp    !< separation diameter
 
     INTEGER(iwp), INTENT(IN) ::  i              !<
     INTEGER(iwp), INTENT(IN) ::  j              !<
     INTEGER(iwp), INTENT(IN) ::  k              !<
-    INTEGER(iwp) ::  n                          !<
+    INTEGER(iwp)             ::  n              !<
 
     REAL(wp) ::  afactor                       !< curvature effects
@@ -5398 +5246 @@
     REAL(wp) ::  r_ros_ini                     !< initial Rosenbrock radius
     REAL(wp) ::  r0                            !< gas-kinetic lengthscale
+    REAL(wp) ::  re_p                          !< particle Reynolds number
     REAL(wp) ::  sigma                         !< surface tension of water
     REAL(wp) ::  thermal_conductivity          !< thermal conductivity for water
     REAL(wp) ::  t_int                         !< temperature
     REAL(wp) ::  w_s                           !< terminal velocity of droplets
-    REAL(wp) ::  re_p                          !< particle Reynolds number
-!
-!-- Parameters for Rosenbrock method (see Verwer et al., 1999)
-    REAL(wp), PARAMETER ::  prec = 1.0E-3_wp     !< precision of Rosenbrock solution
-    REAL(wp), PARAMETER ::  q_increase = 1.5_wp  !< increase factor in timestep
-    REAL(wp), PARAMETER ::  q_decrease = 0.9_wp  !< decrease factor in timestep
-    REAL(wp), PARAMETER ::  gamma = 0.292893218814_wp !< = 1.0 - 1.0 / SQRT(2.0)
-!
-!-- Parameters for terminal velocity
-    REAL(wp), PARAMETER ::  a_rog = 9.65_wp      !< parameter for fall velocity
-    REAL(wp), PARAMETER ::  b_rog = 10.43_wp     !< parameter for fall velocity
-    REAL(wp), PARAMETER ::  c_rog = 0.6_wp       !< parameter for fall velocity
-    REAL(wp), PARAMETER ::  k_cap_rog = 4.0_wp   !< parameter for fall velocity
-    REAL(wp), PARAMETER ::  k_low_rog = 12.0_wp  !< parameter for fall velocity
-    REAL(wp), PARAMETER ::  d0_rog = 0.745_wp    !< separation diameter
-
+
+    REAL(wp), DIMENSION(number_of_particles) ::  new_r                  !<
     REAL(wp), DIMENSION(number_of_particles) ::  ventilation_effect     !<
-    REAL(wp), DIMENSION(number_of_particles) ::  new_r                  !<
 
     CALL cpu_log( log_point_s(42), 'lpm_droplet_condens', 'start' )
@@ -5437 +5271 @@
 !
 !-- Moldecular diffusivity of water vapor in air (Hall und Pruppacher, 1976)
-    diff_coeff           = 0.211E-4_wp * ( t_int / 273.15_wp )**1.94_wp * &
-                           ( 101325.0_wp / hyp(k) )
+    diff_coeff           = 0.211E-4_wp * ( t_int / 273.15_wp )**1.94_wp * ( 101325.0_wp / hyp(k) )
 !
 !-- Lengthscale for gas-kinetic effects (from Mordy, 1959, p. 23):
@@ -5445 +5278 @@
 !-- Calculate effects of heat conductivity and diffusion of water vapor on the
 !-- diffusional growth process (usually known as 1.0 / (F_k + F_d) )
-    ddenom  = 1.0_wp / ( rho_l * r_v * t_int / ( e_s * diff_coeff ) +          &
-                         ( l_v / ( r_v * t_int ) - 1.0_wp ) * rho_l *          &
-                         l_v / ( thermal_conductivity * t_int )                &
+    ddenom  = 1.0_wp / ( rho_l * r_v * t_int / ( e_s * diff_coeff ) +                              &
+                         ( l_v / ( r_v * t_int ) - 1.0_wp ) * rho_l *                              &
+                         l_v / ( thermal_conductivity * t_int )                                    &
                        )
     new_r = 0.0_wp
@@ -5458 +5291 @@
 !--       Terminal velocity is computed for vertical direction (Rogers et al.,
 !--       1993, J. Appl. Meteorol.)
-          diameter = particles(n)%radius * 2000.0_wp !diameter in mm
+          diameter = particles(n)%radius * 2000.0_wp  !diameter in mm
           IF ( diameter <= d0_rog )  THEN
              w_s = k_cap_rog * diameter * ( 1.0_wp - EXP( -k_low_rog * diameter ) )
@@ -5476 +5309 @@
        ELSE
 !
-!--       For small droplets or in supersaturated environments, the ventilation
-!--       effect does not play a role
+!--       For small droplets or in supersaturated environments, the ventilation effect does not play
+!--       a role.
           ventilation_effect(n) = 1.0_wp
        ENDIF
@@ -5484 +5317 @@
     IF( .NOT. curvature_solution_effects )  THEN
 !
-!--    Use analytic model for diffusional growth including gas-kinetic
-!--    effects (Mordy, 1959) but without the impact of aerosols.
+!--    Use analytic model for diffusional growth including gas-kinetic effects (Mordy, 1959) but
+!--    without the impact of aerosols.
        DO  n = 1, number_of_particles
-          arg      = ( particles(n)%radius + r0 )**2 + 2.0_wp * dt_3d * ddenom * &
-                                                       ventilation_effect(n) *   &
+          arg      = ( particles(n)%radius + r0 )**2 + 2.0_wp * dt_3d * ddenom *                   &
+                                                       ventilation_effect(n)   *                   &
                                                        ( e_a / e_s - 1.0_wp )
           arg      = MAX( arg, ( 0.01E-6 + r0 )**2 )
@@ -5508 +5341 @@
 !
 !--       Solute effect (bfactor)
-          bfactor = vanthoff * rho_s * particles(n)%aux1**3 *                    &
+          bfactor = vanthoff * rho_s * particles(n)%aux1**3 *                                      &
                     molecular_weight_of_water / ( rho_l * molecular_weight_of_solute )
 
@@ -5518 +5351 @@
 !
 !--       Integrate growth equation using a 2nd-order Rosenbrock method
-!--       (see Verwer et al., 1999, Eq. (3.2)). The Rosenbrock method adjusts
-!--       its with internal timestep to minimize the local truncation error.
+!--       (see Verwer et al., 1999, Eq. (3.2)). The Rosenbrock method adjusts its with internal
+!--       timestep to minimize the local truncation error.
           DO WHILE ( dt_ros_sum < dt_3d )
 
@@ -5526 +5359 @@
              DO
 
-                drdt = ddenom * ventilation_effect(n) * ( e_a / e_s - 1.0_wp - &
-                                                          afactor / r_ros +    &
-                                                          bfactor / r_ros**3   &
+                drdt = ddenom * ventilation_effect(n) * ( e_a / e_s - 1.0_wp -                     &
+                                                          afactor / r_ros +                        &
+                                                          bfactor / r_ros**3                       &
                                                         ) / ( r_ros + r0 )
 
-                d2rdtdr = -ddenom * ventilation_effect(n) * (                  &
-                                            (e_a / e_s - 1.0_wp ) * r_ros**4 - &
-                                            afactor * r0 * r_ros**2 -          &
-                                            2.0_wp * afactor * r_ros**3 +      &
-                                            3.0_wp * bfactor * r0 +            &
-                                            4.0_wp * bfactor * r_ros           &
-                                                            )                  &
+                d2rdtdr = -ddenom * ventilation_effect(n) *  (                                     &
+                                            ( e_a / e_s - 1.0_wp ) * r_ros**4 -                    &
+                                            afactor * r0 * r_ros**2 -                              &
+                                            2.0_wp * afactor * r_ros**3 +                          &
+                                            3.0_wp * bfactor * r0 +                                &
+                                            4.0_wp * bfactor * r_ros                               &
+                                                             )                                     &
                           / ( r_ros**4 * ( r_ros + r0 )**2 )
 
@@ -5545 +5378 @@
                 r_err = r_ros
 
-                drdt  = ddenom * ventilation_effect(n) * ( e_a / e_s - 1.0_wp - &
-                                                           afactor / r_ros +    &
-                                                           bfactor / r_ros**3   &
+                drdt  = ddenom * ventilation_effect(n) * ( e_a / e_s - 1.0_wp -                    &
+                                                           afactor / r_ros +                       &
+                                                           bfactor / r_ros**3                      &
                                                          ) / ( r_ros + r0 )
 
-                k2 = ( drdt - dt_ros * 2.0 * gamma * d2rdtdr * k1 ) / &
+                k2 = ( drdt - dt_ros * 2.0 * gamma * d2rdtdr * k1 ) /                              &
                      ( 1.0_wp - dt_ros * gamma * d2rdtdr )
 
                 r_ros = MAX(r_ros_ini + dt_ros * ( 1.5_wp * k1 + 0.5_wp * k2), particles(n)%aux1)
-   !
-   !--          Check error of the solution, and reduce dt_ros if necessary.
+!
+!--             Check error of the solution, and reduce dt_ros if necessary.
                 error = ABS(r_err - r_ros) / r_ros
                 IF ( error > prec )  THEN
@@ -5569 +5402 @@
              END DO
 
-          END DO !Rosenbrock loop
+          END DO  !Rosenbrock loop
 !
 !--       Store new particle radius
@@ -5583 +5416 @@
     DO  n = 1, number_of_particles
 !
-!--    Sum up the change in liquid water for the respective grid
-!--    box for the computation of the release/depletion of water vapor
-!--    and heat.
-       ql_c(k,j,i) = ql_c(k,j,i) + particles(n)%weight_factor *          &
-                                   rho_l * 1.33333333_wp * pi *                &
-                                   ( new_r(n)**3 - particles(n)%radius**3 ) /  &
+!--    Sum up the change in liquid water for the respective grid box for the computation of the
+!--    release/depletion of water vapor and heat.
+       ql_c(k,j,i) = ql_c(k,j,i) + particles(n)%weight_factor *                                    &
+                                   rho_l * 1.33333333_wp * pi *                                    &
+                                   ( new_r(n)**3 - particles(n)%radius**3 ) /                      &
                                    ( rho_surface * dx * dy * dzw(k) )
 !
-!--    Check if the increase in liqid water is not too big. If this is the case,
-!--    the model timestep might be too long.
+!--    Check if the increase in liqid water is not too big. If this is the case, the model timestep
+!--    might be too long.
        IF ( ql_c(k,j,i) > 100.0_wp )  THEN
-          WRITE( message_string, * ) 'k=',k,' j=',j,' i=',i,                &
-                       ' ql_c=',ql_c(k,j,i), '&part(',n,')%wf=',            &
-                       particles(n)%weight_factor,' delta_r=',delta_r
+          WRITE( message_string, * ) 'k=',k,' j=',j,' i=',i,                                       &
+                                     ' ql_c=',ql_c(k,j,i), '&part(',n,')%wf=',                     &
+                                     particles(n)%weight_factor,' delta_r=',delta_r
           CALL message( 'lpm_droplet_condensation', 'PA0143', 2, 2, -1, 6, 1 )
        ENDIF
 !
-!--    Check if the change in the droplet radius is not too big. If this is the
-!--    case, the model timestep might be too long.
+!--    Check if the change in the droplet radius is not too big. If this is the case, the model
+!--    timestep might be too long.
        delta_r = new_r(n) - particles(n)%radius
        IF ( delta_r < 0.0_wp  .AND.  new_r(n) < 0.0_wp )  THEN
-          WRITE( message_string, * ) '#1 k=',k,' j=',j,' i=',i,                &
-                       ' e_s=',e_s, ' e_a=',e_a,' t_int=',t_int,               &
-                       '&delta_r=',delta_r,                                    &
-                       ' particle_radius=',particles(n)%radius
+          WRITE( message_string, * ) '#1 k=',k,' j=',j,' i=',i,                                    &
+                                     ' e_s=',e_s, ' e_a=',e_a,' t_int=',t_int,                     &
+                                     '&delta_r=',delta_r,                                          &
+                                     ' particle_radius=',particles(n)%radius
           CALL message( 'lpm_droplet_condensation', 'PA0144', 2, 2, -1, 6, 1 )
        ENDIF
 !
-!--    Sum up the total volume of liquid water (needed below for
-!--    re-calculating the weighting factors)
+!--    Sum up the total volume of liquid water (needed below for re-calculating the weighting
+!--    factors)
        ql_v(k,j,i) = ql_v(k,j,i) + particles(n)%weight_factor * new_r(n)**3
 !
 !--    Determine radius class of the particle needed for collision
        IF ( use_kernel_tables )  THEN
-          particles(n)%class = ( LOG( new_r(n) ) - rclass_lbound ) /           &
-                               ( rclass_ubound - rclass_lbound ) *             &
-                               radius_classes
+          particles(n)%class = ( LOG( new_r(n) ) - rclass_lbound ) /                               &
+                               ( rclass_ubound - rclass_lbound ) * radius_classes
           particles(n)%class = MIN( particles(n)%class, radius_classes )
           particles(n)%class = MAX( particles(n)%class, 1 )
@@ -5635 +5466 @@
 
 
-!------------------------------------------------------------------------------!
+!--------------------------------------------------------------------------------------------------!
 ! Description:
 ! ------------
-!> Release of latent heat and change of mixing ratio due to condensation /
-!> evaporation of droplets.
-!------------------------------------------------------------------------------!
+!> Release of latent heat and change of mixing ratio due to condensation / evaporation of droplets.
+!--------------------------------------------------------------------------------------------------!
  SUBROUTINE lpm_interaction_droplets_ptq
 
@@ -5657 +5487 @@
 
              q(k,j,i)  = q(k,j,i)  - ql_c(k,j,i) * flag
-             pt(k,j,i) = pt(k,j,i) + lv_d_cp * ql_c(k,j,i) * d_exner(k) &
-                                                           * flag
+             pt(k,j,i) = pt(k,j,i) + lv_d_cp * ql_c(k,j,i) * d_exner(k) * flag
           ENDDO
        ENDDO
@@ -5666 +5495 @@
 
 
-!------------------------------------------------------------------------------!
+!--------------------------------------------------------------------------------------------------!
 ! Description:
 ! ------------
-!> Release of latent heat and change of mixing ratio due to condensation /
-!> evaporation of droplets. Call for grid point i,j
-!------------------------------------------------------------------------------!
+!> Release of latent heat and change of mixing ratio due to condensation / evaporation of droplets.
+!> Call for grid point i,j
+!--------------------------------------------------------------------------------------------------!
  SUBROUTINE lpm_interaction_droplets_ptq_ij( i, j )
 
@@ -5693 +5522 @@
 
 
-!------------------------------------------------------------------------------! 
+!--------------------------------------------------------------------------------------------------!
 ! Description:
 ! ------------
 !> Calculate the liquid water content for each grid box.
-!------------------------------------------------------------------------------!
+!--------------------------------------------------------------------------------------------------!
  SUBROUTINE lpm_calc_liquid_water_content
 
@@ -5721 +5550 @@
              particles => grid_particles(k,j,i)%particles(1:number_of_particles)
 !
-!--          Calculate the total volume in the boxes (ql_v, weighting factor
-!--          has to beincluded)
+!--          Calculate the total volume in the boxes (ql_v, weighting factor has to beincluded)
              DO  n = 1, prt_count(k,j,i)
-                ql_v(k,j,i)  = ql_v(k,j,i)  + particles(n)%weight_factor *     &
-                                              particles(n)%radius**3
+                ql_v(k,j,i)  = ql_v(k,j,i)  + particles(n)%weight_factor * particles(n)%radius**3
              ENDDO
 !
 !--          Calculate the liquid water content
              IF ( ql_v(k,j,i) /= 0.0_wp )  THEN
-                ql(k,j,i) = ql(k,j,i) + rho_l * 1.33333333_wp * pi *           &
-                                        ql_v(k,j,i) /                          &
-                                        ( rho_surface * dx * dy * dzw(k) )
+                ql(k,j,i) = ql(k,j,i) + rho_l * 1.33333333_wp * pi *                               &
+                                        ql_v(k,j,i) / ( rho_surface * dx * dy * dzw(k) )
                 IF ( ql(k,j,i) < 0.0_wp )  THEN
-                   WRITE( message_string, * )  'LWC out of range: ' , &
-                                               ql(k,j,i),i,j,k
-                   CALL message( 'lpm_calc_liquid_water_content', 'PA0719',    &
-                                   2, 2, -1, 6, 1 )
+                   WRITE( message_string, * )  'LWC out of range: ' , ql(k,j,i),i,j,k
+                   CALL message( 'lpm_calc_liquid_water_content', 'PA0719', 2, 2, -1, 6, 1 )
                 ENDIF
              ELSE
@@ -5751 +5575 @@
 
 
-!------------------------------------------------------------------------------! 
+!--------------------------------------------------------------------------------------------------!
 ! Description:
 ! ------------
-!> Calculates change in droplet radius by collision. Droplet collision is
-!> calculated for each grid box seperately. Collision is parameterized by
-!> using collision kernels. Two different kernels are available:
-!> Hall kernel: Kernel from Hall (1980, J. Atmos. Sci., 2486-2507), which
-!>              considers collision due to pure gravitational effects.
-!> Wang kernel: Beside gravitational effects (treated with the Hall-kernel) also
-!>              the effects of turbulence on the collision are considered using
-!>              parameterizations of Ayala et al. (2008, New J. Phys., 10,
-!>              075015) and Wang and Grabowski (2009, Atmos. Sci. Lett., 10,
-!>              1-8). This kernel includes three possible effects of turbulence:
+!> Calculates change in droplet radius by collision. Droplet collision is calculated for each grid
+!> box seperately. Collision is parameterized by using collision kernels. Two different kernels are
+!> available:
+!> Hall kernel: Kernel from Hall (1980, J. Atmos. Sci., 2486-2507), which considers collision due to
+!>              pure gravitational effects.
+!> Wang kernel: Beside gravitational effects (treated with the Hall-kernel) also the effects of
+!>              turbulence on the collision are considered using parameterizations of Ayala et al.
+!>              (2008, New J. Phys., 10, 075015) and Wang and Grabowski (2009, Atmos. Sci. Lett.,
+!>              10, 1-8). This kernel includes three possible effects of turbulence:
 !>              the modification of the relative velocity between the droplets,
-!>              the effect of preferential concentration, and the enhancement of
-!>              collision efficiencies.
-!------------------------------------------------------------------------------! 
+!>              the effect of preferential concentration,
+!>              and the enhancement of collision efficiencies.
+!--------------------------------------------------------------------------------------------------!
  SUBROUTINE lpm_droplet_collision (i,j,k)
 
@@ -5789 +5612 @@
     REAL(wp) ::  xsn                     !< aerosol mass of super-droplet n
 
+    REAL(wp), DIMENSION(:), ALLOCATABLE ::  aero_mass !< total aerosol mass of super droplet
+    REAL(wp), DIMENSION(:), ALLOCATABLE ::  mass      !< total mass of super droplet
     REAL(wp), DIMENSION(:), ALLOCATABLE ::  weight    !< weighting factor
-    REAL(wp), DIMENSION(:), ALLOCATABLE ::  mass      !< total mass of super droplet
-    REAL(wp), DIMENSION(:), ALLOCATABLE ::  aero_mass !< total aerosol mass of super droplet
 
     CALL cpu_log( log_point_s(43), 'lpm_droplet_coll', 'start' )
@@ -5804 +5627 @@
        IF ( use_kernel_tables )  THEN
 !
-!--       Fast method with pre-calculated collection kernels for
-!--       discrete radius- and dissipation-classes.
+!--       Fast method with pre-calculated collection kernels for discrete radius- and
+!--       dissipation-classes.
           IF ( wang_kernel )  THEN
-             eclass = INT( diss(k,j,i) * 1.0E4_wp / 600.0_wp * &
-                           dissipation_classes ) + 1
+             eclass = INT( diss(k,j,i) * 1.0E4_wp / 600.0_wp * dissipation_classes ) + 1
              epsilon_collision = diss(k,j,i)
           ELSE
@@ -5822 +5644 @@
        ELSE
 !
-!--       Collection kernels are re-calculated for every new
-!--       grid box. First, allocate memory for kernel table.
-!--       Third dimension is 1, because table is re-calculated for
-!--       every new dissipation value.
+!--       Collection kernels are re-calculated for every new grid box. First, allocate memory for
+!--       kernel table.
+!--       Third dimension is 1, because table is re-calculated for every new dissipation value.
           ALLOCATE( ckernel(1:number_of_particles,1:number_of_particles,1:1) )
 !
-!--       Now calculate collection kernel for this box. Note that
-!--       the kernel is based on the previous time step
+!--       Now calculate collection kernel for this box. Note that the kernel is based on the
+!--       previous time step
           CALL recalculate_kernel( i, j, k )
 
        ENDIF
 !
-!--    Temporary fields for total mass of super-droplet, aerosol mass, and
-!--    weighting factor are allocated.
+!--    Temporary fields for total mass of super-droplet, aerosol mass, and weighting factor are
+!--    allocated.
        ALLOCATE(mass(1:number_of_particles), weight(1:number_of_particles))
        IF ( curvature_solution_effects )  ALLOCATE(aero_mass(1:number_of_particles))
 
-       mass(1:number_of_particles)   = particles(1:number_of_particles)%weight_factor * &
-                                       particles(1:number_of_particles)%radius**3     * &
+       mass(1:number_of_particles)   = particles(1:number_of_particles)%weight_factor *            &
+                                       particles(1:number_of_particles)%radius**3     *            &
                                        factor_volume_to_mass
 
@@ -5846 +5667 @@
 
        IF ( curvature_solution_effects )  THEN
-          aero_mass(1:number_of_particles) = particles(1:number_of_particles)%weight_factor * &
-                                             particles(1:number_of_particles)%aux1**3       * &
+          aero_mass(1:number_of_particles) = particles(1:number_of_particles)%weight_factor *      &
+                                             particles(1:number_of_particles)%aux1**3       *      &
                                              4.0_wp / 3.0_wp * pi * rho_s
        ENDIF
@@ -5856 +5677 @@
           DO  m = n, number_of_particles
 !
-!--          For collisions, the weighting factor of at least one super-droplet
-!--          needs to be larger or equal to one.
+!--          For collisions, the weighting factor of at least one super-droplet needs to be larger
+!--          or equal to one.
              IF ( MIN( weight(n), weight(m) ) < 1.0_wp )  CYCLE
 !
@@ -5873 +5694 @@
                 rclass_s = particles(m)%class
 
-                collection_probability  = MAX( weight(n), weight(m) ) *     &
+                collection_probability  = MAX( weight(n), weight(m) ) *                            &
                                           ckernel(rclass_l,rclass_s,eclass) * ddV * dt_3d
              ELSE
-                collection_probability  = MAX( weight(n), weight(m) ) *     &
+                collection_probability  = MAX( weight(n), weight(m) ) *                            &
                                           ckernel(n,m,1) * ddV * dt_3d
              ENDIF
@@ -5883 +5704 @@
 !--          (Accordingly, p_crit will be 0.0, 1.0, 2.0, ...)
              CALL random_number_parallel( random_dummy )
-             IF ( collection_probability - FLOOR(collection_probability)    &
-                  > random_dummy )  THEN
+             IF ( collection_probability - FLOOR(collection_probability) > random_dummy )  THEN
                 collection_probability = FLOOR(collection_probability) + 1.0_wp
              ELSE
@@ -5919 +5739 @@
 !--                particle m collects 1/2 weight(m) droplets of particle n.
 !--                The total mass mass changes accordingly.
-!--                If n = m, the first half of the droplets coalesces with the
-!--                second half of the droplets; mass is unchanged because
-!--                xm = xn for n = m.
+!--                If n = m, the first half of the droplets coalesces with the second half of the
+!--                droplets; mass is unchanged because xm = xn for n = m.
 !--
-!--                Note: For m = n this equation is an approximation only
-!--                valid for weight >> 1 (which is usually the case). The
-!--                approximation is weight(n)-1 = weight(n).
+!--                Note: For m = n this equation is an approximation only valid for weight >> 1
+!--                (which is usually the case). The approximation is weight(n)-1 = weight(n).
                    mass(n)   = mass(n)   + 0.5_wp * weight(n) * ( xm - xn )
                    mass(m)   = mass(m)   + 0.5_wp * weight(m) * ( xn - xm )
@@ -5947 +5765 @@
        IF ( ANY(weight < 0.0_wp) )  THEN
              WRITE( message_string, * ) 'negative weighting factor'
-             CALL message( 'lpm_droplet_collision', 'PA0028',      &
-                            2, 2, -1, 6, 1 )
+             CALL message( 'lpm_droplet_collision', 'PA0028', 2, 2, -1, 6, 1 )
        ENDIF
 
-       particles(1:number_of_particles)%radius = ( mass(1:number_of_particles) /   &
-                                                   ( weight(1:number_of_particles) &
-                                                     * factor_volume_to_mass       &
-                                                   )                               &
+       particles(1:number_of_particles)%radius = ( mass(1:number_of_particles) /                   &
+                                                    ( weight(1:number_of_particles)                &
+                                                      * factor_volume_to_mass                      &
+                                                    )                                              &
                                                  )**0.33333333333333_wp
 
        IF ( curvature_solution_effects )  THEN
-          particles(1:number_of_particles)%aux1 = ( aero_mass(1:number_of_particles) / &
-                                                    ( weight(1:number_of_particles)    &
-                                                      * 4.0_wp / 3.0_wp * pi * rho_s   &
-                                                    )                                  &
+          particles(1:number_of_particles)%aux1 = ( aero_mass(1:number_of_particles) /             &
+                                                     ( weight(1:number_of_particles)               &
+                                                       * 4.0_wp / 3.0_wp * pi * rho_s              &
+                                                     )                                             &
                                                   )**0.33333333333333_wp
        ENDIF
@@ -5974 +5791 @@
 !--    Check if LWC is conserved during collision process
        IF ( ql_v(k,j,i) /= 0.0_wp )  THEN
-          IF ( ql_vp(k,j,i) / ql_v(k,j,i) >= 1.0001_wp  .OR.                      &
+          IF ( ql_vp(k,j,i) / ql_v(k,j,i) >= 1.0001_wp  .OR.                                       &
                ql_vp(k,j,i) / ql_v(k,j,i) <= 0.9999_wp )  THEN
-             WRITE( message_string, * ) ' LWC is not conserved during',           &
-                                        ' collision! ',                           &
-                                        ' LWC after condensation: ', ql_v(k,j,i), &
+             WRITE( message_string, * ) ' LWC is not conserved during',' collision! ',             &
+                                        ' LWC after condensation: ', ql_v(k,j,i),                  &
                                         ' LWC after collision: ', ql_vp(k,j,i)
              CALL message( 'lpm_droplet_collision', 'PA0040', 2, 2, -1, 6, 1 )
@@ -5989 +5805 @@
 
  END SUBROUTINE lpm_droplet_collision
- 
-!------------------------------------------------------------------------------!
+
+!--------------------------------------------------------------------------------------------------!
 ! Description:
 ! ------------
-!> Initialization of the collision efficiency matrix with fixed radius and
-!> dissipation classes, calculated at simulation start only.
-!------------------------------------------------------------------------------! 
+!> Initialization of the collision efficiency matrix with fixed radius and dissipation classes,
+!> calculated at simulation start only.
+!--------------------------------------------------------------------------------------------------!
  SUBROUTINE lpm_init_kernels
 
@@ -6001 +5817 @@
     INTEGER(iwp) ::  j !<
     INTEGER(iwp) ::  k !<
-    
-!
-!-- Calculate collision efficiencies for fixed radius- and dissipation
-!-- classes
+
+!
+!-- Calculate collision efficiencies for fixed radius- and dissipation classes
     IF ( collision_kernel(6:9) == 'fast' )  THEN
 
-       ALLOCATE( ckernel(1:radius_classes,1:radius_classes,                 &
-                 0:dissipation_classes), epsclass(1:dissipation_classes),   &
+       ALLOCATE( ckernel(1:radius_classes,1:radius_classes,0:dissipation_classes),                 &
+                 epsclass(1:dissipation_classes),                                                  &
                  radclass(1:radius_classes) )
 
 !
-!--    Calculate the radius class bounds with logarithmic distances
-!--    in the interval [1.0E-6, 1000.0E-6] m
+!--    Calculate the radius class bounds with logarithmic distances in the interval
+!--    [1.0E-6, 1000.0E-6] m
        rclass_lbound = LOG( 1.0E-6_wp )
        rclass_ubound = LOG( 1000.0E-6_wp )
        radclass(1)   = EXP( rclass_lbound )
        DO  i = 2, radius_classes
-          radclass(i) = EXP( rclass_lbound +                                &
-                             ( rclass_ubound - rclass_lbound ) *            &
+          radclass(i) = EXP( rclass_lbound +                                                       &
+                             ( rclass_ubound - rclass_lbound ) *                                   &
                              ( i - 1.0_wp ) / ( radius_classes - 1.0_wp ) )
        ENDDO
@@ -6030 +5845 @@
 !
 !--    Calculate collision efficiencies of the Wang/ayala kernel
-       ALLOCATE( ec(1:radius_classes,1:radius_classes),  &
-                 ecf(1:radius_classes,1:radius_classes), &
-                 gck(1:radius_classes,1:radius_classes), &
+       ALLOCATE( ec(1:radius_classes,1:radius_classes),                                            &
+                 ecf(1:radius_classes,1:radius_classes),                                           &
+                 gck(1:radius_classes,1:radius_classes),                                           &
                  winf(1:radius_classes) )
 
@@ -6054 +5869 @@
 !
 !--    Calculate collision efficiencies of the Hall kernel
-       ALLOCATE( hkernel(1:radius_classes,1:radius_classes), &
+       ALLOCATE( hkernel(1:radius_classes,1:radius_classes),                                       &
                  hwratio(1:radius_classes,1:radius_classes) )
 
@@ -6062 +5877 @@
        DO  j = 1, radius_classes
           DO  i =  1, radius_classes
-             hkernel(i,j) = pi * ( radclass(j) + radclass(i) )**2 &
+             hkernel(i,j) = pi * ( radclass(j) + radclass(i) )**2                                  &
                                * ec(i,j) * ABS( winf(j) - winf(i) )
              ckernel(i,j,0) = hkernel(i,j)  ! hall kernel stored on index 0
@@ -6072 +5887 @@
        IF ( j == -1 )  THEN
           PRINT*, '*** Hall kernel'
-          WRITE ( *,'(5X,20(F4.0,1X))' ) ( radclass(i)*1.0E6_wp, &
-                                           i = 1,radius_classes )
+          WRITE ( *,'(5X,20(F4.0,1X))' ) ( radclass(i)*1.0E6_wp, i = 1,radius_classes )
           DO  j = 1, radius_classes
-             WRITE ( *,'(F4.0,1X,20(F8.4,1X))' ) radclass(j),  &
-                                       ( hkernel(i,j), i = 1,radius_classes )
+             WRITE ( *,'(F4.0,1X,20(F8.4,1X))' ) radclass(j), ( hkernel(i,j), i = 1,radius_classes )
           ENDDO
 
@@ -6091 +5904 @@
 
              PRINT*, '*** epsilon = ', epsclass(k)
-             WRITE ( *,'(5X,20(F4.0,1X))' ) ( radclass(i) * 1.0E6_wp, &
-                                              i = 1,radius_classes )
+             WRITE ( *,'(5X,20(F4.0,1X))' ) ( radclass(i) * 1.0E6_wp, i = 1,radius_classes )
              DO  j = 1, radius_classes
-                WRITE ( *,'(F4.0,1X,20(F8.4,1X))' ) radclass(j) * 1.0E6_wp, &
-                                       ( hwratio(i,j), i = 1,radius_classes )
+                WRITE ( *,'(F4.0,1X,20(F8.4,1X))' ) radclass(j) * 1.0E6_wp,                        &
+                                                    ( hwratio(i,j), i = 1,radius_classes )
              ENDDO
           ENDDO
@@ -6105 +5917 @@
 
  END SUBROUTINE lpm_init_kernels
- 
-!------------------------------------------------------------------------------!
+
+!--------------------------------------------------------------------------------------------------!
 ! Description:
 ! ------------
 !> Calculation of collision kernels during each timestep and for each grid box
-!------------------------------------------------------------------------------!
+!--------------------------------------------------------------------------------------------------!
  SUBROUTINE recalculate_kernel( i1, j1, k1 )
 
@@ -6123 +5935 @@
     number_of_particles = prt_count(k1,j1,i1)
     radius_classes      = number_of_particles   ! necessary to use the same
-                                                ! subroutines as for 
+                                                ! subroutines as for
                                                 ! precalculated kernels
 
-    ALLOCATE( ec(1:number_of_particles,1:number_of_particles), &
+    ALLOCATE( ec(1:number_of_particles,1:number_of_particles),                                     &
               radclass(1:number_of_particles), winf(1:number_of_particles) )
 
@@ -6143 +5955 @@
 !
 !--    Call routines to calculate efficiencies for the Wang kernel
-       ALLOCATE( gck(1:number_of_particles,1:number_of_particles), &
+       ALLOCATE( gck(1:number_of_particles,1:number_of_particles),                                 &
                  ecf(1:number_of_particles,1:number_of_particles) )
 
@@ -6165 +5977 @@
        DO  j = 1, number_of_particles
           DO  i =  1, number_of_particles
-             ckernel(i,j,1) = pi * ( radclass(j) + radclass(i) )**2         &
+             ckernel(i,j,1) = pi * ( radclass(j) + radclass(i) )**2                                &
                                  * ec(i,j) * ABS( winf(j) - winf(i) )
           ENDDO
@@ -6175 +5987 @@
  END SUBROUTINE recalculate_kernel
 
-!------------------------------------------------------------------------------! 
+!--------------------------------------------------------------------------------------------------!
 ! Description:
 ! ------------
-!> Calculation of effects of turbulence on the geometric collision kernel 
-!> (by including the droplets' average radial relative velocities and their 
-!> radial distribution function) following the analytic model by Aayala et al. 
-!> (2008, New J. Phys.). For details check the second part 2 of the publication,
-!> page 37ff.
+!> Calculation of effects of turbulence on the geometric collision kernel (by including the
+!> droplets' average radial relative velocities and their radial distribution function) following
+!> the analytic model by Aayala et al. (2008, New J. Phys.). For details check the second part 2 of
+!> the publication, page 37ff.
 !>
-!> Input parameters, which need to be replaced by PALM parameters:
-!>    water density, air density
-!------------------------------------------------------------------------------!
+!> Input parameters, which need to be replaced by PALM parameters: water density, air density
+!--------------------------------------------------------------------------------------------------!
  SUBROUTINE turbsd
 
@@ -6284 +6094 @@
           t2  = tau(j)
 
-          v1xysq  = b1 * d1 * phi_w(c1,e1,v1,t1) - b1 * d2 * phi_w(c1,e2,v1,t1) &
-                  - b2 * d1 * phi_w(c2,e1,v1,t1) + b2 * d2 * phi_w(c2,e2,v1,t1)
+          v1xysq  =   b1 * d1 * phi_w(c1,e1,v1,t1) - b1 * d2 * phi_w(c1,e2,v1,t1)                  &
+                    - b2 * d1 * phi_w(c2,e1,v1,t1) + b2 * d2 * phi_w(c2,e2,v1,t1)
           v1xysq  = v1xysq * urms**2 / t1
           vrms1xy = SQRT( v1xysq )
 
-          v2xysq  = b1 * d1 * phi_w(c1,e1,v2,t2) - b1 * d2 * phi_w(c1,e2,v2,t2) &
-                  - b2 * d1 * phi_w(c2,e1,v2,t2) + b2 * d2 * phi_w(c2,e2,v2,t2)
+          v2xysq  =   b1 * d1 * phi_w(c1,e1,v2,t2) - b1 * d2 * phi_w(c1,e2,v2,t2)                  &
+                    - b2 * d1 * phi_w(c2,e1,v2,t2) + b2 * d2 * phi_w(c2,e2,v2,t2)
           v2xysq  = v2xysq * urms**2 / t2
           vrms2xy = SQRT( v2xysq )
@@ -6306 +6116 @@
           ENDIF
 
-          v1v2xy   =  b1 * d1 * zhi(c1,e1,v1,t1,v2,t2) - &
-                      b1 * d2 * zhi(c1,e2,v1,t1,v2,t2) - &
-                      b2 * d1 * zhi(c2,e1,v1,t1,v2,t2) + &
+          v1v2xy   =  b1 * d1 * zhi(c1,e1,v1,t1,v2,t2) -                                           &
+                      b1 * d2 * zhi(c1,e2,v1,t1,v2,t2) -                                           &
+                      b2 * d1 * zhi(c2,e1,v1,t1,v2,t2) +                                           &
                       b2 * d2* zhi(c2,e2,v1,t1,v2,t2)
           fr       = d1 * EXP( -rrp / e1 ) - d2 * EXP( -rrp / e2 )
@@ -6325 +6135 @@
           ENDIF
 
-          xx = -0.1988_wp * sst**4 + 1.5275_wp * sst**3 - 4.2942_wp *       &
-                sst**2 + 5.3406_wp * sst
+          xx = -0.1988_wp * sst**4 + 1.5275_wp * sst**3 - 4.2942_wp * sst**2 + 5.3406_wp * sst
           IF ( xx < 0.0_wp )  xx = 0.0_wp
           yy = 0.1886_wp * EXP( 20.306_wp / lambda_re )
@@ -6340 +6149 @@
 
 !
-!--       Calculate general collection kernel (without the consideration of
-!--       collection efficiencies)
+!--       Calculate general collection kernel (without the consideration of collection efficiencies)
           gck(i,j) = 2.0_wp * pi * rrp**2 * wrfin * grfin
           gck(j,i) = gck(i,j)
@@ -6352 +6160 @@
  REAL(wp) FUNCTION phi_w( a, b, vsett, tau0 )
 !
-!-- Function used in the Ayala et al. (2008) analytical model for turbulent
-!-- effects on the collision kernel
-    
+!-- Function used in the Ayala et al. (2008) analytical model for turbulent effects on the
+!-- collision kernel
+
 
     REAL(wp) ::  a     !<
@@ -6369 +6177 @@
  REAL(wp) FUNCTION zhi( a, b, vsett1, tau1, vsett2, tau2 )
 !
-!-- Function used in the Ayala et al. (2008) analytical model for turbulent
-!-- effects on the collision kernel
+!-- Function used in the Ayala et al. (2008) analytical model for turbulent effects on the collision
+!-- kernel
 
     REAL(wp) ::  a      !<
@@ -6390 +6198 @@
     aa4 = ( vsett2 / b )**2 - ( 1.0_wp / tau2 + 1.0_wp / a )**2
     aa5 = vsett2 / b + 1.0_wp / tau2 + 1.0_wp / a
-    aa6 = 1.0_wp / tau1 - 1.0_wp / a + ( 1.0_wp / tau2 + 1.0_wp / a) *      &
-          vsett1 / vsett2
-    zhi = (1.0_wp / aa1 - 1.0_wp / aa2 ) * ( vsett1 - vsett2 ) * 0.5_wp /   &
-          b / aa3**2 + ( 4.0_wp / aa4 - 1.0_wp / aa5**2 - 1.0_wp / aa1**2 ) &
-          * vsett2 * 0.5_wp / b /aa6 + ( 2.0_wp * ( b / aa2 - b / aa1 ) -   &
+    aa6 = 1.0_wp / tau1 - 1.0_wp / a + ( 1.0_wp / tau2 + 1.0_wp / a) * vsett1 / vsett2
+    zhi = ( 1.0_wp / aa1 - 1.0_wp / aa2 ) * ( vsett1 - vsett2 ) * 0.5_wp /                         &
+          b / aa3**2 + ( 4.0_wp / aa4 - 1.0_wp / aa5**2 - 1.0_wp / aa1**2 )                        &
+          * vsett2 * 0.5_wp / b /aa6 + ( 2.0_wp * ( b / aa2 - b / aa1 ) -                          &
           vsett1 / aa2**2 + vsett2 / aa1**2 ) * 0.5_wp / b / aa3
 
@@ -6400 +6207 @@
 
 
-!------------------------------------------------------------------------------!
+!--------------------------------------------------------------------------------------------------!
 ! Description:
 ! ------------
-!> Parameterization of terminal velocity following Rogers et al. (1993, J. Appl.
-!> Meteorol.)
-!------------------------------------------------------------------------------!
+!> Parameterization of terminal velocity following Rogers et al. (1993, J. Appl.Meteorol.)
+!--------------------------------------------------------------------------------------------------!
  SUBROUTINE fallg
 
     INTEGER(iwp) ::  j                            !<
 
-    REAL(wp), PARAMETER ::  k_cap_rog = 4.0_wp    !< parameter
-    REAL(wp), PARAMETER ::  k_low_rog = 12.0_wp   !< parameter
     REAL(wp), PARAMETER ::  a_rog     = 9.65_wp   !< parameter
     REAL(wp), PARAMETER ::  b_rog     = 10.43_wp  !< parameter
     REAL(wp), PARAMETER ::  c_rog     = 0.6_wp    !< parameter
     REAL(wp), PARAMETER ::  d0_rog    = 0.745_wp  !< seperation diameter
+    REAL(wp), PARAMETER ::  k_cap_rog = 4.0_wp    !< parameter
+    REAL(wp), PARAMETER ::  k_low_rog = 12.0_wp   !< parameter
 
     REAL(wp)            ::  diameter              !< droplet diameter in mm
@@ -6425 +6231 @@
 
        IF ( diameter <= d0_rog )  THEN
-          winf(j) = k_cap_rog * diameter * ( 1.0_wp -                       &
-                                             EXP( -k_low_rog * diameter ) )
+          winf(j) = k_cap_rog * diameter * ( 1.0_wp - EXP( -k_low_rog * diameter ) )
        ELSE
           winf(j) = a_rog - b_rog * EXP( -c_rog * diameter )
@@ -6436 +6241 @@
 
 
-!------------------------------------------------------------------------------!
+!--------------------------------------------------------------------------------------------------!
 ! Description:
 ! ------------
 !> Interpolation of collision efficiencies (Hall, 1980, J. Atmos. Sci.)
-!------------------------------------------------------------------------------!
+!--------------------------------------------------------------------------------------------------!
  SUBROUTINE effic
- 
+
     INTEGER(iwp) ::  i  !<
     INTEGER(iwp) ::  iq !<
@@ -6460 +6265 @@
 
     REAL(wp), DIMENSION(1:21), SAVE ::  rat        !<
-    
+
     REAL(wp), DIMENSION(1:15), SAVE ::  r0         !<
-    
+
     REAL(wp), DIMENSION(1:15,1:21), SAVE ::  ecoll !<
 
@@ -6470 +6275 @@
 
       first = .FALSE.
-      r0  = (/   6.0_wp,   8.0_wp,  10.0_wp, 15.0_wp,  20.0_wp,  25.0_wp,   &
-                30.0_wp,  40.0_wp,  50.0_wp, 60.0_wp,  70.0_wp, 100.0_wp,   &
+      r0  = (/   6.0_wp,   8.0_wp,  10.0_wp, 15.0_wp,  20.0_wp,  25.0_wp,                          &
+                30.0_wp,  40.0_wp,  50.0_wp, 60.0_wp,  70.0_wp, 100.0_wp,                          &
                150.0_wp, 200.0_wp, 300.0_wp /)
 
-      rat = (/ 0.00_wp, 0.05_wp, 0.10_wp, 0.15_wp, 0.20_wp, 0.25_wp,        &
-               0.30_wp, 0.35_wp, 0.40_wp, 0.45_wp, 0.50_wp, 0.55_wp,        &
-               0.60_wp, 0.65_wp, 0.70_wp, 0.75_wp, 0.80_wp, 0.85_wp,        &
+      rat = (/ 0.00_wp, 0.05_wp, 0.10_wp, 0.15_wp, 0.20_wp, 0.25_wp,                               &
+               0.30_wp, 0.35_wp, 0.40_wp, 0.45_wp, 0.50_wp, 0.55_wp,                               &
+               0.60_wp, 0.65_wp, 0.70_wp, 0.75_wp, 0.80_wp, 0.85_wp,                               &
                0.90_wp, 0.95_wp, 1.00_wp /)
 
-      ecoll(:,1)  = (/ 0.001_wp, 0.001_wp, 0.001_wp, 0.001_wp, 0.001_wp,    &
-                       0.001_wp, 0.001_wp, 0.001_wp, 0.001_wp, 0.001_wp,    &
+      ecoll(:,1)  = (/ 0.001_wp, 0.001_wp, 0.001_wp, 0.001_wp, 0.001_wp,                           &
+                       0.001_wp, 0.001_wp, 0.001_wp, 0.001_wp, 0.001_wp,                           &
                        0.001_wp, 0.001_wp, 0.001_wp, 0.001_wp, 0.001_wp /)
-      ecoll(:,2)  = (/ 0.003_wp, 0.003_wp, 0.003_wp, 0.004_wp, 0.005_wp,    &
-                       0.005_wp, 0.005_wp, 0.010_wp, 0.100_wp, 0.050_wp,    &
+      ecoll(:,2)  = (/ 0.003_wp, 0.003_wp, 0.003_wp, 0.004_wp, 0.005_wp,                           &
+                       0.005_wp, 0.005_wp, 0.010_wp, 0.100_wp, 0.050_wp,                           &
                        0.200_wp, 0.500_wp, 0.770_wp, 0.870_wp, 0.970_wp /)
-      ecoll(:,3)  = (/ 0.007_wp, 0.007_wp, 0.007_wp, 0.008_wp, 0.009_wp,    &
-                       0.010_wp, 0.010_wp, 0.070_wp, 0.400_wp, 0.430_wp,    &
+      ecoll(:,3)  = (/ 0.007_wp, 0.007_wp, 0.007_wp, 0.008_wp, 0.009_wp,                           &
+                       0.010_wp, 0.010_wp, 0.070_wp, 0.400_wp, 0.430_wp,                           &
                        0.580_wp, 0.790_wp, 0.930_wp, 0.960_wp, 1.000_wp /)
-      ecoll(:,4)  = (/ 0.009_wp, 0.009_wp, 0.009_wp, 0.012_wp, 0.015_wp,    &
-                       0.010_wp, 0.020_wp, 0.280_wp, 0.600_wp, 0.640_wp,    &
+      ecoll(:,4)  = (/ 0.009_wp, 0.009_wp, 0.009_wp, 0.012_wp, 0.015_wp,                           &
+                       0.010_wp, 0.020_wp, 0.280_wp, 0.600_wp, 0.640_wp,                           &
                        0.750_wp, 0.910_wp, 0.970_wp, 0.980_wp, 1.000_wp /)
-      ecoll(:,5)  = (/ 0.014_wp, 0.014_wp, 0.014_wp, 0.015_wp, 0.016_wp,    &
-                       0.030_wp, 0.060_wp, 0.500_wp, 0.700_wp, 0.770_wp,    &
+      ecoll(:,5)  = (/ 0.014_wp, 0.014_wp, 0.014_wp, 0.015_wp, 0.016_wp,                           &
+                       0.030_wp, 0.060_wp, 0.500_wp, 0.700_wp, 0.770_wp,                           &
                        0.840_wp, 0.950_wp, 0.970_wp, 1.000_wp, 1.000_wp /)
-      ecoll(:,6)  = (/ 0.017_wp, 0.017_wp, 0.017_wp, 0.020_wp, 0.022_wp,    &
-                       0.060_wp, 0.100_wp, 0.620_wp, 0.780_wp, 0.840_wp,    &
+      ecoll(:,6)  = (/ 0.017_wp, 0.017_wp, 0.017_wp, 0.020_wp, 0.022_wp,                           &
+                       0.060_wp, 0.100_wp, 0.620_wp, 0.780_wp, 0.840_wp,                           &
                        0.880_wp, 0.950_wp, 1.000_wp, 1.000_wp, 1.000_wp /)
-      ecoll(:,7)  = (/ 0.030_wp, 0.030_wp, 0.024_wp, 0.022_wp, 0.032_wp,    &
-                       0.062_wp, 0.200_wp, 0.680_wp, 0.830_wp, 0.870_wp,    &
+      ecoll(:,7)  = (/ 0.030_wp, 0.030_wp, 0.024_wp, 0.022_wp, 0.032_wp,                           &
+                       0.062_wp, 0.200_wp, 0.680_wp, 0.830_wp, 0.870_wp,                           &
                        0.900_wp, 0.950_wp, 1.000_wp, 1.000_wp, 1.000_wp /)
-      ecoll(:,8)  = (/ 0.025_wp, 0.025_wp, 0.025_wp, 0.036_wp, 0.043_wp,    &
-                       0.130_wp, 0.270_wp, 0.740_wp, 0.860_wp, 0.890_wp,    &
+      ecoll(:,8)  = (/ 0.025_wp, 0.025_wp, 0.025_wp, 0.036_wp, 0.043_wp,                           &
+                       0.130_wp, 0.270_wp, 0.740_wp, 0.860_wp, 0.890_wp,                           &
                        0.920_wp, 1.000_wp, 1.000_wp, 1.000_wp, 1.000_wp /)
-      ecoll(:,9)  = (/ 0.027_wp, 0.027_wp, 0.027_wp, 0.040_wp, 0.052_wp,    &
-                       0.200_wp, 0.400_wp, 0.780_wp, 0.880_wp, 0.900_wp,    &
+      ecoll(:,9)  = (/ 0.027_wp, 0.027_wp, 0.027_wp, 0.040_wp, 0.052_wp,                           &
+                       0.200_wp, 0.400_wp, 0.780_wp, 0.880_wp, 0.900_wp,                           &
                        0.940_wp, 1.000_wp, 1.000_wp, 1.000_wp, 1.000_wp /)
-      ecoll(:,10) = (/ 0.030_wp, 0.030_wp, 0.030_wp, 0.047_wp, 0.064_wp,    &
-                       0.250_wp, 0.500_wp, 0.800_wp, 0.900_wp, 0.910_wp,    &
+      ecoll(:,10) = (/ 0.030_wp, 0.030_wp, 0.030_wp, 0.047_wp, 0.064_wp,                           &
+                       0.250_wp, 0.500_wp, 0.800_wp, 0.900_wp, 0.910_wp,                           &
                        0.950_wp, 1.000_wp, 1.000_wp, 1.000_wp, 1.000_wp /)
-      ecoll(:,11) = (/ 0.040_wp, 0.040_wp, 0.033_wp, 0.037_wp, 0.068_wp,    &
-                       0.240_wp, 0.550_wp, 0.800_wp, 0.900_wp, 0.910_wp,    &
+      ecoll(:,11) = (/ 0.040_wp, 0.040_wp, 0.033_wp, 0.037_wp, 0.068_wp,                           &
+                       0.240_wp, 0.550_wp, 0.800_wp, 0.900_wp, 0.910_wp,                           &
                        0.950_wp, 1.000_wp, 1.000_wp, 1.000_wp, 1.000_wp /)
-      ecoll(:,12) = (/ 0.035_wp, 0.035_wp, 0.035_wp, 0.055_wp, 0.079_wp,    &
-                       0.290_wp, 0.580_wp, 0.800_wp, 0.900_wp, 0.910_wp,    &
+      ecoll(:,12) = (/ 0.035_wp, 0.035_wp, 0.035_wp, 0.055_wp, 0.079_wp,                           &
+                       0.290_wp, 0.580_wp, 0.800_wp, 0.900_wp, 0.910_wp,                           &
                        0.950_wp, 1.000_wp, 1.000_wp, 1.000_wp, 1.000_wp /)
-      ecoll(:,13) = (/ 0.037_wp, 0.037_wp, 0.037_wp, 0.062_wp, 0.082_wp,    &
-                       0.290_wp, 0.590_wp, 0.780_wp, 0.900_wp, 0.910_wp,    &
+      ecoll(:,13) = (/ 0.037_wp, 0.037_wp, 0.037_wp, 0.062_wp, 0.082_wp,                           &
+                       0.290_wp, 0.590_wp, 0.780_wp, 0.900_wp, 0.910_wp,                           &
                        0.950_wp, 1.000_wp, 1.000_wp, 1.000_wp, 1.000_wp /)
-      ecoll(:,14) = (/ 0.037_wp, 0.037_wp, 0.037_wp, 0.060_wp, 0.080_wp,    &
-                       0.290_wp, 0.580_wp, 0.770_wp, 0.890_wp, 0.910_wp,    &
+      ecoll(:,14) = (/ 0.037_wp, 0.037_wp, 0.037_wp, 0.060_wp, 0.080_wp,                           &
+                       0.290_wp, 0.580_wp, 0.770_wp, 0.890_wp, 0.910_wp,                           &
                        0.950_wp, 1.000_wp, 1.000_wp, 1.000_wp, 1.000_wp /)
-      ecoll(:,15) = (/ 0.037_wp, 0.037_wp, 0.037_wp, 0.041_wp, 0.075_wp,    &
-                       0.250_wp, 0.540_wp, 0.760_wp, 0.880_wp, 0.920_wp,    &
+      ecoll(:,15) = (/ 0.037_wp, 0.037_wp, 0.037_wp, 0.041_wp, 0.075_wp,                           &
+                       0.250_wp, 0.540_wp, 0.760_wp, 0.880_wp, 0.920_wp,                           &
                        0.950_wp, 1.000_wp, 1.000_wp, 1.000_wp, 1.000_wp /)
-      ecoll(:,16) = (/ 0.037_wp, 0.037_wp, 0.037_wp, 0.052_wp, 0.067_wp,    &
-                       0.250_wp, 0.510_wp, 0.770_wp, 0.880_wp, 0.930_wp,    &
+      ecoll(:,16) = (/ 0.037_wp, 0.037_wp, 0.037_wp, 0.052_wp, 0.067_wp,                           &
+                       0.250_wp, 0.510_wp, 0.770_wp, 0.880_wp, 0.930_wp,                           &
                        0.970_wp, 1.000_wp, 1.000_wp, 1.000_wp, 1.000_wp /)
-      ecoll(:,17) = (/ 0.037_wp, 0.037_wp, 0.037_wp, 0.047_wp, 0.057_wp,    &
-                       0.250_wp, 0.490_wp, 0.770_wp, 0.890_wp, 0.950_wp,    &
+      ecoll(:,17) = (/ 0.037_wp, 0.037_wp, 0.037_wp, 0.047_wp, 0.057_wp,                           &
+                       0.250_wp, 0.490_wp, 0.770_wp, 0.890_wp, 0.950_wp,                           &
                        1.000_wp, 1.000_wp, 1.000_wp, 1.000_wp, 1.000_wp /)
-      ecoll(:,18) = (/ 0.036_wp, 0.036_wp, 0.036_wp, 0.042_wp, 0.048_wp,    &
-                       0.230_wp, 0.470_wp, 0.780_wp, 0.920_wp, 1.000_wp,    &
+      ecoll(:,18) = (/ 0.036_wp, 0.036_wp, 0.036_wp, 0.042_wp, 0.048_wp,                           &
+                       0.230_wp, 0.470_wp, 0.780_wp, 0.920_wp, 1.000_wp,                           &
                        1.020_wp, 1.020_wp, 1.020_wp, 1.020_wp, 1.020_wp /)
-      ecoll(:,19) = (/ 0.040_wp, 0.040_wp, 0.035_wp, 0.033_wp, 0.040_wp,    &
-                       0.112_wp, 0.450_wp, 0.790_wp, 1.010_wp, 1.030_wp,    &
+      ecoll(:,19) = (/ 0.040_wp, 0.040_wp, 0.035_wp, 0.033_wp, 0.040_wp,                           &
+                       0.112_wp, 0.450_wp, 0.790_wp, 1.010_wp, 1.030_wp,                           &
                        1.040_wp, 1.040_wp, 1.040_wp, 1.040_wp, 1.040_wp /)
-      ecoll(:,20) = (/ 0.033_wp, 0.033_wp, 0.033_wp, 0.033_wp, 0.033_wp,    &
-                       0.119_wp, 0.470_wp, 0.950_wp, 1.300_wp, 1.700_wp,    &
+      ecoll(:,20) = (/ 0.033_wp, 0.033_wp, 0.033_wp, 0.033_wp, 0.033_wp,                           &
+                       0.119_wp, 0.470_wp, 0.950_wp, 1.300_wp, 1.700_wp,                           &
                        2.300_wp, 2.300_wp, 2.300_wp, 2.300_wp, 2.300_wp /)
-      ecoll(:,21) = (/ 0.027_wp, 0.027_wp, 0.027_wp, 0.027_wp, 0.027_wp,    &
-                       0.125_wp, 0.520_wp, 1.400_wp, 2.300_wp, 3.000_wp,    &
+      ecoll(:,21) = (/ 0.027_wp, 0.027_wp, 0.027_wp, 0.027_wp, 0.027_wp,                           &
+                       0.125_wp, 0.520_wp, 1.400_wp, 2.300_wp, 3.000_wp,                           &
                        4.000_wp, 4.000_wp, 4.000_wp, 4.000_wp, 4.000_wp /)
     ENDIF
 
 !
-!-- Calculate the radius class index of particles with respect to array r
-!-- Radius has to be in microns
+!-- Calculate the radius class index of particles with respect to array r.
+!-- Radius has to be in microns.
     ALLOCATE( ira(1:radius_classes) )
     DO  j = 1, radius_classes
@@ -6561 +6366 @@
 !
 !-- Two-dimensional linear interpolation of the collision efficiency.
-!-- Radius has to be in microns
+!-- Radius has to be in microns.
     DO  j = 1, radius_classes
        DO  i = 1, j
@@ -6572 +6377 @@
           IF ( ir < 16 )  THEN
              IF ( ir >= 2 )  THEN
-                pp = ( ( MAX( radclass(j), radclass(i) ) * 1.0E6_wp ) -     &
-                       r0(ir-1) ) / ( r0(ir) - r0(ir-1) )
+                pp = ( ( MAX( radclass(j), radclass(i) ) * 1.0E6_wp ) - r0(ir-1) )                 &
+                     / ( r0(ir) - r0(ir-1) )
                 qq = ( rq - rat(iq-1) ) / ( rat(iq) - rat(iq-1) )
-                ec(j,i) = ( 1.0_wp - pp ) * ( 1.0_wp - qq )                 &
-                          * ecoll(ir-1,iq-1)                                &
-                          + pp * ( 1.0_wp - qq ) * ecoll(ir,iq-1)           &
-                          + qq * ( 1.0_wp - pp ) * ecoll(ir-1,iq)           &
+                ec(j,i) = ( 1.0_wp - pp ) * ( 1.0_wp - qq ) * ecoll(ir-1,iq-1)                     &
+                          + pp * ( 1.0_wp - qq ) * ecoll(ir,iq-1)                                  &
+                          + qq * ( 1.0_wp - pp ) * ecoll(ir-1,iq)                                  &
                           + pp * qq * ecoll(ir,iq)
              ELSE
@@ -6602 +6406 @@
 
 
-!------------------------------------------------------------------------------!
+!--------------------------------------------------------------------------------------------------!
 ! Description:
 ! ------------
-!> Interpolation of turbulent enhancement factor for collision efficencies
-!> following Wang and Grabowski (2009, Atmos. Sci. Let.)
-!------------------------------------------------------------------------------!
+!> Interpolation of turbulent enhancement factor for collision efficencies following
+!> Wang and Grabowski (2009, Atmos. Sci. Let.)
+!--------------------------------------------------------------------------------------------------!
  SUBROUTINE turb_enhance_eff
 
@@ -6641 +6445 @@
        first = .FALSE.
 
-       r0  = (/  10.0_wp, 20.0_wp, 30.0_wp, 40.0_wp, 50.0_wp, 60.0_wp,  &
-                100.0_wp /)
-
-       rat = (/ 0.0_wp, 0.1_wp, 0.2_wp, 0.3_wp, 0.4_wp, 0.5_wp, 0.6_wp, &
-                0.7_wp, 0.8_wp, 0.9_wp, 1.0_wp /)
+       r0  = (/  10.0_wp, 20.0_wp, 30.0_wp, 40.0_wp, 50.0_wp, 60.0_wp, 100.0_wp /)
+
+       rat = (/ 0.0_wp, 0.1_wp, 0.2_wp, 0.3_wp, 0.4_wp, 0.5_wp, 0.6_wp, 0.7_wp, 0.8_wp, 0.9_wp,    &
+                1.0_wp /)
 !
 !--    Tabulated turbulent enhancement factor at 100 cm**2/s**3
-       ecoll_100(:,1)  = (/  1.74_wp,   1.74_wp,   1.773_wp, 1.49_wp,  &
+       ecoll_100(:,1)  = (/  1.74_wp,   1.74_wp,   1.773_wp, 1.49_wp,                              &
                              1.207_wp,  1.207_wp,  1.0_wp /)
-       ecoll_100(:,2)  = (/  1.46_wp,   1.46_wp,   1.421_wp, 1.245_wp, &
+       ecoll_100(:,2)  = (/  1.46_wp,   1.46_wp,   1.421_wp, 1.245_wp,                             &
                              1.069_wp,  1.069_wp,  1.0_wp /)
-       ecoll_100(:,3)  = (/  1.32_wp,   1.32_wp,   1.245_wp, 1.123_wp, &
+       ecoll_100(:,3)  = (/  1.32_wp,   1.32_wp,   1.245_wp, 1.123_wp,                             &
                              1.000_wp,  1.000_wp,  1.0_wp /)
-       ecoll_100(:,4)  = (/  1.250_wp,  1.250_wp,  1.148_wp, 1.087_wp, &
+       ecoll_100(:,4)  = (/  1.250_wp,  1.250_wp,  1.148_wp, 1.087_wp,                             &
                              1.025_wp,  1.025_wp,  1.0_wp /)
-       ecoll_100(:,5)  = (/  1.186_wp,  1.186_wp,  1.066_wp, 1.060_wp, &
+       ecoll_100(:,5)  = (/  1.186_wp,  1.186_wp,  1.066_wp, 1.060_wp,                             &
                              1.056_wp,  1.056_wp,  1.0_wp /)
-       ecoll_100(:,6)  = (/  1.045_wp,  1.045_wp,  1.000_wp, 1.014_wp, &
+       ecoll_100(:,6)  = (/  1.045_wp,  1.045_wp,  1.000_wp, 1.014_wp,                             &
                              1.028_wp,  1.028_wp,  1.0_wp /)
-       ecoll_100(:,7)  = (/  1.070_wp,  1.070_wp,  1.030_wp, 1.038_wp, &
+       ecoll_100(:,7)  = (/  1.070_wp,  1.070_wp,  1.030_wp, 1.038_wp,                             &
                              1.046_wp,  1.046_wp,  1.0_wp /)
-       ecoll_100(:,8)  = (/  1.000_wp,  1.000_wp,  1.054_wp, 1.042_wp, &
+       ecoll_100(:,8)  = (/  1.000_wp,  1.000_wp,  1.054_wp, 1.042_wp,                             &
                              1.029_wp,  1.029_wp,  1.0_wp /)
-       ecoll_100(:,9)  = (/  1.223_wp,  1.223_wp,  1.117_wp, 1.069_wp, &
+       ecoll_100(:,9)  = (/  1.223_wp,  1.223_wp,  1.117_wp, 1.069_wp,                             &
                              1.021_wp,  1.021_wp,  1.0_wp /)
-       ecoll_100(:,10) = (/  1.570_wp,  1.570_wp,  1.244_wp, 1.166_wp, &
+       ecoll_100(:,10) = (/  1.570_wp,  1.570_wp,  1.244_wp, 1.166_wp,                             &
                              1.088_wp,  1.088_wp,  1.0_wp /)
-       ecoll_100(:,11) = (/ 20.3_wp,   20.3_wp,   14.6_wp,   8.61_wp,  &
+       ecoll_100(:,11) = (/ 20.3_wp,   20.3_wp,   14.6_wp,   8.61_wp,                              &
                              2.60_wp,   2.60_wp,   1.0_wp /)
 !
 !--    Tabulated turbulent enhancement factor at 400 cm**2/s**3
-       ecoll_400(:,1)  = (/  4.976_wp,  4.976_wp,  3.593_wp,  2.519_wp, &
+       ecoll_400(:,1)  = (/  4.976_wp,  4.976_wp,  3.593_wp,  2.519_wp,                            &
                              1.445_wp,  1.445_wp,  1.0_wp /)
-       ecoll_400(:,2)  = (/  2.984_wp,  2.984_wp,  2.181_wp,  1.691_wp, &
+       ecoll_400(:,2)  = (/  2.984_wp,  2.984_wp,  2.181_wp,  1.691_wp,                            &
                              1.201_wp,  1.201_wp,  1.0_wp /)
-       ecoll_400(:,3)  = (/  1.988_wp,  1.988_wp,  1.475_wp,  1.313_wp, &
+       ecoll_400(:,3)  = (/  1.988_wp,  1.988_wp,  1.475_wp,  1.313_wp,                            &
                              1.150_wp,  1.150_wp,  1.0_wp /)
-       ecoll_400(:,4)  = (/  1.490_wp,  1.490_wp,  1.187_wp,  1.156_wp, &
+       ecoll_400(:,4)  = (/  1.490_wp,  1.490_wp,  1.187_wp,  1.156_wp,                            &
                              1.126_wp,  1.126_wp,  1.0_wp /)
-       ecoll_400(:,5)  = (/  1.249_wp,  1.249_wp,  1.088_wp,  1.090_wp, &
+       ecoll_400(:,5)  = (/  1.249_wp,  1.249_wp,  1.088_wp,  1.090_wp,                            &
                              1.092_wp,  1.092_wp,  1.0_wp /)
-       ecoll_400(:,6)  = (/  1.139_wp,  1.139_wp,  1.130_wp,  1.091_wp, &
+       ecoll_400(:,6)  = (/  1.139_wp,  1.139_wp,  1.130_wp,  1.091_wp,                            &
                              1.051_wp,  1.051_wp,  1.0_wp /)
-       ecoll_400(:,7)  = (/  1.220_wp,  1.220_wp,  1.190_wp,  1.138_wp, &
+       ecoll_400(:,7)  = (/  1.220_wp,  1.220_wp,  1.190_wp,  1.138_wp,                            &
                              1.086_wp,  1.086_wp,  1.0_wp /)
-       ecoll_400(:,8)  = (/  1.325_wp,  1.325_wp,  1.267_wp,  1.165_wp, &
+       ecoll_400(:,8)  = (/  1.325_wp,  1.325_wp,  1.267_wp,  1.165_wp,                            &
                              1.063_wp,  1.063_wp,  1.0_wp /)
-       ecoll_400(:,9)  = (/  1.716_wp,  1.716_wp,  1.345_wp,  1.223_wp, &
+       ecoll_400(:,9)  = (/  1.716_wp,  1.716_wp,  1.345_wp,  1.223_wp,                            &
                              1.100_wp,  1.100_wp,  1.0_wp /)
-       ecoll_400(:,10) = (/  3.788_wp,  3.788_wp,  1.501_wp,  1.311_wp, &
+       ecoll_400(:,10) = (/  3.788_wp,  3.788_wp,  1.501_wp,  1.311_wp,                            &
                              1.120_wp,  1.120_wp,  1.0_wp /)
-       ecoll_400(:,11) = (/ 36.52_wp,  36.52_wp,  19.16_wp,  22.80_wp,  &
+       ecoll_400(:,11) = (/ 36.52_wp,  36.52_wp,  19.16_wp,  22.80_wp,                             &
                             26.0_wp,   26.0_wp,    1.0_wp /)
 
@@ -6698 +6501 @@
 
 !
-!-- Calculate the radius class index of particles with respect to array r0
+!-- Calculate the radius class index of particles with respect to array r0.
 !-- The droplet radius has to be given in microns.
     ALLOCATE( ira(1:radius_classes) )
@@ -6733 +6536 @@
           IF ( ir < 8 )  THEN
              IF ( ir >= 2 )  THEN
-                pp = ( MAX( radclass(j), radclass(i) ) * 1.0E6_wp -  &
-                       r0(ir-1) ) / ( r0(ir) - r0(ir-1) )
+                pp = ( MAX( radclass(j), radclass(i) ) * 1.0E6_wp - r0(ir-1) )                     &
+                     / ( r0(ir) - r0(ir-1) )
                 qq = ( rq - rat(iq-1) ) / ( rat(iq) - rat(iq-1) )
-                y2 = ( 1.0_wp - pp ) * ( 1.0_wp - qq ) * ecoll_100(ir-1,iq-1) + &
-                             pp * ( 1.0_wp - qq ) * ecoll_100(ir,iq-1)        + &
-                             qq * ( 1.0_wp - pp ) * ecoll_100(ir-1,iq)        + &
+                y2 = ( 1.0_wp - pp ) * ( 1.0_wp - qq ) * ecoll_100(ir-1,iq-1) +                    &
+                             pp * ( 1.0_wp - qq ) * ecoll_100(ir,iq-1)        +                    &
+                             qq * ( 1.0_wp - pp ) * ecoll_100(ir-1,iq)        +                    &
                              pp * qq              * ecoll_100(ir,iq)
-                y3 = ( 1.0-pp ) * ( 1.0_wp - qq ) * ecoll_400(ir-1,iq-1)      + &
-                             pp * ( 1.0_wp - qq ) * ecoll_400(ir,iq-1)        + &
-                             qq * ( 1.0_wp - pp ) * ecoll_400(ir-1,iq)        + &
+                y3 = ( 1.0-pp ) * ( 1.0_wp - qq ) * ecoll_400(ir-1,iq-1)      +                    &
+                             pp * ( 1.0_wp - qq ) * ecoll_400(ir,iq-1)        +                    &
+                             qq * ( 1.0_wp - pp ) * ecoll_400(ir-1,iq)        +                    &
                              pp * qq              * ecoll_400(ir,iq)
              ELSE
@@ -6757 +6560 @@
 !--       Linear interpolation of turbulent enhancement factor
           IF ( epsilon_collision <= 0.01_wp )  THEN
-             ecf(j,i) = ( epsilon_collision - 0.01_wp ) / ( 0.0_wp  - 0.01_wp ) * y1 &
-                      + ( epsilon_collision - 0.0_wp  ) / ( 0.01_wp - 0.0_wp  ) * y2
+             ecf(j,i) =   ( epsilon_collision - 0.01_wp ) / ( 0.0_wp  - 0.01_wp ) * y1             &
+                        + ( epsilon_collision - 0.0_wp  ) / ( 0.01_wp - 0.0_wp  ) * y2
           ELSEIF ( epsilon_collision <= 0.06_wp )  THEN
-             ecf(j,i) = ( epsilon_collision - 0.04_wp ) / ( 0.01_wp - 0.04_wp ) * y2 &
-                      + ( epsilon_collision - 0.01_wp ) / ( 0.04_wp - 0.01_wp ) * y3
+             ecf(j,i) =   ( epsilon_collision - 0.04_wp ) / ( 0.01_wp - 0.04_wp ) * y2             &
+                        + ( epsilon_collision - 0.01_wp ) / ( 0.04_wp - 0.01_wp ) * y3
           ELSE
-             ecf(j,i) = ( 0.06_wp - 0.04_wp ) / ( 0.01_wp - 0.04_wp ) * y2 &
-                      + ( 0.06_wp - 0.01_wp ) / ( 0.04_wp - 0.01_wp ) * y3
+             ecf(j,i) =   ( 0.06_wp - 0.04_wp ) / ( 0.01_wp - 0.04_wp ) * y2                       &
+                        + ( 0.06_wp - 0.01_wp ) / ( 0.04_wp - 0.01_wp ) * y3
           ENDIF
 
@@ -6775 +6578 @@
 
  END SUBROUTINE turb_enhance_eff
- 
- 
- !------------------------------------------------------------------------------!
+
+
+ !-------------------------------------------------------------------------------------------------!
 ! Description:
 ! ------------
-! This routine is a part of the Lagrangian particle model. Super droplets which 
-! fulfill certain criterion's (e.g. a big weighting factor and a large radius) 
-! can be split into several super droplets with a reduced number of 
-! represented particles of every super droplet. This mechanism ensures an
-! improved representation of the right tail of the drop size distribution with 
-! a feasible amount of computational costs. The limits of particle creation 
-! should be chosen carefully! The idea of this algorithm is based on 
-! Unterstrasser and Soelch, 2014. 
-!------------------------------------------------------------------------------!
+! This routine is a part of the Lagrangian particle model. Super droplets which fulfill certain
+! criterion's (e.g. a big weighting factor and a large radius) can be split into several super
+! droplets with a reduced number of represented particles of every super droplet. This mechanism
+! ensures an improved representation of the right tail of the drop size distribution with a feasible
+! amount of computational costs. The limits of particle creation should be chosen carefully! The
+! idea of this algorithm is based on Unterstrasser and Soelch, 2014.
+!--------------------------------------------------------------------------------------------------!
  SUBROUTINE lpm_splitting
 
-    INTEGER(iwp) ::  i                !< 
+    INTEGER(iwp), PARAMETER ::  n_max = 100 !< number of radii bin for splitting functions
+
+    INTEGER(iwp) ::  i                !<
     INTEGER(iwp) ::  j                !<
     INTEGER(iwp) ::  jpp              !<
@@ -6798 +6601 @@
     INTEGER(iwp) ::  new_particles_gb !< counter of created particles within one grid box
     INTEGER(iwp) ::  new_size         !< new particle array size
-    INTEGER(iwp) ::  np               !< 
+    INTEGER(iwp) ::  np               !<
     INTEGER(iwp) ::  old_size         !< old particle array size
-
-    INTEGER(iwp), PARAMETER ::  n_max = 100 !< number of radii bin for splitting functions    
 
     LOGICAL ::  first_loop_stride_sp = .TRUE. !< flag to calculate constants only once
@@ -6818 +6619 @@
     REAL(wp) ::  m3_total                 !< average average over all PEs third moment of DSD
     REAL(wp) ::  mu                       !< spectral shape parameter of gamma distribution
-    REAL(wp) ::  nrclgb                   !< number of cloudy grid boxes (ql >= 1.0E-5 kg/kg) 
+    REAL(wp) ::  nrclgb                   !< number of cloudy grid boxes (ql >= 1.0E-5 kg/kg)
     REAL(wp) ::  nrclgb_total             !< average over all PEs of number of cloudy grid boxes
     REAL(wp) ::  nr                       !< number concentration of cloud droplets
@@ -6824 +6625 @@
     REAL(wp) ::  nr0                      !< intercept parameter of gamma distribution
     REAL(wp) ::  pirho_l                  !< pi * rho_l / 6.0
-    REAL(wp) ::  ql_crit = 1.0E-5_wp      !< threshold lwc for cloudy grid cells 
-                                          !< (Siebesma et al 2003, JAS, 60)
+    REAL(wp) ::  ql_crit = 1.0E-5_wp      !< threshold lwc for cloudy grid cells (Siebesma et al 2003, JAS, 60)
     REAL(wp) ::  rm                       !< volume averaged mean radius
     REAL(wp) ::  rm_total                 !< average over all PEs of volume averaged mean radius
-    REAL(wp) ::  r_min = 1.0E-6_wp        !< minimum radius of approximated spectra 
+    REAL(wp) ::  r_min = 1.0E-6_wp        !< minimum radius of approximated spectra
     REAL(wp) ::  r_max = 1.0E-3_wp        !< maximum radius of approximated spectra
     REAL(wp) ::  sigma_log = 1.5_wp       !< standard deviation of the LOG-distribution
@@ -6849 +6649 @@
           ENDDO
           r_bin(n_max) = 10.0_wp**( LOG10(r_min) + n_max * dlog - 0.5_wp * dlog )
-       ENDIF   
+       ENDIF
        factor_volume_to_mass =  4.0_wp / 3.0_wp * pi * rho_l
        pirho_l  = pi * rho_l / 6.0_wp
        IF ( weight_factor_split == -1.0_wp )  THEN
-          weight_factor_split = 0.1_wp * initial_weighting_factor 
+          weight_factor_split = 0.1_wp * initial_weighting_factor
        ENDIF
     ENDIF
@@ -6866 +6666 @@
                 new_particles_gb = 0
                 number_of_particles = prt_count(k,j,i)
-                IF ( number_of_particles <= 0  .OR.                            &  
-                     ql(k,j,i) < ql_crit )  CYCLE
+                IF ( number_of_particles <= 0  .OR.  ql(k,j,i) < ql_crit )  CYCLE
                 particles => grid_particles(k,j,i)%particles(1:number_of_particles)
 !
-!--             Start splitting operations. Each particle is checked if it
-!--             fulfilled the splitting criterion's. In splitting mode 'const'   
-!--             a critical radius  (radius_split) a critical weighting factor
-!--             (weight_factor_split) and a splitting factor (splitting_factor)
-!--             must  be prescribed (see particle_parameters). Super droplets 
-!--             which have a larger radius and larger weighting factor are split 
-!--             into 'splitting_factor' super droplets. Therefore, the weighting 
-!--             factor of  the super droplet and all created clones is reduced 
-!--             by the factor of 'splitting_factor'.
+!--             Start splitting operations. Each particle is checked if it fulfilled the splitting
+!--             criterion's. In splitting mode 'const' a critical radius  (radius_split) a critical
+!--             weighting factor (weight_factor_split) and a splitting factor (splitting_factor)
+!--             must be prescribed (see particle_parameters). Super droplets which have a larger
+!--             radius and larger weighting factor are split into 'splitting_factor' super droplets.
+!--             Therefore, the weighting factor of the super droplet and all created clones is
+!--             reduced by the factor of 'splitting_factor'.
                 DO  n = 1, number_of_particles
-                   IF ( particles(n)%particle_mask  .AND.                      &
-                        particles(n)%radius >= radius_split  .AND.             & 
-                        particles(n)%weight_factor >= weight_factor_split )    &
+                   IF ( particles(n)%particle_mask           .AND.                                 &
+                        particles(n)%radius >= radius_split  .AND.                                 &
+                        particles(n)%weight_factor >= weight_factor_split )                        &
                    THEN
 !
@@ -6888 +6685 @@
                       new_size = prt_count(k,j,i) + splitting_factor - 1
 !
-!--                   Cycle if maximum number of particles per grid box
-!--                   is greater than the allowed maximum number.
+!--                   Cycle if maximum number of particles per grid box is greater than the allowed
+!--                   maximum number.
                       IF ( new_size >= max_number_particles_per_gridbox )  CYCLE
 !
-!--                   Reallocate particle array if necessary. 
-                      IF ( new_size > SIZE(particles) )  THEN 
+!--                   Reallocate particle array if necessary.
+                      IF ( new_size > SIZE( particles ) )  THEN
                          CALL realloc_particles_array( i, j, k, new_size )
                       ENDIF
@@ -6899 +6696 @@
 !
 !--                   Calculate new weighting factor.
-                      particles(n)%weight_factor =  & 
-                         particles(n)%weight_factor / splitting_factor
+                      particles(n)%weight_factor = particles(n)%weight_factor / splitting_factor
                       tmp_particle = particles(n)
 !
 !--                   Create splitting_factor-1 new particles.
                       DO  jpp = 1, splitting_factor-1
-                         grid_particles(k,j,i)%particles(jpp+old_size) =       & 
-                            tmp_particle
-                      ENDDO  
+                         grid_particles(k,j,i)%particles(jpp+old_size) = tmp_particle
+                      ENDDO
                       new_particles_gb = new_particles_gb + splitting_factor - 1
-!   
+!
 !--                   Save the new number of super droplets for every grid box.
-                      prt_count(k,j,i) = prt_count(k,j,i) +                    &
-                                         splitting_factor - 1
+                      prt_count(k,j,i) = prt_count(k,j,i) + splitting_factor - 1
                    ENDIF
                 ENDDO
@@ -6920 +6714 @@
        ENDDO
 
-    ELSEIF ( i_splitting_mode == 2 )  THEN 
+    ELSEIF ( i_splitting_mode == 2 )  THEN
 !
 !--    Initialize summing variables.
        lwc          = 0.0_wp
-       lwc_total    = 0.0_wp 
+       lwc_total    = 0.0_wp
        m1           = 0.0_wp
        m1_total     = 0.0_wp
@@ -6942 +6736 @@
              DO  k = nzb+1, nzt
                 number_of_particles = prt_count(k,j,i)
-                IF ( number_of_particles <= 0  .OR.                            & 
-                     ql(k,j,i) < ql_crit )  CYCLE
+                IF ( number_of_particles <= 0  .OR.  ql(k,j,i) < ql_crit )  CYCLE
                 particles => grid_particles(k,j,i)%particles(1:number_of_particles)
                 nrclgb = nrclgb + 1.0_wp
@@ -6949 +6742 @@
 !--             Calculate moments of DSD.
                 DO  n = 1, number_of_particles
-                   IF ( particles(n)%particle_mask  .AND.                      &
-                        particles(n)%radius >= r_min )                         &
+                   IF ( particles(n)%particle_mask  .AND.  particles(n)%radius >= r_min )          &
                    THEN
                       nr  = nr  + particles(n)%weight_factor
-                      rm  = rm  + factor_volume_to_mass  *                     &
-                                 particles(n)%radius**3  *                     &
+                      rm  = rm  + factor_volume_to_mass  *                                         &
+                                 particles(n)%radius**3  *                                         &
                                  particles(n)%weight_factor
-                      IF ( isf == 1 )  THEN           
+                      IF ( isf == 1 )  THEN
                          diameter   = particles(n)%radius * 2.0_wp
-                         lwc = lwc + factor_volume_to_mass *                   &
-                                     particles(n)%radius**3 *                  & 
-                                     particles(n)%weight_factor 
+                         lwc = lwc + factor_volume_to_mass *                                       &
+                                     particles(n)%radius**3 *                                      &
+                                     particles(n)%weight_factor
                          m1  = m1  + particles(n)%weight_factor * diameter
                          m2  = m2  + particles(n)%weight_factor * diameter**2
@@ -6966 +6758 @@
                       ENDIF
                    ENDIF
-                ENDDO 
+                ENDDO
              ENDDO
           ENDDO
@@ -6973 +6765 @@
 #if defined( __parallel )
        IF ( collective_wait )  CALL MPI_BARRIER( comm2d, ierr )
-       CALL MPI_ALLREDUCE( nr, nr_total, 1 , &
-       MPI_REAL, MPI_SUM, comm2d, ierr )
-       CALL MPI_ALLREDUCE( rm, rm_total, 1 , &
-       MPI_REAL, MPI_SUM, comm2d, ierr )
+       CALL MPI_ALLREDUCE( nr, nr_total, 1 , MPI_REAL, MPI_SUM, comm2d, ierr )
+       CALL MPI_ALLREDUCE( rm, rm_total, 1 , MPI_REAL, MPI_SUM, comm2d, ierr )
        IF ( collective_wait )  CALL MPI_BARRIER( comm2d, ierr )
-       CALL MPI_ALLREDUCE( nrclgb, nrclgb_total, 1 , &
-       MPI_REAL, MPI_SUM, comm2d, ierr )
+       CALL MPI_ALLREDUCE( nrclgb, nrclgb_total, 1 , MPI_REAL, MPI_SUM, comm2d, ierr )
        IF ( collective_wait )  CALL MPI_BARRIER( comm2d, ierr )
-       CALL MPI_ALLREDUCE( lwc, lwc_total, 1 , &
-       MPI_REAL, MPI_SUM, comm2d, ierr )
+       CALL MPI_ALLREDUCE( lwc, lwc_total, 1 , MPI_REAL, MPI_SUM, comm2d, ierr )
        IF ( collective_wait )  CALL MPI_BARRIER( comm2d, ierr )
-       CALL MPI_ALLREDUCE( m1, m1_total, 1 , &
-       MPI_REAL, MPI_SUM, comm2d, ierr )
+       CALL MPI_ALLREDUCE( m1, m1_total, 1 , MPI_REAL, MPI_SUM, comm2d, ierr )
        IF ( collective_wait )  CALL MPI_BARRIER( comm2d, ierr )
-       CALL MPI_ALLREDUCE( m2, m2_total, 1 , &
-       MPI_REAL, MPI_SUM, comm2d, ierr )
+       CALL MPI_ALLREDUCE( m2, m2_total, 1 , MPI_REAL, MPI_SUM, comm2d, ierr )
        IF ( collective_wait )  CALL MPI_BARRIER( comm2d, ierr )
-       CALL MPI_ALLREDUCE( m3, m3_total, 1 , &
-       MPI_REAL, MPI_SUM, comm2d, ierr )
-#endif 
+       CALL MPI_ALLREDUCE( m3, m3_total, 1 , MPI_REAL, MPI_SUM, comm2d, ierr )
+#endif
 
 !
 !--    Calculate number concentration and mean volume averaged radius.
-       nr_total = MERGE( nr_total / nrclgb_total,                              &
-                         0.0_wp, nrclgb_total > 0.0_wp                         &
-                       )
-       rm_total = MERGE( ( rm_total /                                          &
-                            ( nr_total * factor_volume_to_mass )               &
-                          )**0.3333333_wp, 0.0_wp, nrclgb_total > 0.0_wp       &
+       nr_total = MERGE( nr_total / nrclgb_total, 0.0_wp, nrclgb_total > 0.0_wp )
+       rm_total = MERGE( ( rm_total / ( nr_total * factor_volume_to_mass ) )**0.3333333_wp, 0.0_wp,&
+                          nrclgb_total > 0.0_wp                                                    &
                        )
 !
 !--    Check which function should be used to approximate the DSD.
        IF ( isf == 1 )  THEN
-          lwc_total = MERGE( lwc_total / nrclgb_total,                         &
-                             0.0_wp, nrclgb_total > 0.0_wp                     &
-                           )
-          m1_total  = MERGE( m1_total / nrclgb_total,                          &
-                             0.0_wp, nrclgb_total > 0.0_wp                     &
-                           )
-          m2_total  = MERGE( m2_total / nrclgb_total,                          &
-                             0.0_wp, nrclgb_total > 0.0_wp                     &
-                           )
-          m3_total  = MERGE( m3_total / nrclgb_total,                          &
-                             0.0_wp, nrclgb_total > 0.0_wp                     &
-                           )
+          lwc_total = MERGE( lwc_total / nrclgb_total, 0.0_wp, nrclgb_total > 0.0_wp )
+          m1_total  = MERGE( m1_total  / nrclgb_total, 0.0_wp, nrclgb_total > 0.0_wp )
+          m2_total  = MERGE( m2_total  / nrclgb_total, 0.0_wp, nrclgb_total > 0.0_wp )
+          m3_total  = MERGE( m3_total  / nrclgb_total, 0.0_wp, nrclgb_total > 0.0_wp )
           zeta = m1_total * m3_total / m2_total**2
-          mu   = MAX( ( ( 1.0_wp - zeta ) * 2.0_wp + 1.0_wp ) /                &
-                        ( zeta - 1.0_wp ), 0.0_wp                              &
-                    )
-
-          lambda = ( pirho_l * nr_total / lwc_total *                          &
-                     ( mu + 3.0_wp ) * ( mu + 2.0_wp ) * ( mu + 1.0_wp )       &
+          mu   = MAX( ( ( 1.0_wp - zeta ) * 2.0_wp + 1.0_wp ) / ( zeta - 1.0_wp ), 0.0_wp )
+
+          lambda = ( pirho_l * nr_total / lwc_total *                                              &
+                     ( mu + 3.0_wp ) * ( mu + 2.0_wp ) * ( mu + 1.0_wp )                           &
                    )**0.3333333_wp
-          nr0 = nr_total / gamma( mu + 1.0_wp ) * lambda**( mu + 1.0_wp ) 
+          nr0 = nr_total / gamma( mu + 1.0_wp ) * lambda**( mu + 1.0_wp )
 
           DO  n = 0, n_max-1
              diameter  = r_bin_mid(n) * 2.0_wp
-             an_spl(n) = nr0 * diameter**mu * EXP( -lambda * diameter ) *      & 
-                         ( r_bin(n+1) - r_bin(n) ) * 2.0_wp 
+             an_spl(n) = nr0 * diameter**mu * EXP( -lambda * diameter ) *                          &
+                         ( r_bin(n+1) - r_bin(n) ) * 2.0_wp
           ENDDO
        ELSEIF ( isf == 2 )  THEN
           DO  n = 0, n_max-1
-             an_spl(n) = nr_total / ( SQRT( 2.0_wp * pi ) *                    &
-                                     LOG(sigma_log) * r_bin_mid(n)             &
-                                     ) *                                       &
-                         EXP( -( LOG( r_bin_mid(n) / rm_total )**2 ) /         &
-                               ( 2.0_wp * LOG(sigma_log)**2 )                  & 
-                             ) *                                               & 
+             an_spl(n) = nr_total / ( SQRT( 2.0_wp * pi ) * LOG(sigma_log) * r_bin_mid(n) ) *      &
+                         EXP( -( LOG( r_bin_mid(n) / rm_total )**2 ) /                             &
+                               ( 2.0_wp * LOG(sigma_log)**2 )                                      &
+                            ) *                                                                    &
                          ( r_bin(n+1) - r_bin(n) )
           ENDDO
        ELSEIF( isf == 3 )  THEN
-          DO  n = 0, n_max-1 
-             an_spl(n) = 3.0_wp * nr_total * r_bin_mid(n)**2 / rm_total**3  *  &
-                         EXP( - ( r_bin_mid(n)**3 / rm_total**3 ) )         *  &
+          DO  n = 0, n_max-1
+             an_spl(n) = 3.0_wp * nr_total * r_bin_mid(n)**2 / rm_total**3  *                      &
+                         EXP( -( r_bin_mid(n)**3 / rm_total**3 ) )          *                      &
                          ( r_bin(n+1) - r_bin(n) )
           ENDDO
@@ -7058 +6828 @@
              DO  k = nzb+1, nzt
                 number_of_particles = prt_count(k,j,i)
-                IF ( number_of_particles <= 0  .OR.                            &
-                     ql(k,j,i) < ql_crit )  CYCLE
+                IF ( number_of_particles <= 0  .OR.  ql(k,j,i) < ql_crit )  CYCLE
                 particles => grid_particles(k,j,i)%particles(1:number_of_particles)
                 new_particles_gb = 0
 !
-!--             Start splitting operations. Each particle is checked if it
-!--             fulfilled the splitting criterion's. In splitting mode 'cl_av'
-!--             a critical radius (radius_split) and a splitting function must
-!--             be prescribed (see particles_par). The critical weighting factor
-!--             is calculated while approximating a 'gamma', 'log' or 'exp'-
-!--             drop size distribution. In this mode the DSD is calculated as
-!--             an average over all cloudy grid boxes. Super droplets which
-!--             have a larger radius and larger weighting factor are split into
-!--             'splitting_factor' super droplets. In this case the splitting
-!--             factor is calculated of weighting factor of the super droplet
-!--             and the approximated number concentration for droplet of such
-!--             a size. Due to the splitting, the weighting factor of the
-!--             super droplet and all created clones is reduced by the factor
-!--             of 'splitting_facor'.
+!--             Start splitting operations. Each particle is checked if it fulfilled the splitting
+!--             criterion's. In splitting mode 'cl_av' a critical radius (radius_split) and a
+!--             splitting function must be prescribed (see particles_par). The critical weighting
+!--             factor is calculated while approximating a 'gamma', 'log' or 'exp'- drop size
+!--             distribution. In this mode the DSD is calculated as an average over all cloudy grid
+!--             boxes. Super droplets which have a larger radius and larger weighting factor are
+!--             split into 'splitting_factor' super droplets. In this case the splitting factor is
+!--             calculated of weighting factor of the super droplet and the approximated number
+!--             concentration for droplet of such a size. Due to the splitting, the weighting factor
+!--             of the super droplet and all created clones is reduced by the factor of
+!--             'splitting_facor'.
                 DO  n = 1, number_of_particles
                    DO  np = 0, n_max-1
-                      IF ( r_bin(np) >= radius_split  .AND.                    &
-                           particles(n)%particle_mask  .AND.                   &
-                           particles(n)%radius >= r_bin(np)  .AND.             &
-                           particles(n)%radius < r_bin(np+1)  .AND.            &
-                           particles(n)%weight_factor >= an_spl(np)  )         &
+                      IF ( r_bin(np) >= radius_split          .AND.                                &
+                           particles(n)%particle_mask         .AND.                                &
+                           particles(n)%radius >= r_bin(np)   .AND.                                &
+                           particles(n)%radius < r_bin(np+1)  .AND.                                &
+                           particles(n)%weight_factor >= an_spl(np)  )                             &
                       THEN
 !
 !--                      Calculate splitting factor
-                         splitting_factor =                                    & 
-                             MIN( INT( particles(n)%weight_factor /            &
-                                        an_spl(np)                             &
-                                     ), splitting_factor_max                   &
-                                )
+                         splitting_factor = MIN( INT( particles(n)%weight_factor /                 &
+                                                       an_spl(np)                                  &
+                                                    ), splitting_factor_max                        &
+                                               )
                          IF ( splitting_factor < 2 )  CYCLE
 !
@@ -7097 +6862 @@
                          new_size = prt_count(k,j,i) + splitting_factor - 1
 !
-!--                      Cycle if maximum number of particles per grid box
-!--                      is greater than the allowed maximum number.
-                         IF ( new_size >= max_number_particles_per_gridbox )   & 
-                         CYCLE
-!
-!--                      Reallocate particle array if necessary. 
-                         IF ( new_size > SIZE(particles) )  THEN 
+!--                      Cycle if maximum number of particles per grid box is greater than the
+!--                      allowed maximum number.
+                         IF ( new_size >= max_number_particles_per_gridbox )  CYCLE
+!
+!--                      Reallocate particle array if necessary.
+                         IF ( new_size > SIZE( particles ) )  THEN
                             CALL realloc_particles_array( i, j, k, new_size )
                          ENDIF
                          old_size  = prt_count(k,j,i)
-                         new_particles_gb = new_particles_gb +                 &
-                                            splitting_factor - 1
+                         new_particles_gb = new_particles_gb + splitting_factor - 1
 !
 !--                      Calculate new weighting factor.
-                         particles(n)%weight_factor =                          & 
-                            particles(n)%weight_factor / splitting_factor
+                         particles(n)%weight_factor = particles(n)%weight_factor / splitting_factor
                          tmp_particle = particles(n)
 !
 !--                      Create splitting_factor-1 new particles.
                          DO  jpp = 1, splitting_factor-1
-                            grid_particles(k,j,i)%particles(jpp+old_size) =    &
-                                                                    tmp_particle
+                            grid_particles(k,j,i)%particles(jpp+old_size) = tmp_particle
                          ENDDO
 !
-!--                      Save the new number of super droplets. 
-                         prt_count(k,j,i) = prt_count(k,j,i) +                 &
-                                            splitting_factor - 1
+!--                      Save the new number of super droplets.
+                         prt_count(k,j,i) = prt_count(k,j,i) + splitting_factor - 1
                       ENDIF
                    ENDDO
-                ENDDO 
+                ENDDO
 
              ENDDO
@@ -7132 +6892 @@
        ENDDO
 
-    ELSEIF ( i_splitting_mode == 3 )  THEN 
+    ELSEIF ( i_splitting_mode == 3 )  THEN
 
        DO  i = nxl, nxr
@@ -7145 +6905 @@
                 m3  = 0.0_wp
                 nr  = 0.0_wp
-                rm  = 0.0_wp  
+                rm  = 0.0_wp
 
                 new_particles_gb = 0
                 number_of_particles = prt_count(k,j,i)
-                IF ( number_of_particles <= 0  .OR.                            & 
-                     ql(k,j,i) < ql_crit )  CYCLE
+                IF ( number_of_particles <= 0  .OR.  ql(k,j,i) < ql_crit )  CYCLE
                 particles => grid_particles(k,j,i)%particles
 !
 !--             Calculate moments of DSD.
                 DO  n = 1, number_of_particles
-                   IF ( particles(n)%particle_mask  .AND.                      &
-                        particles(n)%radius >= r_min )                         &
+                   IF ( particles(n)%particle_mask  .AND.  particles(n)%radius >= r_min )          &
                    THEN
                       nr  = nr + particles(n)%weight_factor
-                      rm  = rm + factor_volume_to_mass  *                      &
-                                 particles(n)%radius**3  *                     &
+                      rm  = rm + factor_volume_to_mass  *                                          &
+                                 particles(n)%radius**3  *                                         &
                                  particles(n)%weight_factor
                       IF ( isf == 1 )  THEN
                          diameter   = particles(n)%radius * 2.0_wp
-                         lwc = lwc + factor_volume_to_mass *                   &
-                                     particles(n)%radius**3 *                  &
-                                     particles(n)%weight_factor 
+                         lwc = lwc + factor_volume_to_mass *                                       &
+                                     particles(n)%radius**3 *                                      &
+                                     particles(n)%weight_factor
                          m1  = m1 + particles(n)%weight_factor * diameter
                          m2  = m2 + particles(n)%weight_factor * diameter**2
@@ -7182 +6940 @@
                 IF ( isf == 1 )  THEN
 !
-!--                Gamma size distribution to calculate  
+!--                Gamma size distribution to calculate
 !--                critical weight_factor (e.g. Marshall + Palmer, 1948).
                    zeta = m1 * m3 / m2**2
-                   mu   = MAX( ( ( 1.0_wp - zeta ) * 2.0_wp + 1.0_wp ) /       &
-                                ( zeta - 1.0_wp ), 0.0_wp                      &
-                             )   
-                   lambda = ( pirho_l * nr / lwc *                             &
-                              ( mu + 3.0_wp ) * ( mu + 2.0_wp ) *              &
-                              ( mu + 1.0_wp )                                  &
+                   mu   = MAX( ( ( 1.0_wp - zeta ) * 2.0_wp + 1.0_wp ) / ( zeta - 1.0_wp ), 0.0_wp )
+                   lambda = ( pirho_l * nr / lwc *                                                 &
+                              ( mu + 3.0_wp ) * ( mu + 2.0_wp ) * ( mu + 1.0_wp )                  &
                             )**0.3333333_wp
-                   nr0 =  ( nr / (gamma( mu + 1.0_wp ) ) ) *                   &
-                          lambda**( mu + 1.0_wp ) 
+                   nr0 =  ( nr / (gamma( mu + 1.0_wp ) ) ) *                                       &
+                          lambda**( mu + 1.0_wp )
 
                    DO  n = 0, n_max-1
                       diameter         = r_bin_mid(n) * 2.0_wp
-                      an_spl(n) = nr0 * diameter**mu *                         &
-                                  EXP( -lambda * diameter ) *                  & 
-                                  ( r_bin(n+1) - r_bin(n) ) * 2.0_wp 
+                      an_spl(n) = nr0 * diameter**mu *                                             &
+                                  EXP( -lambda * diameter ) *                                      &
+                                  ( r_bin(n+1) - r_bin(n) ) * 2.0_wp
                    ENDDO
                 ELSEIF ( isf == 2 )  THEN
 !
-!--                Lognormal size distribution to calculate critical 
+!--                Lognormal size distribution to calculate critical
 !--                weight_factor (e.g. Levin, 1971, Bradley + Stow, 1974).
                    DO  n = 0, n_max-1
-                      an_spl(n) = nr / ( SQRT( 2.0_wp * pi ) *                 &
-                                              LOG(sigma_log) * r_bin_mid(n)    &
-                                        ) *                                    &
-                                  EXP( -( LOG( r_bin_mid(n) / rm )**2 ) /      &
-                                        ( 2.0_wp * LOG(sigma_log)**2 )         &
-                                      ) *                                      &
+                      an_spl(n) = nr / ( SQRT( 2.0_wp * pi ) *                                     &
+                                              LOG(sigma_log) * r_bin_mid(n)                        &
+                                       ) *                                                         &
+                                  EXP( -( LOG( r_bin_mid(n) / rm )**2 ) /                          &
+                                        ( 2.0_wp * LOG(sigma_log)**2 )                             &
+                                     ) *                                                           &
                                   ( r_bin(n+1) - r_bin(n) )
                    ENDDO
                 ELSEIF ( isf == 3 )  THEN
 !
-!--                Exponential size distribution to calculate critical 
-!--                weight_factor (e.g. Berry + Reinhardt, 1974).  
+!--                Exponential size distribution to calculate critical weight_factor
+!--                (e.g. Berry + Reinhardt, 1974).
                    DO  n = 0, n_max-1
-                      an_spl(n) = 3.0_wp * nr * r_bin_mid(n)**2 / rm**3 *     &
-                                  EXP( - ( r_bin_mid(n)**3 / rm**3 ) ) *      &
+                      an_spl(n) = 3.0_wp * nr * r_bin_mid(n)**2 / rm**3 *                          &
+                                  EXP( - ( r_bin_mid(n)**3 / rm**3 ) ) *                           &
                                   ( r_bin(n+1) - r_bin(n) )
                    ENDDO
@@ -7229 +6984 @@
                 an_spl = MAX(an_spl, 1.0_wp)
 !
-!--             Start splitting operations. Each particle is checked if it
-!--             fulfilled the splitting criterion's. In splitting mode 'gb_av'
-!--             a critical radius (radius_split) and a splitting function must 
-!--             be prescribed (see particles_par). The critical weighting factor
-!--             is calculated while appoximating a 'gamma', 'log' or 'exp'-
-!--             drop size distribution. In this mode a DSD is calculated for 
-!--             every cloudy grid box. Super droplets which have a larger 
-!--             radius and larger weighting factor are split into
-!--             'splitting_factor' super droplets. In this case the splitting  
-!--             factor is calculated of weighting factor of the super droplet  
-!--             and theapproximated number concentration for droplet of such 
-!--             a size. Due to the splitting, the weighting factor of the  
-!--             super droplet and all created clones is reduced by the factor  
-!--             of 'splitting_facor'.
+!--             Start splitting operations. Each particle is checked if it fulfilled the splitting
+!--             criterions. In splitting mode 'gb_av' a critical radius (radius_split) and a
+!--             splitting function must be prescribed (see particles_par). The critical weighting
+!--             factor is calculated while appoximating a 'gamma', 'log' or 'exp'-drop size
+!--             distribution. In this mode a DSD is calculated for every cloudy grid box. Super
+!--             droplets which have a larger radius and larger weighting factor are split into
+!--             'splitting_factor' super droplets. In this case the splitting factor is calculated
+!--             by the weighting factor of the super droplet  and the approximated number
+!--             concentration for droplets of such size. Due to the splitting, the weighting factor
+!--             of the super droplet and all created clones are reduced by the factor  of
+!--             'splitting_facor'.
                 DO  n = 1, number_of_particles
                    DO  np = 0, n_max-1
-                      IF ( r_bin(np) >= radius_split  .AND.                    &
-                           particles(n)%particle_mask  .AND.                   &
-                           particles(n)%radius >= r_bin(np)    .AND.           &
-                           particles(n)%radius < r_bin(np+1)   .AND.           &
-                           particles(n)%weight_factor >= an_spl(np) )          &
+                      IF ( r_bin(np) >= radius_split           .AND.                               &
+                           particles(n)%particle_mask          .AND.                               &
+                           particles(n)%radius >= r_bin(np)    .AND.                               &
+                           particles(n)%radius < r_bin(np+1)   .AND.                               &
+                           particles(n)%weight_factor >= an_spl(np) )                              &
                       THEN
 !
 !--                      Calculate splitting factor.
-                         splitting_factor =                                    & 
-                             MIN( INT( particles(n)%weight_factor /            &
-                                        an_spl(np)                             &
-                                     ), splitting_factor_max                   &
-                                )
+                         splitting_factor = MIN( INT( particles(n)%weight_factor / an_spl(np) ),   &
+                                                 splitting_factor_max                              &
+                                               )
                          IF ( splitting_factor < 2 )  CYCLE
 
@@ -7266 +7016 @@
 !--                      Cycle if maximum number of particles per grid box
 !--                      is greater than the allowed maximum number.
-                         IF ( new_size >= max_number_particles_per_gridbox )   &
-                         CYCLE
+                         IF ( new_size >= max_number_particles_per_gridbox )  CYCLE
 !
 !--                      Reallocate particle array if necessary.
-                         IF ( new_size > SIZE(particles) )  THEN 
+                         IF ( new_size > SIZE( particles ) )  THEN
                             CALL realloc_particles_array( i, j, k, new_size )
                          ENDIF
 !
 !--                      Calculate new weighting factor.
-                         particles(n)%weight_factor = & 
-                            particles(n)%weight_factor / splitting_factor
+                         particles(n)%weight_factor = particles(n)%weight_factor / splitting_factor
                          tmp_particle               = particles(n)
                          old_size                   = prt_count(k,j,i)
@@ -7282 +7030 @@
 !--                      Create splitting_factor-1 new particles.
                          DO  jpp = 1, splitting_factor-1
-                            grid_particles(k,j,i)%particles( jpp + old_size ) = &
-                               tmp_particle
+                            grid_particles(k,j,i)%particles( jpp + old_size ) = tmp_particle
                          ENDDO
 !
 !--                      Save the new number of droplets for every grid box.
-                         prt_count(k,j,i)    = prt_count(k,j,i) +              &
-                                               splitting_factor - 1
-                         new_particles_gb    = new_particles_gb +              &
-                                               splitting_factor - 1
+                         prt_count(k,j,i)    = prt_count(k,j,i) + splitting_factor - 1
+                         new_particles_gb    = new_particles_gb + splitting_factor - 1
                       ENDIF
                    ENDDO
@@ -7302 +7047 @@
 
  END SUBROUTINE lpm_splitting
- 
-
-!------------------------------------------------------------------------------!
+
+
+!--------------------------------------------------------------------------------------------------!
 ! Description:
 ! ------------
-! This routine is a part of the Lagrangian particle model. Two Super droplets 
-! which fulfill certain criterion's (e.g. a big weighting factor and a small
-! radius) can be merged into one super droplet with a increased number of 
-! represented particles of the super droplet. This mechanism ensures an
-! improved a feasible amount of computational costs. The limits of particle 
-! creation should be chosen carefully! The idea of this algorithm is based on 
-! Unterstrasser and Soelch, 2014. 
-!------------------------------------------------------------------------------!
+! This routine is a part of the Lagrangian particle model. Two Super droplets which fulfill certain
+! criterions (e.g. a big weighting factor and a small radius) can be merged into one super droplet
+! with a increased number of represented particles of the super droplet. This mechanism ensures an
+! improved feasible amount of computational costs. The limits of particle creation should be chosen
+! carefully! The idea of this algorithm is based on Unterstrasser and Soelch, 2014.
+!--------------------------------------------------------------------------------------------------!
  SUBROUTINE lpm_merging
 
@@ -7324 +7067 @@
 
 
-    REAL(wp) ::  ql_crit = 1.0E-5_wp  !< threshold lwc for cloudy grid cells 
+    REAL(wp) ::  ql_crit = 1.0E-5_wp  !< threshold lwc for cloudy grid cells
                                       !< (e.g. Siebesma et al 2003, JAS, 60)
 
@@ -7332 +7075 @@
 
     IF ( weight_factor_merge == -1.0_wp )  THEN
-       weight_factor_merge = 0.5_wp * initial_weighting_factor 
+       weight_factor_merge = 0.5_wp * initial_weighting_factor
     ENDIF
 
@@ -7340 +7083 @@
 
              number_of_particles = prt_count(k,j,i)
-             IF ( number_of_particles <= 0  .OR.                               &
-                   ql(k,j,i) >= ql_crit )  CYCLE
+             IF ( number_of_particles <= 0  .OR.  ql(k,j,i) >= ql_crit )  CYCLE
              particles => grid_particles(k,j,i)%particles(1:number_of_particles)
 !
-!--          Start merging operations: This routine delete super droplets with
-!--          a small radius (radius <= radius_merge) and a low weighting 
-!--          factor (weight_factor  <= weight_factor_merge). The number of 
-!--          represented particles will be added to the next particle of the 
-!--          particle array. Tests showed that this simplified method can be 
-!--          used because it will only take place outside of cloudy grid 
-!--          boxes where ql <= 1.0E-5 kg/kg. Therefore, especially former cloned
-!--          and subsequent evaporated super droplets will be merged.
+!--          Start merging operations: This routine deletes super droplets with a small radius
+!--          (radius <= radius_merge) and a low weighting factor (weight_factor  <=
+!--          weight_factor_merge). The number of represented particles will be added to the next
+!--          particle of the particle array. Tests showed that this simplified method can be used
+!--          because it will only take place outside of cloudy grid boxes where ql <= 1.0E-5 kg/kg.
+!--          Therefore, especially former cloned and subsequent evaporated super droplets will be
+!--          merged.
              DO  n = 1, number_of_particles-1
-                IF ( particles(n)%particle_mask                    .AND.       &
-                     particles(n+1)%particle_mask                  .AND.       &
-                     particles(n)%radius        <= radius_merge    .AND.       &
-                     particles(n)%weight_factor <= weight_factor_merge )       &
+                IF ( particles(n)%particle_mask                    .AND.                           &
+                     particles(n+1)%particle_mask                  .AND.                           &
+                     particles(n)%radius        <= radius_merge    .AND.                           &
+                     particles(n)%weight_factor <= weight_factor_merge )                           &
                 THEN
-                   particles(n+1)%weight_factor  =                             &
-                                       particles(n+1)%weight_factor +          &
-                                       ( particles(n)%radius**3     /          &
-                                         particles(n+1)%radius**3   *          &
-                                         particles(n)%weight_factor            &
-                                       )
+                   particles(n+1)%weight_factor  = particles(n+1)%weight_factor +                  &
+                                                   ( particles(n)%radius**3     /                  &
+                                                     particles(n+1)%radius**3   *                  &
+                                                     particles(n)%weight_factor                    &
+                                                   )
                    particles(n)%particle_mask = .FALSE.
-                   deleted_particles          = deleted_particles + 1 
+                   deleted_particles          = deleted_particles + 1
                    merge_drp                  = merge_drp + 1
 
@@ -7379 +7119 @@
  END SUBROUTINE lpm_merging
 
- 
-
- 
-!------------------------------------------------------------------------------!
+
+
+
+!--------------------------------------------------------------------------------------------------!
 ! Description:
 ! ------------
 !> Exchange between subdomains.
-!> As soon as one particle has moved beyond the boundary of the domain, it
-!> is included in the relevant transfer arrays and marked for subsequent
-!> deletion on this PE.
-!> First sweep for crossings in x direction. Find out first the number of
-!> particles to be transferred and allocate temporary arrays needed to store
-!> them.
-!> For a one-dimensional decomposition along y, no transfer is necessary,
-!> because the particle remains on the PE, but the particle coordinate has to
-!> be adjusted.
-!------------------------------------------------------------------------------!
+!> As soon as one particle has moved beyond the boundary of the domain, it is included in the
+!> relevant transfer arrays and marked for subsequent deletion on this PE.
+!> First sweep for crossings in x direction. Find out first the number of particles to be
+!> transferred and allocate temporary arrays needed to store them.
+!> For a one-dimensional decomposition along y, no transfer is necessary, because the particle
+!> remains on the PE, but the particle coordinate has to be adjusted.
+!--------------------------------------------------------------------------------------------------!
  SUBROUTINE lpm_exchange_horiz
 
@@ -7401 +7138 @@
     INTEGER(iwp) ::  jp                !< index variable along y
     INTEGER(iwp) ::  kp                !< index variable along z
-    INTEGER(iwp) ::  n                 !< particle index variable 
+    INTEGER(iwp) ::  n                 !< particle index variable
 
 #if defined( __parallel )
@@ -7432 +7169 @@
 !
 !-- Exchange between subdomains.
-!-- As soon as one particle has moved beyond the boundary of the domain, it
-!-- is included in the relevant transfer arrays and marked for subsequent
-!-- deletion on this PE.
-!-- First sweep for crossings in x direction. Find out first the number of
-!-- particles to be transferred and allocate temporary arrays needed to store
-!-- them.
-!-- For a one-dimensional decomposition along y, no transfer is necessary,
-!-- because the particle remains on the PE, but the particle coordinate has to
-!-- be adjusted.
+!-- As soon as one particle has moved beyond the boundary of the domain, it is included in the
+!-- relevant transfer arrays and marked for subsequent deletion on this PE.
+!-- First sweep for crossings in x direction. Find out first the number of particles to be
+!-- transferred and allocate temporary arrays needed to store them.
+!-- For a one-dimensional decomposition along y, no transfer is necessary, because the particle
+!-- remains on the PE, but the particle coordinate has to be adjusted.
     trlp_count  = 0
     trrp_count  = 0
@@ -7449 +7183 @@
     IF ( pdims(1) /= 1 )  THEN
 !
-!--    First calculate the storage necessary for sending and receiving the data.
-!--    Compute only first (nxl) and last (nxr) loop iterration.
+!--    First calculate the storage necessary for sending and receiving the data. Compute only first
+!--    (nxl) and last (nxr) loop iterration.
        DO  ip = nxl, nxr, nxr - nxl
           DO  jp = nys, nyn
@@ -7499 +7233 @@
              DO  n = 1, number_of_particles
 !
-!--             Only those particles that have not been marked as 'deleted' may
-!--             be moved.
+!--             Only those particles that have not been marked as 'deleted' may be moved.
                 IF ( particles(n)%particle_mask )  THEN
 
@@ -7551 +7284 @@
                       ELSE
 !
-!--                      Store particle data in the transfer array, which will be 
-!--                      send to the neighbouring PE
+!--                      Store particle data in the transfer array, which will be send to the
+!--                      neighbouring PE
                          trlp_count = trlp_count + 1
                          trlp(trlp_count) = particles(n)
@@ -7569 +7302 @@
                             IF ( pdims(1) == 1 )  THEN
                                particles(n)%x = particles(n)%x - ( nx + 1 ) * dx
-                               particles(n)%origin_x = particles(n)%origin_x - &
-                               ( nx + 1 ) * dx
+                               particles(n)%origin_x = particles(n)%origin_x - ( nx + 1 ) * dx
                             ELSE
                                trrp_count = trrp_count + 1
                                trrp(trrp_count) = particles(n)
                                trrp(trrp_count)%x = trrp(trrp_count)%x - ( nx + 1 ) * dx
-                               trrp(trrp_count)%origin_x = trrp(trrp_count)%origin_x - &
-                               ( nx + 1 ) * dx
+                               trrp(trrp_count)%origin_x = trrp(trrp_count)%origin_x -             &
+                                                           ( nx + 1 ) * dx
                                particles(n)%particle_mask = .FALSE.
                                deleted_particles = deleted_particles + 1
@@ -7597 +7329 @@
                       ELSE
 !
-!--                      Store particle data in the transfer array, which will be send
-!--                      to the neighbouring PE
+!--                      Store particle data in the transfer array, which will be send to the
+!--                      neighbouring PE
                          trrp_count = trrp_count + 1
                          trrp(trrp_count) = particles(n)
@@ -7615 +7347 @@
 
 !
-!-- STORAGE_SIZE returns the storage size of argument A in bits. However , it 
+!-- STORAGE_SIZE returns the storage size of argument A in bits. However , it
 !-- is needed in bytes. The function C_SIZEOF which produces this value directly
 !-- causes problems with gfortran. For this reason the use of C_SIZEOF is avoided
-    par_size = STORAGE_SIZE(trlp(1))/8
-
-
-!
-!-- Allocate arrays required for north-south exchange, as these
-!-- are used directly after particles are exchange along x-direction.
-    ALLOCATE( move_also_north(1:NR_2_direction_move) )
-    ALLOCATE( move_also_south(1:NR_2_direction_move) )
+    par_size = STORAGE_SIZE( trlp(1) ) / 8
+
+
+!
+!-- Allocate arrays required for north-south exchange, as these are used directly after particles
+!-- are exchange along x-direction.
+    ALLOCATE( move_also_north(1:nr_2_direction_move) )
+    ALLOCATE( move_also_south(1:nr_2_direction_move) )
 
     nr_move_north = 0
     nr_move_south = 0
 !
-!-- Send left boundary, receive right boundary (but first exchange how many
-!-- and check, if particle storage must be extended)
+!-- Send left boundary, receive right boundary (but first exchange how many and check, if particle
+!-- storage must be extended)
     IF ( pdims(1) /= 1 )  THEN
 
-       CALL MPI_SENDRECV( trlp_count,      1, MPI_INTEGER, pleft,  0, &
-                          trrp_count_recv, 1, MPI_INTEGER, pright, 0, &
+       CALL MPI_SENDRECV( trlp_count,      1, MPI_INTEGER, pleft,  0,                              &
+                          trrp_count_recv, 1, MPI_INTEGER, pright, 0,                              &
                           comm2d, status, ierr )
 
        ALLOCATE(rvrp(MAX(1,trrp_count_recv)))
 
-       CALL MPI_SENDRECV( trlp, max(1,trlp_count)*par_size, MPI_BYTE,&
-                          pleft, 1, rvrp,                            &
-                          max(1,trrp_count_recv)*par_size, MPI_BYTE, pright, 1,&
+       CALL MPI_SENDRECV( trlp, MAX(1,trlp_count)*par_size,      MPI_BYTE, pleft, 1,               &
+                          rvrp, MAX(1,trrp_count_recv)*par_size, MPI_BYTE, pright, 1,              &
                           comm2d, status, ierr )
 
@@ -7651 +7382 @@
 !
 !--    Send right boundary, receive left boundary
-       CALL MPI_SENDRECV( trrp_count,      1, MPI_INTEGER, pright, 0, &
-                          trlp_count_recv, 1, MPI_INTEGER, pleft,  0, &
+       CALL MPI_SENDRECV( trrp_count,      1, MPI_INTEGER, pright, 0,                              &
+                          trlp_count_recv, 1, MPI_INTEGER, pleft,  0,                              &
                           comm2d, status, ierr )
 
        ALLOCATE(rvlp(MAX(1,trlp_count_recv)))
 !
-!--    This MPI_SENDRECV should work even with odd mixture on 32 and 64 Bit 
-!--    variables in structure particle_type (due to the calculation of par_size)
-       CALL MPI_SENDRECV( trrp, max(1,trrp_count)*par_size, MPI_BYTE,&
-                          pright, 1, rvlp,                           &
-                          max(1,trlp_count_recv)*par_size, MPI_BYTE, pleft, 1, &
+!--    This MPI_SENDRECV should work even with odd mixture on 32 and 64 Bit variables in structure
+!--    particle_type (due to the calculation of par_size)
+       CALL MPI_SENDRECV( trrp, MAX(1,trrp_count)*par_size,      MPI_BYTE, pright, 1,              &
+                          rvlp, MAX(1,trlp_count_recv)*par_size, MPI_BYTE,  pleft, 1,              &
                           comm2d, status, ierr )
 
@@ -7672 +7402 @@
 
 !
-!-- Check whether particles have crossed the boundaries in y direction. Note 
-!-- that this case can also apply to particles that have just been received
-!-- from the adjacent right or left PE.
-!-- Find out first the number of particles to be transferred and allocate
-!-- temporary arrays needed to store them.
-!-- For a one-dimensional decomposition along y, no transfer is necessary,
-!-- because the particle remains on the PE.
+!-- Check whether particles have crossed the boundaries in y direction. Note that this case can also
+!-- apply to particles that have just been received from the adjacent right or left PE.
+!-- Find out first the number of particles to be transferred and allocate temporary arrays needed to
+!-- store them.
+!-- For a one-dimensional decomposition along y, no transfer is necessary, because the particle
+!-- remains on the PE.
     trsp_count  = nr_move_south
     trnp_count  = nr_move_north
@@ -7687 +7416 @@
     IF ( pdims(2) /= 1 )  THEN
 !
-!--    First calculate the storage necessary for sending and receiving the
-!--    data
+!--    First calculate the storage necessary for sending and receiving the data
        DO  ip = nxl, nxr
           DO  jp = nys, nyn, nyn-nys    !compute only first (nys) and last (nyn) loop iterration
@@ -7737 +7465 @@
              DO  n = 1, number_of_particles
 !
-!--             Only those particles that have not been marked as 'deleted' may
-!--             be moved.
+!--             Only those particles that have not been marked as 'deleted' may be moved.
                 IF ( particles(n)%particle_mask )  THEN
 
@@ -7755 +7482 @@
                             IF ( pdims(2) == 1 )  THEN
                                particles(n)%y = ( ny + 1 ) * dy + particles(n)%y
-                               particles(n)%origin_y = ( ny + 1 ) * dy + &
-                                                     particles(n)%origin_y
+                               particles(n)%origin_y = ( ny + 1 ) * dy + particles(n)%origin_y
                             ELSE
                                trsp_count         = trsp_count + 1
                                trsp(trsp_count)   = particles(n)
-                               trsp(trsp_count)%y = ( ny + 1 ) * dy + &
-                                                 trsp(trsp_count)%y
-                               trsp(trsp_count)%origin_y = trsp(trsp_count)%origin_y &
-                                                + ( ny + 1 ) * dy
+                               trsp(trsp_count)%y = ( ny + 1 ) * dy + trsp(trsp_count)%y
+                               trsp(trsp_count)%origin_y = trsp(trsp_count)%origin_y               &
+                                                           + ( ny + 1 ) * dy
                                particles(n)%particle_mask = .FALSE.
                                deleted_particles = deleted_particles + 1
@@ -7770 +7495 @@
                                   trsp(trsp_count)%y = trsp(trsp_count)%y - 1.0E-10_wp
                                   !++ why is 1 subtracted in next statement???
-                                  trsp(trsp_count)%origin_y =                        &
-                                                  trsp(trsp_count)%origin_y - 1
+                                  trsp(trsp_count)%origin_y = trsp(trsp_count)%origin_y - 1
                                ENDIF
 
@@ -7791 +7515 @@
                       ELSE
 !
-!--                      Store particle data in the transfer array, which will 
-!--                      be send to the neighbouring PE
+!--                      Store particle data in the transfer array, which will be send to the
+!--                      neighbouring PE
                          trsp_count = trsp_count + 1
                          trsp(trsp_count) = particles(n)
@@ -7809 +7533 @@
                             IF ( pdims(2) == 1 )  THEN
                                particles(n)%y        = particles(n)%y - ( ny + 1 ) * dy
-                               particles(n)%origin_y =                         &
-                                          particles(n)%origin_y - ( ny + 1 ) * dy
+                               particles(n)%origin_y = particles(n)%origin_y - ( ny + 1 ) * dy
                             ELSE
                                trnp_count         = trnp_count + 1
                                trnp(trnp_count)   = particles(n)
-                               trnp(trnp_count)%y =                            &
-                                          trnp(trnp_count)%y - ( ny + 1 ) * dy
-                               trnp(trnp_count)%origin_y =                     &
-                                         trnp(trnp_count)%origin_y - ( ny + 1 ) * dy
+                               trnp(trnp_count)%y = trnp(trnp_count)%y - ( ny + 1 ) * dy
+                               trnp(trnp_count)%origin_y =                                         &
+                                                         trnp(trnp_count)%origin_y - ( ny + 1 ) * dy
                                particles(n)%particle_mask = .FALSE.
                                deleted_particles          = deleted_particles + 1
@@ -7837 +7559 @@
                       ELSE
 !
-!--                      Store particle data in the transfer array, which will 
-!--                      be send to the neighbouring PE
+!--                      Store particle data in the transfer array, which will be send to the
+!--                      neighbouring PE
                          trnp_count = trnp_count + 1
                          trnp(trnp_count) = particles(n)
@@ -7854 +7576 @@
 
 !
-!-- Send front boundary, receive back boundary (but first exchange how many
-!-- and check, if particle storage must be extended)
+!-- Send front boundary, receive back boundary (but first exchange how many and check, if particle
+!-- storage must be extended)
     IF ( pdims(2) /= 1 )  THEN
 
@@ -7864 +7586 @@
        ALLOCATE(rvnp(MAX(1,trnp_count_recv)))
 !
-!--    This MPI_SENDRECV should work even with odd mixture on 32 and 64 Bit 
-!--    variables in structure particle_type (due to the calculation of par_size)
-       CALL MPI_SENDRECV( trsp, trsp_count*par_size, MPI_BYTE,      &
-                          psouth, 1, rvnp,                             &
-                          trnp_count_recv*par_size, MPI_BYTE, pnorth, 1,   &
+!--    This MPI_SENDRECV should work even with odd mixture on 32 and 64 Bit variables in structure
+!--    particle_type (due to the calculation of par_size)
+       CALL MPI_SENDRECV( trsp, trsp_count*par_size,      MPI_BYTE, psouth, 1,                     &
+                          rvnp, trnp_count_recv*par_size, MPI_BYTE, pnorth, 1,                     &
                           comm2d, status, ierr )
 
@@ -7877 +7598 @@
 !
 !--    Send back boundary, receive front boundary
-       CALL MPI_SENDRECV( trnp_count,      1, MPI_INTEGER, pnorth, 0, &
-                          trsp_count_recv, 1, MPI_INTEGER, psouth, 0, &
+       CALL MPI_SENDRECV( trnp_count,      1, MPI_INTEGER, pnorth, 0,                              &
+                          trsp_count_recv, 1, MPI_INTEGER, psouth, 0,                              &
                           comm2d, status, ierr )
 
        ALLOCATE(rvsp(MAX(1,trsp_count_recv)))
 !
-!--    This MPI_SENDRECV should work even with odd mixture on 32 and 64 Bit 
-!--    variables in structure particle_type (due to the calculation of par_size)
-       CALL MPI_SENDRECV( trnp, trnp_count*par_size, MPI_BYTE,      &
-                          pnorth, 1, rvsp,                          &
-                          trsp_count_recv*par_size, MPI_BYTE, psouth, 1,   &
+!--    This MPI_SENDRECV should work even with odd mixture on 32 and 64 Bit variables in structure
+!--    particle_type (due to the calculation of par_size)
+       CALL MPI_SENDRECV( trnp, trnp_count*par_size,      MPI_BYTE, pnorth, 1,                     &
+                          rvsp, trsp_count_recv*par_size, MPI_BYTE, psouth, 1,                     &
                           comm2d, status, ierr )
 
@@ -7922 +7642 @@
 !--                   Cyclic boundary. Relevant coordinate has to be changed.
                       particles(n)%x = ( nx + 1 ) * dx + particles(n)%x
-                      particles(n)%origin_x = ( nx + 1 ) * dx + &
-                               particles(n)%origin_x
+                      particles(n)%origin_x = ( nx + 1 ) * dx + particles(n)%origin_x
                    ELSEIF ( ibc_par_lr == 1 )  THEN
 !
@@ -7943 +7662 @@
 !--                   Cyclic boundary. Relevant coordinate has to be changed.
                       particles(n)%x = particles(n)%x - ( nx + 1 ) * dx
-                      particles(n)%origin_x = particles(n)%origin_x - &
-                               ( nx + 1 ) * dx
+                      particles(n)%origin_x = particles(n)%origin_x - ( nx + 1 ) * dx
 
                    ELSEIF ( ibc_par_lr == 1 )  THEN
@@ -7979 +7697 @@
 !--                   Cyclic boundary. Relevant coordinate has to be changed.
                       particles(n)%y = ( ny + 1 ) * dy + particles(n)%y
-                      particles(n)%origin_y = ( ny + 1 ) * dy + &
-                           particles(n)%origin_y
+                      particles(n)%origin_y = ( ny + 1 ) * dy + particles(n)%origin_y
 
                    ELSEIF ( ibc_par_ns == 1 )  THEN
@@ -8001 +7718 @@
 !--                   Cyclic boundary. Relevant coordinate has to be changed.
                       particles(n)%y = particles(n)%y - ( ny + 1 ) * dy
-                      particles(n)%origin_y = particles(n)%origin_y - &
-                                ( ny + 1 ) * dy
+                      particles(n)%origin_y = particles(n)%origin_y - ( ny + 1 ) * dy
 
                    ELSEIF ( ibc_par_ns == 1 )  THEN
@@ -8043 +7759 @@
 
 #if defined( __parallel )
-!------------------------------------------------------------------------------!
+!--------------------------------------------------------------------------------------------------!
 ! Description:
 ! ------------
-!> If a particle moves from one processor to another, this subroutine moves 
-!> the corresponding elements from the particle arrays of the old grid cells 
-!> to the particle arrays of the new grid cells.
-!------------------------------------------------------------------------------!
+!> If a particle moves from one processor to another, this subroutine moves the corresponding
+!> elements from the particle arrays of the old grid cells to the particle arrays of the new grid
+!> cells.
+!--------------------------------------------------------------------------------------------------!
  SUBROUTINE lpm_add_particles_to_gridcell (particle_array)
 
@@ -8065 +7781 @@
     TYPE(particle_type), DIMENSION(:), ALLOCATABLE ::  temp_ns        !< temporary particle array for reallocation
 
+
     pack_done     = .FALSE.
 
-    DO  n = 1, SIZE(particle_array)
+    DO  n = 1, SIZE( particle_array )
 
        IF ( .NOT. particle_array(n)%particle_mask )  CYCLE
@@ -8075 +7792 @@
 !
 !--    In case of stretching the actual k index must be found
-       IF ( dz_stretch_level /= -9999999.9_wp  .OR.         &
-            dz_stretch_level_start(1) /= -9999999.9_wp )  THEN
+       IF ( dz_stretch_level /= -9999999.9_wp  .OR.  dz_stretch_level_start(1) /= -9999999.9_wp )  &
+       THEN
           kp = MAX( MINLOC( ABS( particle_array(n)%z - zu ), DIM = 1 ) - 1, 1 )
        ELSE
@@ -8082 +7799 @@
        ENDIF
 
-       IF ( ip >= nxl  .AND.  ip <= nxr  .AND.  jp >= nys  .AND.  jp <= nyn    &
-            .AND.  kp >= nzb+1  .AND.  kp <= nzt)  THEN ! particle stays on processor
+       IF ( ip >= nxl    .AND.  ip <= nxr  .AND.  jp >= nys  .AND.  jp <= nyn  .AND.               &
+            kp >= nzb+1  .AND.  kp <= nzt)  THEN  ! particle stays on processor
+
           number_of_particles = prt_count(kp,jp,ip)
           particles => grid_particles(kp,jp,ip)%particles(1:number_of_particles)
 
           pindex = prt_count(kp,jp,ip)+1
-          IF( pindex > SIZE(grid_particles(kp,jp,ip)%particles) )  THEN
+          IF( pindex > SIZE( grid_particles(kp,jp,ip)%particles ) )  THEN
              IF ( pack_done )  THEN
                 CALL realloc_particles_array ( ip, jp, kp )
@@ -8095 +7813 @@
                 prt_count(kp,jp,ip) = number_of_particles
                 pindex = prt_count(kp,jp,ip)+1
-                IF ( pindex > SIZE(grid_particles(kp,jp,ip)%particles) )  THEN
+                IF ( pindex > SIZE( grid_particles(kp,jp,ip)%particles ) )  THEN
                    CALL realloc_particles_array ( ip, jp, kp )
                 ENDIF
@@ -8103 +7821 @@
           grid_particles(kp,jp,ip)%particles(pindex) = particle_array(n)
           prt_count(kp,jp,ip) = pindex
+
        ELSE
+
           IF ( jp <= nys - 1 )  THEN
+
              nr_move_south = nr_move_south+1
 !
-!--          Before particle information is swapped to exchange-array, check 
-!--          if enough memory is allocated. If required, reallocate exchange
-!--          array.
-             IF ( nr_move_south > SIZE(move_also_south) )  THEN
-!
-!--             At first, allocate further temporary array to swap particle 
-!--             information.
-                ALLOCATE( temp_ns(SIZE(move_also_south)+NR_2_direction_move) )
+!--          Before particle information is swapped to exchange-array, check if enough memory is
+!--          allocated. If required, reallocate exchange array.
+             IF ( nr_move_south > SIZE( move_also_south ) )  THEN
+!
+!--             At first, allocate further temporary array to swap particle information.
+                ALLOCATE( temp_ns(SIZE( move_also_south )+nr_2_direction_move) )
                 temp_ns(1:nr_move_south-1) = move_also_south(1:nr_move_south-1)
                 DEALLOCATE( move_also_south )
-                ALLOCATE( move_also_south(SIZE(temp_ns)) )
+                ALLOCATE( move_also_south(SIZE( temp_ns )) )
                 move_also_south(1:nr_move_south-1) = temp_ns(1:nr_move_south-1)
                 DEALLOCATE( temp_ns )
@@ -8129 +7848 @@
 !--             Apply boundary condition along y
                 IF ( ibc_par_ns == 0 )  THEN
-                   move_also_south(nr_move_south)%y =                          &
-                      move_also_south(nr_move_south)%y + ( ny + 1 ) * dy
-                   move_also_south(nr_move_south)%origin_y =                   &
-                      move_also_south(nr_move_south)%origin_y + ( ny + 1 ) * dy
+                   move_also_south(nr_move_south)%y =                                              &
+                                                  move_also_south(nr_move_south)%y + ( ny + 1 ) * dy
+                   move_also_south(nr_move_south)%origin_y =                                       &
+                                           move_also_south(nr_move_south)%origin_y + ( ny + 1 ) * dy
                 ELSEIF ( ibc_par_ns == 1 )  THEN
 !
@@ -8142 +7861 @@
 !
 !--                Particle reflection
-                   move_also_south(nr_move_south)%y       =                    &
-                      -move_also_south(nr_move_south)%y
-                   move_also_south(nr_move_south)%speed_y =                    &
-                      -move_also_south(nr_move_south)%speed_y
+                   move_also_south(nr_move_south)%y       = -move_also_south(nr_move_south)%y
+                   move_also_south(nr_move_south)%speed_y = -move_also_south(nr_move_south)%speed_y
 
                 ENDIF
+
              ENDIF
+
           ELSEIF ( jp >= nyn+1 )  THEN
+
              nr_move_north = nr_move_north+1
 !
-!--          Before particle information is swapped to exchange-array, check 
-!--          if enough memory is allocated. If required, reallocate exchange
-!--          array.
-             IF ( nr_move_north > SIZE(move_also_north) )  THEN
-!
-!--             At first, allocate further temporary array to swap particle 
-!--             information.
-                ALLOCATE( temp_ns(SIZE(move_also_north)+NR_2_direction_move) )
+!--          Before particle information is swapped to exchange-array, check if enough memory is
+!--          allocated. If required, reallocate exchange array.
+             IF ( nr_move_north > SIZE( move_also_north ) )  THEN
+!
+!--             At first, allocate further temporary array to swap particle information.
+                ALLOCATE( temp_ns(SIZE( move_also_north )+nr_2_direction_move) )
                 temp_ns(1:nr_move_north-1) = move_also_south(1:nr_move_north-1)
                 DEALLOCATE( move_also_north )
-                ALLOCATE( move_also_north(SIZE(temp_ns)) )
+                ALLOCATE( move_also_north(SIZE( temp_ns )) )
                 move_also_north(1:nr_move_north-1) = temp_ns(1:nr_move_north-1)
                 DEALLOCATE( temp_ns )
@@ -8174 +7892 @@
                 IF ( ibc_par_ns == 0 )  THEN
 
-                   move_also_north(nr_move_north)%y =                          &
-                      move_also_north(nr_move_north)%y - ( ny + 1 ) * dy
-                   move_also_north(nr_move_north)%origin_y =                   &
-                      move_also_north(nr_move_north)%origin_y - ( ny + 1 ) * dy
+                   move_also_north(nr_move_north)%y =                                              &
+                                                  move_also_north(nr_move_north)%y - ( ny + 1 ) * dy
+                   move_also_north(nr_move_north)%origin_y =                                       &
+                                           move_also_north(nr_move_north)%origin_y - ( ny + 1 ) * dy
                 ELSEIF ( ibc_par_ns == 1 )  THEN
 !
@@ -8187 +7905 @@
 !
 !--                Particle reflection
-                   move_also_north(nr_move_north)%y       =                    &
-                      -move_also_north(nr_move_north)%y
-                   move_also_north(nr_move_north)%speed_y =                    &
-                      -move_also_north(nr_move_north)%speed_y
+                   move_also_north(nr_move_north)%y       = -move_also_north(nr_move_north)%y
+                   move_also_north(nr_move_north)%speed_y = -move_also_north(nr_move_north)%speed_y
 
                 ENDIF
+
              ENDIF
+
           ELSE
+
              IF ( .NOT. child_domain )  THEN
                 WRITE(0,'(a,8i7)') 'particle out of range ',myid,ip,jp,kp,nxl,nxr,nys,nyn
+
              ENDIF
+
           ENDIF
+
        ENDIF
+
     ENDDO
 
  END SUBROUTINE lpm_add_particles_to_gridcell
 #endif
- 
- 
-!------------------------------------------------------------------------------!
+
+
+!--------------------------------------------------------------------------------------------------!
 ! Description:
 ! ------------
-!> If a particle moves from one grid cell to another (on the current 
-!> processor!), this subroutine moves the corresponding element from the
-!> particle array of the old grid cell to the particle array of the new grid 
-!> cell.
-!------------------------------------------------------------------------------!
+!> If a particle moves from one grid cell to another (on the current processor!), this subroutine
+!> moves the corresponding element from the particle array of the old grid cell to the particle
+!> array of the new grid cell.
+!--------------------------------------------------------------------------------------------------!
  SUBROUTINE lpm_move_particle
- 
+
     INTEGER(iwp)        ::  i           !< grid index (x) of particle position
     INTEGER(iwp)        ::  ip          !< index variable along x
@@ -8243 +7965 @@
                 k = kp
 !
-!--             Find correct vertical particle grid box (necessary in case of grid stretching)
-!--             Due to the CFL limitations only the neighbouring grid boxes are considered. 
+!--             Find correct vertical particle grid box (necessary in case of grid stretching).
+!--             Due to the CFL limitations only the neighbouring grid boxes are considered.
                 IF( zw(k)   < particles_before_move(n)%z ) k = k + 1
-                IF( zw(k-1) > particles_before_move(n)%z ) k = k - 1 
-
-!--             For lpm_exchange_horiz to work properly particles need to be moved to the outermost gridboxes
-!--             of the respective processor. If the particle index is inside the processor the following lines
-!--             will not change the index
+                IF( zw(k-1) > particles_before_move(n)%z ) k = k - 1
+
+!--             For lpm_exchange_horiz to work properly particles need to be moved to the outermost
+!--             gridboxes of the respective processor. If the particle index is inside the processor
+!--             the following lines will not change the index.
                 i = MIN ( i , nxr )
                 i = MAX ( i , nxl )
@@ -8263 +7985 @@
                 IF ( i /= ip  .OR.  j /= jp  .OR.  k /= kp )  THEN
 !!
-!--                If the particle stays on the same processor, the particle
-!--                will be added to the particle array of the new processor.
+!--                If the particle stays on the same processor, the particle will be added to the
+!--                particle array of the new processor.
                    number_of_particles = prt_count(k,j,i)
                    particles => grid_particles(k,j,i)%particles(1:number_of_particles)
 
                    pindex = prt_count(k,j,i)+1
-                   IF (  pindex > SIZE(grid_particles(k,j,i)%particles)  )     &
-                   THEN
+                   IF (  pindex > SIZE( grid_particles(k,j,i)%particles )  )  THEN
                       CALL realloc_particles_array( i, j, k )
                    ENDIF
@@ -8290 +8011 @@
 
  END SUBROUTINE lpm_move_particle
- 
-
-!------------------------------------------------------------------------------!
+
+
+!--------------------------------------------------------------------------------------------------!
 ! Description:
 ! ------------
-!> Check CFL-criterion for each particle. If one particle violated the 
-!> criterion the particle will be deleted and a warning message is given.
-!------------------------------------------------------------------------------!
- SUBROUTINE lpm_check_cfl  
+!> Check CFL-criterion for each particle. If one particle violated the criterion the particle will
+!> be deleted and a warning message is given.
+!--------------------------------------------------------------------------------------------------!
+ SUBROUTINE lpm_check_cfl
 
     IMPLICIT NONE
@@ -8312 +8033 @@
              number_of_particles = prt_count(k,j,i)
              IF ( number_of_particles <= 0 )  CYCLE
-             particles => grid_particles(k,j,i)%particles(1:number_of_particles)         
+             particles => grid_particles(k,j,i)%particles(1:number_of_particles)
              DO  n = 1, number_of_particles
 !
-!--             Note, check for CFL does not work at first particle timestep 
-!--             when both, age and age_m are zero. 
+!--             Note, check for CFL does not work at first particle timestep when both, age and
+!--             age_m are zero.
                 IF ( particles(n)%age - particles(n)%age_m > 0.0_wp )  THEN
-                   IF( ABS( particles(n)%speed_x ) >                           &
-                      ( dx / ( particles(n)%age - particles(n)%age_m) )  .OR.  &
-                       ABS( particles(n)%speed_y ) >                           & 
-                      ( dy / ( particles(n)%age - particles(n)%age_m) )  .OR.  &
-                       ABS( particles(n)%speed_z ) >                           &
-                      ( ( zw(k)-zw(k-1) )                                      &
-                      / ( particles(n)%age - particles(n)%age_m) ) )  THEN
-                      WRITE( message_string, * )                               &
-                      'Particle violated CFL-criterion: &particle with id ',   &
-                      particles(n)%id, ' will be deleted!'   
+                   IF( ABS( particles(n)%speed_x ) >                                               &
+                       ( dx / ( particles(n)%age - particles(n)%age_m) )  .OR.                     &
+                       ABS( particles(n)%speed_y ) >                                               &
+                       ( dy / ( particles(n)%age - particles(n)%age_m) )  .OR.                     &
+                       ABS( particles(n)%speed_z ) >                                               &
+                       ( ( zw(k)-zw(k-1) ) / ( particles(n)%age - particles(n)%age_m) ) )          &
+                   THEN
+                      WRITE( message_string, * )                                                   &
+                         'Particle violated CFL-criterion: &particle with id ', particles(n)%id,   &
+                         ' will be deleted!'
                       CALL message( 'lpm_check_cfl', 'PA0475', 0, 1, -1, 6, 0 )
 
@@ -8336 +8057 @@
           ENDDO
        ENDDO
-    ENDDO   
+    ENDDO
 
  END SUBROUTINE lpm_check_cfl
- 
- 
-!------------------------------------------------------------------------------!
+
+
+!--------------------------------------------------------------------------------------------------!
 ! Description:
 ! ------------
-!> If the allocated memory for the particle array do not suffice to add arriving
-!> particles from neighbour grid cells, this subrouting reallocates the 
-!> particle array to assure enough memory is available. 
-!------------------------------------------------------------------------------!
+!> If the allocated memory for the particle array does not suffice to add arriving particles from
+!> neighbour grid cells, this subrouting reallocates the particle array to assure enough memory is
+!> available.
+!--------------------------------------------------------------------------------------------------!
  SUBROUTINE realloc_particles_array ( i, j, k, size_in )
 
@@ -8355 +8076 @@
     INTEGER(iwp), INTENT(IN), OPTIONAL             ::  size_in        !<
 
+    INTEGER(iwp)                                   ::  new_size        !<
     INTEGER(iwp)                                   ::  old_size        !<
-    INTEGER(iwp)                                   ::  new_size        !<
     TYPE(particle_type), DIMENSION(:), ALLOCATABLE ::  tmp_particles_d !<
     TYPE(particle_type), DIMENSION(500)            ::  tmp_particles_s !<
 
-    old_size = SIZE(grid_particles(k,j,i)%particles)
-
-    IF ( PRESENT(size_in) )   THEN
+    old_size = SIZE( grid_particles(k,j,i)%particles )
+
+    IF ( PRESENT( size_in) )  THEN
        new_size = size_in
     ELSE
@@ -8397 +8118 @@
 
     RETURN
-    
+
  END SUBROUTINE realloc_particles_array
- 
- 
-!------------------------------------------------------------------------------!
+
+
+!--------------------------------------------------------------------------------------------------!
 ! Description:
 ! ------------
-!> Not needed but allocated space for particles is dealloced. 
-!------------------------------------------------------------------------------!
+!> Not needed but allocated space for particles is dealloced.
+!--------------------------------------------------------------------------------------------------!
  SUBROUTINE dealloc_particles_array
 
- 
+
     INTEGER(iwp) ::  i               !<
     INTEGER(iwp) ::  j               !<
@@ -8431 +8152 @@
 !
 !--          Check for large unused memory
-             dealloc = ( ( number_of_particles < 1 .AND.         &
-                           old_size            > 1 )  .OR.       &
-                         ( number_of_particles > 1 .AND.         &
-                           old_size - number_of_particles *                    &
-                              ( 1.0_wp + 0.01_wp * alloc_factor ) > 0.0_wp ) )
+             dealloc = ( ( number_of_particles < 1 .AND. old_size > 1 )  .OR.                      &
+                         ( number_of_particles > 1 .AND.                                           &
+                           old_size - number_of_particles * ( 1.0_wp + 0.01_wp * alloc_factor )    &
+                           > 0.0_wp )                                                              &
+                       )
 
              IF ( dealloc )  THEN
                 IF ( number_of_particles < 1 )  THEN
                    new_size = 1
-                ELSE 
+                ELSE
                    new_size = INT( number_of_particles * ( 1.0_wp + 0.01_wp * alloc_factor ) )
                 ENDIF
@@ -8474 +8195 @@
     ENDDO
 
- END SUBROUTINE dealloc_particles_array 
- 
- 
-!------------------------------------------------------------------------------!
+ END SUBROUTINE dealloc_particles_array
+
+
+!--------------------------------------------------------------------------------------------------!
 ! Description:
 ! -----------
-!> Routine for the whole processor
-!> Sort all particles into the 8 respective subgrid boxes (in case of trilinear
-!> interpolation method) and free space of particles which has been marked for
-!> deletion.
-!------------------------------------------------------------------------------!
+!> Routine for the whole processor.
+!> Sort all particles into the 8 respective subgrid boxes (in case of trilinear interpolation
+!> method) and free space of particles which has been marked for deletion.
+!--------------------------------------------------------------------------------------------------!
    SUBROUTINE lpm_sort_and_delete
 
@@ -8520 +8240 @@
                          nn = nn + 1
 !
-!--                      Sorting particles with a binary scheme
+!--                      Sorting particles with a binary scheme.
 !--                      sort_index=111_2=7_10 -> particle at the left,south,bottom subgridbox
 !--                      sort_index=000_2=0_10 -> particle at the right,north,top subgridbox
-!--                      For this the center of the gridbox is calculated
+!--                      For this the center of the gridbox is calculated.
                          i = (particles(n)%x + 0.5_wp * dx) * ddx
                          j = (particles(n)%y + 0.5_wp * dy) * ddy
@@ -8538 +8258 @@
                    ENDDO
 !
-!--                Delete and resort particles by overwritting and set
-!--                the number_of_particles to the actual value.
+!--                Delete and resort particles by overwritting and set the number_of_particles to
+!--                the actual value.
                    nn = 0
                    DO  is = 0,7
@@ -8557 +8277 @@
           ENDDO
 
-!--    In case of the simple interpolation method the particles must not
-!--    be sorted in subboxes. Particles marked for deletion however, must be
-!--    deleted and number of particles must be recalculated as it is also
-!--    done for the trilinear particle advection interpolation method.
+!--    In case of the simple interpolation method the particles must not be sorted in subboxes.
+!--    Particles marked for deletion however, must be deleted and number of particles must be
+!--    recalculated as it is also done for the trilinear particle advection interpolation method.
        ELSE
 
@@ -8571 +8290 @@
                    particles => grid_particles(kp,jp,ip)%particles(1:number_of_particles)
 !
-!--                Repack particles array, i.e. delete particles and recalculate
-!--                number of particles
+!--                Repack particles array, i.e. delete particles and recalculate number of particles
                    CALL lpm_pack
                    prt_count(kp,jp,ip) = number_of_particles
@@ -8583 +8301 @@
     END SUBROUTINE lpm_sort_and_delete
 
- 
-!------------------------------------------------------------------------------!
+
+!--------------------------------------------------------------------------------------------------!
 ! Description:
 ! ------------
 !> Move all particles not marked for deletion to lowest indices (packing)
-!------------------------------------------------------------------------------!
+!--------------------------------------------------------------------------------------------------!
     SUBROUTINE lpm_pack
 
@@ -8594 +8312 @@
        INTEGER(iwp) ::  nn      !<
 !
-!--    Find out elements marked for deletion and move data from highest index
-!--    values to these free indices
+!--    Find out elements marked for deletion and move data from highest index values to these free
+!--    indices
        nn = number_of_particles
 
@@ -8618 +8336 @@
 
 !
-!--    The number of deleted particles has been determined in routines
-!--    lpm_boundary_conds, lpm_droplet_collision, and lpm_exchange_horiz
+!--    The number of deleted particles has been determined in routines lpm_boundary_conds,
+!--    lpm_droplet_collision, and lpm_exchange_horiz
        number_of_particles = nn
 
-    END SUBROUTINE lpm_pack 
-
-
-!------------------------------------------------------------------------------!
+    END SUBROUTINE lpm_pack
+
+
+!--------------------------------------------------------------------------------------------------!
 ! Description:
 ! ------------
-!> Sort particles in each sub-grid box into two groups: particles that already
-!> completed the LES timestep, and particles that need further timestepping to
-!> complete the LES timestep. 
-!------------------------------------------------------------------------------!
+!> Sort particles in each sub-grid box into two groups: particles that already completed the LES
+!> timestep, and particles that need further timestepping to complete the LES timestep.
+!--------------------------------------------------------------------------------------------------!
     SUBROUTINE lpm_sort_timeloop_done
 
@@ -8661 +8378 @@
                    end_index   = grid_particles(k,j,i)%end_index(nb)
 !
-!--                Allocate temporary array used for sorting. 
+!--                Allocate temporary array used for sorting.
                    ALLOCATE( sort_particles(start_index:end_index) )
 !
-!--                Determine number of particles already completed the LES 
-!--                timestep, and write them into a temporary array. 
+!--                Determine number of particles already completed the LES timestep, and write them
+!--                into a temporary array.
                    nf = start_index
                    num_finalized = 0
@@ -8676 +8393 @@
                    ENDDO
 !
-!--                Determine number of particles that not completed the LES 
-!--                timestep, and write them into a temporary array. 
+!--                Determine number of particles that not completed the LES timestep, and write them
+!--                into a temporary array.
                    nnf = nf
                    DO  n = start_index, end_index
@@ -8687 +8404 @@
 !
 !--                Write back sorted particles
-                   particles(start_index:end_index) =                          &
-                                           sort_particles(start_index:end_index)
-!
-!--                Determine updated start_index, used to masked already 
-!--                completed particles. 
-                   grid_particles(k,j,i)%start_index(nb) =                     &
-                                      grid_particles(k,j,i)%start_index(nb)    &
-                                    + num_finalized
+                   particles(start_index:end_index) = sort_particles(start_index:end_index)
+!
+!--                Determine updated start_index, used to masked already
+!--                completed particles.
+                   grid_particles(k,j,i)%start_index(nb) = grid_particles(k,j,i)%start_index(nb)   &
+                                                           + num_finalized
 !
 !--                Deallocate dummy array
                    DEALLOCATE ( sort_particles )
 !
-!--                Finally, if number of non-completed particles is non zero 
-!--                in any of the sub-boxes, set control flag appropriately. 
-                   IF ( nnf > nf )                                             &
-                      grid_particles(k,j,i)%time_loop_done = .FALSE.
+!--                Finally, if number of non-completed particles is non zero
+!--                in any of the sub-boxes, set control flag appropriately.
+                   IF ( nnf > nf )  grid_particles(k,j,i)%time_loop_done = .FALSE.
 
                 ENDDO
@@ -8709 +8423 @@
        ENDDO
 
-    END SUBROUTINE lpm_sort_timeloop_done 
+    END SUBROUTINE lpm_sort_timeloop_done
 
 END MODULE lagrangian_particle_model_mod