Index: palm/trunk/SOURCE/lpm_droplet_collision.f90
===================================================================
--- palm/trunk/SOURCE/lpm_droplet_collision.f90	(revision 2274)
+++ palm/trunk/SOURCE/lpm_droplet_collision.f90	(revision 2312)
@@ -20,9 +20,13 @@
 ! Current revisions:
 ! ------------------
-! 
-! 
+!
+!
 ! Former revisions:
 ! -----------------
 ! $Id$
+! Consideration of aerosol mass during collision. Average impact algorithm has
+! been removed.
+!
+! 2274 2017-06-09 13:27:48Z Giersch
 ! Changed error messages
 !
@@ -39,5 +43,5 @@
 !
 ! 1860 2016-04-13 13:21:28Z hoffmann
-! Interpolation of dissipation rate adjusted to more reasonable values. 
+! Interpolation of dissipation rate adjusted to more reasonable values.
 !
 ! 1822 2016-04-07 07:49:42Z hoffmann
@@ -49,8 +53,8 @@
 !
 ! 1682 2015-10-07 23:56:08Z knoop
-! Code annotations made doxygen readable 
-! 
+! Code annotations made doxygen readable
+!
 ! 1359 2014-04-11 17:15:14Z hoffmann
-! New particle structure integrated. 
+! New particle structure integrated.
 ! Kind definition added to all floating point numbers.
 !
@@ -96,9 +100,7 @@
 !>              the modification of the relative velocity between the droplets,
 !>              the effect of preferential concentration, and the enhancement of
-!>              collision efficiencies. 
+!>              collision efficiencies.
 !------------------------------------------------------------------------------!
  SUBROUTINE lpm_droplet_collision (i,j,k)
- 
-
 
     USE arrays_3d,                                                             &
@@ -126,7 +128,7 @@
 
     USE particle_attributes,                                                   &
-        ONLY:  all_or_nothing, average_impact, dissipation_classes,            &
-               hall_kernel, iran_part, number_of_particles, particles,         &
-               particle_type, prt_count, use_kernel_tables, wang_kernel
+        ONLY:  curvature_solution_effects, dissipation_classes, hall_kernel,   &
+               iran_part, number_of_particles, particles, particle_type,       &
+               prt_count, rho_s, use_kernel_tables, wang_kernel
 
     USE random_function_mod,                                                   &
@@ -150,27 +152,26 @@
     REAL(wp) ::  epsilon                 !< dissipation rate
     REAL(wp) ::  factor_volume_to_mass   !< 4.0 / 3.0 * pi * rho_l
-    REAL(wp) ::  xm                      !< mean mass of droplet m
-    REAL(wp) ::  xn                      !< mean mass of droplet n
-
-    REAL(wp), DIMENSION(:), ALLOCATABLE ::  weight  !< weighting factor
-    REAL(wp), DIMENSION(:), ALLOCATABLE ::  mass    !< total mass of super droplet
+    REAL(wp) ::  xm                      !< droplet mass of super-droplet m
+    REAL(wp) ::  xn                      !< droplet mass of super-droplet n
+    REAL(wp) ::  xsm                     !< aerosol mass of super-droplet m
+    REAL(wp) ::  xsn                     !< aerosol mass of super-droplet n
+
+    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' )
 
     number_of_particles   = prt_count(k,j,i)
-    factor_volume_to_mass = 4.0_wp / 3.0_wp * pi * rho_l 
-    ddV                   = 1 / ( dx * dy * dz )
+    factor_volume_to_mass = 4.0_wp / 3.0_wp * pi * rho_l
+    ddV                   = 1.0_wp / ( dx * dy * dz )
 !
 !-- Collision requires at least one super droplet inside the box
     IF ( number_of_particles > 0 )  THEN
 
-!
-!--    Now apply the different kernels
        IF ( use_kernel_tables )  THEN
 !
 !--       Fast method with pre-calculated collection kernels for
 !--       discrete radius- and dissipation-classes.
-!--
-!--       Determine dissipation class index of this gridbox
           IF ( wang_kernel )  THEN
              eclass = INT( diss(k,j,i) * 1.0E4_wp / 600.0_wp * &
@@ -180,4 +181,5 @@
              epsilon = 0.0_wp
           ENDIF
+
           IF ( hall_kernel  .OR.  epsilon * 1.0E4_wp < 0.001_wp )  THEN
              eclass = 0   ! Hall kernel is used
@@ -186,169 +188,7 @@
           ENDIF
 
-!
-!--       Droplet collision are calculated using collision-coalescence
-!--       formulation proposed by Wang (see PALM documentation)
-!--       Temporary fields for total mass of super-droplet and weighting factors 
-!--       are allocated.
-          ALLOCATE(mass(1:number_of_particles), weight(1:number_of_particles))
-
-          mass(1:number_of_particles)   = particles(1:number_of_particles)%weight_factor * &
-                                          particles(1:number_of_particles)%radius**3     * &
-                                          factor_volume_to_mass
-          weight(1:number_of_particles) = particles(1:number_of_particles)%weight_factor
-
-          IF ( average_impact )  THEN  ! select collision algorithm
-
-             DO  n = 1, number_of_particles
-
-                rclass_l = particles(n)%class
-                xn       = mass(n) / weight(n)
-
-                DO  m = n, number_of_particles
-
-                   rclass_s = particles(m)%class
-                   xm       = mass(m) / weight(m)
-
-                   IF ( xm .LT. xn )  THEN
-                      
-!
-!--                   Particle n collects smaller particle m
-                      collection_probability = ckernel(rclass_l,rclass_s,eclass) * &
-                                               weight(n) * ddV * dt_3d
-
-                      mass(n)   = mass(n)   + mass(m)   * collection_probability
-                      weight(m) = weight(m) - weight(m) * collection_probability
-                      mass(m)   = mass(m)   - mass(m)   * collection_probability
-                   ELSEIF ( xm .GT. xn )  THEN 
-!
-!--                   Particle m collects smaller particle n
-                      collection_probability = ckernel(rclass_l,rclass_s,eclass) * &
-                                               weight(m) * ddV * dt_3d
-
-                      mass(m)   = mass(m)   + mass(n)   * collection_probability
-                      weight(n) = weight(n) - weight(n) * collection_probability
-                      mass(n)   = mass(n)   - mass(n)   * collection_probability
-                   ELSE
-!
-!--                   Same-size collections. If n = m, weight is reduced by the
-!--                   number of possible same-size collections; the total mass 
-!--                   is not changed during same-size collection.
-!--                   Same-size collections of different 
-!--                   particles ( n /= m ) are treated as same-size collections 
-!--                   of ONE partilce with weight = weight(n) + weight(m) and 
-!--                   mass = mass(n) + mass(m).
-!--                   Accordingly, each particle loses the same number of 
-!--                   droplets to the other particle, but this has no effect on 
-!--                   total mass mass, since the exchanged droplets have the 
-!--                   same radius. 
-
-!--                   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).
-                      weight(n) = weight(n) - 0.5_wp * weight(n) *                &
-                                              ckernel(rclass_l,rclass_s,eclass) * &
-                                              weight(m) * ddV * dt_3d
-                      IF ( n .NE. m )  THEN 
-                         weight(m) = weight(m) - 0.5_wp * weight(m) *                &
-                                                 ckernel(rclass_l,rclass_s,eclass) * &
-                                                 weight(n) * ddV * dt_3d
-                      ENDIF
-                   ENDIF
-
-                ENDDO
-
-                ql_vp(k,j,i) = ql_vp(k,j,i) + mass(n) / factor_volume_to_mass
-
-             ENDDO
-
-          ELSEIF ( all_or_nothing )  THEN  ! select collision algorithm
-
-             DO  n = 1, number_of_particles
-
-                rclass_l = particles(n)%class
-                xn       = mass(n) / weight(n) ! mean mass of droplet n
-
-                DO  m = n, number_of_particles
-
-                   rclass_s = particles(m)%class
-                   xm = mass(m) / weight(m) ! mean mass of droplet m
-
-                   IF ( weight(n) .LT. weight(m) )  THEN
-!
-!--                   Particle n collects weight(n) droplets of particle m  
-                      collection_probability = ckernel(rclass_l,rclass_s,eclass) * &
-                                               weight(m) * ddV * dt_3d
-
-                      IF ( collection_probability .GT. random_function( iran_part ) )  THEN
-                         mass(n)   = mass(n)   + weight(n) * xm
-                         weight(m) = weight(m) - weight(n)
-                         mass(m)   = mass(m)   - weight(n) * xm
-                      ENDIF
-
-                   ELSEIF ( weight(m) .LT. weight(n) )  THEN 
-!
-!--                   Particle m collects weight(m) droplets of particle n  
-                      collection_probability = ckernel(rclass_l,rclass_s,eclass) * &
-                                               weight(n) * ddV * dt_3d
-
-                      IF ( collection_probability .GT. random_function( iran_part ) )  THEN
-                         mass(m)   = mass(m)   + weight(m) * xn
-                         weight(n) = weight(n) - weight(m)
-                         mass(n)   = mass(n)   - weight(m) * xn
-                      ENDIF
-                   ELSE
-!
-!--                   Collisions of particles of the same weighting factor. 
-!--                   Particle n collects 1/2 weight(n) droplets of particle m,
-!--                   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.
-
-!--                   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).
-                      collection_probability = ckernel(rclass_l,rclass_s,eclass) * &
-                                               weight(n) * ddV * dt_3d
-
-                      IF ( collection_probability .GT. random_function( iran_part ) )  THEN
-                         mass(n)   = mass(n)   + 0.5_wp * weight(n) * ( xm - xn )
-                         mass(m)   = mass(m)   + 0.5_wp * weight(m) * ( xn - xm )
-                         weight(n) = weight(n) - 0.5_wp * weight(m)
-                         weight(m) = weight(n)
-                      ENDIF
-                   ENDIF
-
-                ENDDO
-
-                ql_vp(k,j,i) = ql_vp(k,j,i) + mass(n) / factor_volume_to_mass
-
-             ENDDO
-
-          ENDIF
-
-
-
-
-          IF ( ANY(weight < 0.0_wp) )  THEN
-                WRITE( message_string, * ) 'negative weighting factor'
-                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       &
-                                                      )                               &
-                                                    )**0.33333333333333_wp
-
-          particles(1:number_of_particles)%weight_factor = weight(1:number_of_particles)
-
-          DEALLOCATE(weight, mass)
-
-       ELSEIF ( .NOT. use_kernel_tables )  THEN
-!
-!--       Collection kernels are calculated for every new
+       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
@@ -359,163 +199,143 @@
 !--       the kernel is based on the previous time step
           CALL recalculate_kernel( i, j, k )
-!
-!--       Droplet collision are calculated using collision-coalescence
-!--       formulation proposed by Wang (see PALM documentation)
-!--       Temporary fields for total mass of super-droplet and weighting factors 
-!--       are allocated.
-          ALLOCATE(mass(1:number_of_particles), weight(1:number_of_particles))
-
-          mass(1:number_of_particles) = particles(1:number_of_particles)%weight_factor * &
-                                        particles(1:number_of_particles)%radius**3     * &
-                                        factor_volume_to_mass
-
-          weight(1:number_of_particles) = particles(1:number_of_particles)%weight_factor
-
-          IF ( average_impact )  THEN  ! select collision algorithm
-
-             DO  n = 1, number_of_particles
-
-                xn = mass(n) / weight(n) ! mean mass of droplet n
-
-                DO  m = n, number_of_particles
-
-                   xm = mass(m) / weight(m) !mean mass of droplet m
-
-                   IF ( xm .LT. xn )  THEN
-!
-!--                   Particle n collects smaller particle m 
-                      collection_probability = ckernel(n,m,1) * weight(n) *    &
-                                               ddV * dt_3d
-
-                      mass(n)   = mass(n)   + mass(m)   * collection_probability
-                      weight(m) = weight(m) - weight(m) * collection_probability
-                      mass(m)   = mass(m)   - mass(m)   * collection_probability
-                   ELSEIF ( xm .GT. xn )  THEN 
-!
-!--                   Particle m collects smaller particle n
-                      collection_probability = ckernel(n,m,1) * weight(m) *    &
-                                               ddV * dt_3d
-
-                      mass(m)   = mass(m)   + mass(n)   * collection_probability
-                      weight(n) = weight(n) - weight(n) * collection_probability
-                      mass(n)   = mass(n)   - mass(n)   * collection_probability
-                   ELSE
-!
-!--                   Same-size collections. If n = m, weight is reduced by the
-!--                   number of possible same-size collections; the total mass 
-!--                   mass is not changed during same-size collection. 
-!--                   Same-size collections of different 
-!--                   particles ( n /= m ) are treated as same-size collections 
-!--                   of ONE partilce with weight = weight(n) + weight(m) and 
-!--                   mass = mass(n) + mass(m).
-!--                   Accordingly, each particle loses the same number of 
-!--                   droplets to the other particle, but this has no effect on 
-!--                   total mass mass, since the exchanged droplets have the 
-!--                   same radius. 
+
+       ENDIF
+!
+!--    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     * &
+                                       factor_volume_to_mass
+
+       weight(1:number_of_particles) = particles(1:number_of_particles)%weight_factor
+
+       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       * &
+                                             4.0 / 3.0 * pi * rho_s
+       ENDIF
+!
+!--    Calculate collision/coalescence
+       DO  n = 1, number_of_particles
+
+          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.
+             IF ( MIN( weight(n), weight(m) ) .LT. 1.0 )  CYCLE
+!
+!--          Get mass of individual droplets (aerosols)
+             xn = mass(n) / weight(n)
+             xm = mass(m) / weight(m)
+             IF ( curvature_solution_effects )  THEN
+                xsn = aero_mass(n) / weight(n)
+                xsm = aero_mass(m) / weight(m)
+             ENDIF
+!
+!--          Probability that the necessary collisions take place
+             IF ( use_kernel_tables )  THEN
+                rclass_l = particles(n)%class
+                rclass_s = particles(m)%class
+
+                collection_probability  = MAX( weight(n), weight(m) ) *     &
+                                          ckernel(rclass_l,rclass_s,eclass) * ddV * dt_3d
+             ELSE
+                collection_probability  = MAX( weight(n), weight(m) ) *     &
+                                          ckernel(n,m,1) * ddV * dt_3d
+             ENDIF
+!
+!--          Calculate the number of collections and consider multiple collections.
+!--          (Accordingly, p_crit will be 0.0, 1.0, 2.0, ...)
+             IF ( collection_probability - FLOOR(collection_probability)    &
+                  .GT. random_function( iran_part ) )  THEN
+                collection_probability = FLOOR(collection_probability) + 1.0_wp
+             ELSE
+                collection_probability = FLOOR(collection_probability)
+             ENDIF
+
+             IF ( collection_probability .GT. 0.0 )  THEN
+!
+!--             Super-droplet n collects droplets of super-droplet m
+                IF ( weight(n) .LT. weight(m) )  THEN
+
+                   mass(n)   = mass(n)   + weight(n) * xm * collection_probability
+                   weight(m) = weight(m) - weight(n)      * collection_probability
+                   mass(m)   = mass(m)   - weight(n) * xm * collection_probability
+                   IF ( curvature_solution_effects )  THEN
+                      aero_mass(n) = aero_mass(n) + weight(n) * xsm * collection_probability
+                      aero_mass(m) = aero_mass(m) - weight(n) * xsm * collection_probability
+                   ENDIF
+
+                ELSEIF ( weight(m) .LT. weight(n) )  THEN
+
+                   mass(m)   = mass(m)   + weight(m) * xn * collection_probability
+                   weight(n) = weight(n) - weight(m)      * collection_probability
+                   mass(n)   = mass(n)   - weight(m) * xn * collection_probability
+                   IF ( curvature_solution_effects )  THEN
+                      aero_mass(m) = aero_mass(m) + weight(m) * xsn * collection_probability
+                      aero_mass(n) = aero_mass(n) - weight(m) * xsn * collection_probability
+                   ENDIF
+
+                ELSE
+!
+!--                Collisions of particles of the same weighting factor.
+!--                Particle n collects 1/2 weight(n) droplets of particle m,
+!--                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.
 !--
-!--                   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).
-                      weight(n) = weight(n) - 0.5_wp * weight(n) *             &
-                                              ckernel(n,m,1) * weight(m) *     &
-                                              ddV * dt_3d
-                      IF ( n .NE. m )  THEN
-                         weight(m) = weight(m) - 0.5_wp * weight(m) *          &
-                                                 ckernel(n,m,1) * weight(n) *  &
-                                                 ddV * dt_3d
-                      ENDIF
+!--                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 )
+                   IF ( curvature_solution_effects )  THEN
+                      aero_mass(n) = aero_mass(n) + 0.5_wp * weight(n) * ( xsm - xsn )
+                      aero_mass(m) = aero_mass(m) + 0.5_wp * weight(m) * ( xsn - xsm )
                    ENDIF
-
-
-                ENDDO
-
-                ql_vp(k,j,i) = ql_vp(k,j,i) + mass(n) / factor_volume_to_mass
-
-             ENDDO
-
-          ELSEIF ( all_or_nothing )  THEN  ! select collision algorithm
-
-             DO  n = 1, number_of_particles
-
-                xn = mass(n) / weight(n) ! mean mass of droplet n
-
-                DO  m = n, number_of_particles
-
-                   xm = mass(m) / weight(m) !mean mass of droplet m
-
-                   IF ( weight(n) .LT. weight(m) )  THEN
-!
-!--                   Particle n collects smaller particle m 
-                      collection_probability = ckernel(n,m,1) * weight(m) *    &
-                                               ddV * dt_3d
-
-                      IF ( collection_probability .GT. random_function( iran_part ) )  THEN
-                         mass(n)   = mass(n)   + weight(n) * xm  
-                         weight(m) = weight(m) - weight(n)
-                         mass(m)   = mass(m)   - weight(n) * xm
-                      ENDIF
-
-                   ELSEIF ( weight(m) .LT. weight(n) )  THEN
-!
-!--                   Particle m collects smaller particle n
-                      collection_probability = ckernel(n,m,1) * weight(n) *    &
-                                               ddV * dt_3d
-
-                      IF ( collection_probability .GT. random_function( iran_part ) )  THEN
-                         mass(m)   = mass(m)   + weight(m) * xn
-                         weight(n) = weight(n) - weight(m)
-                         mass(n)   = mass(n)   - weight(m) * xn
-                      ENDIF
-                   ELSE
-!
-!--                   Collisions of particles of the same weighting factor. 
-!--                   Particle n collects 1/2 weight(n) droplets of particle m,
-!--                   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.
-!--
-!--                   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).
-                      collection_probability = ckernel(n,m,1) * weight(n) *    &
-                                               ddV * dt_3d
-
-                      IF ( collection_probability .GT. random_function( iran_part ) )  THEN
-                         mass(n)   = mass(n)   + 0.5_wp * weight(n) * ( xm - xn )
-                         mass(m)   = mass(m)   + 0.5_wp * weight(m) * ( xn - xm )
-                         weight(n) = weight(n) - 0.5_wp * weight(m)
-                         weight(m) = weight(n)
-                      ENDIF
-                   ENDIF
-
-
-                ENDDO
-
-                ql_vp(k,j,i) = ql_vp(k,j,i) + mass(n) / factor_volume_to_mass
-
-             ENDDO
-
-          ENDIF
-
-          IF ( ANY(weight < 0.0_wp) )  THEN
-                WRITE( message_string, * ) 'negative weighting factor'
-                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       &
-                                                      )                               &
-                                                    )**0.33333333333333_wp
-
-          particles(1:number_of_particles)%weight_factor = weight(1:number_of_particles)
-
-          DEALLOCATE( weight, mass, ckernel )
-
-       ENDIF
- 
+                   weight(n) = weight(n) - 0.5_wp * weight(m)
+                   weight(m) = weight(n)
+
+                ENDIF
+
+             ENDIF
+
+          ENDDO
+
+          ql_vp(k,j,i) = ql_vp(k,j,i) + mass(n) / factor_volume_to_mass
+
+       ENDDO
+
+       IF ( ANY(weight < 0.0_wp) )  THEN
+             WRITE( message_string, * ) 'negative weighting factor'
+             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       &
+                                                   )                               &
+                                                 )**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   &
+                                                    )                                  &
+                                                  )**0.33333333333333_wp
+       ENDIF
+
+       particles(1:number_of_particles)%weight_factor = weight(1:number_of_particles)
+
+       DEALLOCATE( weight, mass )
+       IF ( curvature_solution_effects )  DEALLOCATE( aero_mass )
+       IF ( .NOT. use_kernel_tables )  DEALLOCATE( ckernel )
+
 !
 !--    Check if LWC is conserved during collision process
@@ -532,5 +352,5 @@
 
     ENDIF
- 
+
     CALL cpu_log( log_point_s(43), 'lpm_droplet_coll', 'stop' )
 
