source: palm/trunk/SOURCE/lpm_droplet_collision.f90 @ 1036

Last change on this file since 1036 was 1036, checked in by raasch, 9 years ago

code has been put under the GNU General Public License (v3)

  • Property svn:keywords set to Id
File size: 26.7 KB
Line 
1 SUBROUTINE lpm_droplet_collision
2
3!--------------------------------------------------------------------------------!
4! This file is part of PALM.
5!
6! PALM is free software: you can redistribute it and/or modify it under the terms
7! of the GNU General Public License as published by the Free Software Foundation,
8! either version 3 of the License, or (at your option) any later version.
9!
10! PALM is distributed in the hope that it will be useful, but WITHOUT ANY
11! WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
12! A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
13!
14! You should have received a copy of the GNU General Public License along with
15! PALM. If not, see <http://www.gnu.org/licenses/>.
16!
17! Copyright 1997-2012  Leibniz University Hannover
18!--------------------------------------------------------------------------------!
19!
20! Current revisions:
21! ------------------
22!
23!
24! Former revisions:
25! -----------------
26! $Id: lpm_droplet_collision.f90 1036 2012-10-22 13:43:42Z raasch $
27!
28! 849 2012-03-15 10:35:09Z raasch
29! initial revision (former part of advec_particles)
30!
31!
32! Description:
33! ------------
34! Calculates chang in droplet radius by collision. Droplet collision is
35! calculated for each grid box seperately. Collision is parameterized by
36! using collision kernels. Three different kernels are available:
37! PALM kernel: Kernel is approximated using a method from Rogers and
38!              Yau (1989, A Short Course in Cloud Physics, Pergamon Press).
39!              All droplets smaller than the treated one are represented by
40!              one droplet with mean features. Collision efficiencies are taken
41!              from the respective table in Rogers and Yau.
42! Hall kernel: Kernel from Hall (1980, J. Atmos. Sci., 2486-2507), which
43!              considers collision due to pure gravitational effects.
44! Wang kernel: Beside gravitational effects (treated with the Hall-kernel) also
45!              the effects of turbulence on the collision are considered using
46!              parameterizations of Ayala et al. (2008, New J. Phys., 10,
47!              075015) and Wang and Grabowski (2009, Atmos. Sci. Lett., 10,
48!              1-8). This kernel includes three possible effects of turbulence:
49!              the modification of the relative velocity between the droplets,
50!              the effect of preferential concentration, and the enhancement of
51!              collision efficiencies.
52!------------------------------------------------------------------------------!
53
54    USE arrays_3d
55    USE cloud_parameters
56    USE constants
57    USE control_parameters
58    USE cpulog
59    USE grid_variables
60    USE indices
61    USE interfaces
62    USE lpm_collision_kernels_mod
63    USE particle_attributes
64
65    IMPLICIT NONE
66
67    INTEGER ::  eclass, i, ii, inc, is, j, jj, js, k, kk, n, pse, psi,        &
68                rclass_l, rclass_s
69
70    REAL ::  aa, bb, cc, dd, delta_r, delta_v, gg, epsilon, integral, lw_max, &
71             mean_r, ql_int, ql_int_l, ql_int_u, u_int, u_int_l, u_int_u,     &
72             v_int, v_int_l, v_int_u, w_int, w_int_l, w_int_u, sl_r3, sl_r4,  &
73             x, y
74
75    TYPE(particle_type) ::  tmp_particle
76
77
78    CALL cpu_log( log_point_s(43), 'lpm_droplet_coll', 'start' )
79
80    DO  i = nxl, nxr
81       DO  j = nys, nyn
82          DO  k = nzb+1, nzt
83!
84!--          Collision requires at least two particles in the box
85             IF ( prt_count(k,j,i) > 1 )  THEN
86!
87!--             First, sort particles within the gridbox by their size,
88!--             using Shell's method (see Numerical Recipes)
89!--             NOTE: In case of using particle tails, the re-sorting of
90!--             ----  tails would have to be included here!
91                psi = prt_start_index(k,j,i) - 1
92                inc = 1
93                DO WHILE ( inc <= prt_count(k,j,i) )
94                   inc = 3 * inc + 1
95                ENDDO
96
97                DO WHILE ( inc > 1 )
98                   inc = inc / 3
99                   DO  is = inc+1, prt_count(k,j,i)
100                      tmp_particle = particles(psi+is)
101                      js = is
102                      DO WHILE ( particles(psi+js-inc)%radius >             &
103                                 tmp_particle%radius )
104                         particles(psi+js) = particles(psi+js-inc)
105                         js = js - inc
106                         IF ( js <= inc )  EXIT
107                      ENDDO
108                      particles(psi+js) = tmp_particle
109                   ENDDO
110                ENDDO
111
112                psi = prt_start_index(k,j,i)
113                pse = psi + prt_count(k,j,i)-1
114
115!
116!--             Now apply the different kernels
117                IF ( ( hall_kernel .OR. wang_kernel )  .AND.  &
118                     use_kernel_tables )  THEN
119!
120!--                Fast method with pre-calculated efficiencies for
121!--                discrete radius- and dissipation-classes.
122!
123!--                Determine dissipation class index of this gridbox
124                   IF ( wang_kernel )  THEN
125                      eclass = INT( diss(k,j,i) * 1.0E4 / 1000.0 * &
126                                    dissipation_classes ) + 1
127                      epsilon = diss(k,j,i)
128                   ELSE
129                      epsilon = 0.0
130                   ENDIF
131                   IF ( hall_kernel .OR. epsilon * 1.0E4 < 0.001 )  THEN
132                      eclass = 0   ! Hall kernel is used
133                   ELSE
134                      eclass = MIN( dissipation_classes, eclass )
135                   ENDIF
136
137                   DO  n = pse, psi+1, -1
138
139                      integral = 0.0
140                      lw_max   = 0.0
141                      rclass_l = particles(n)%class
142!
143!--                   Calculate growth of collector particle radius using all
144!--                   droplets smaller than current droplet
145                      DO  is = psi, n-1
146
147                         rclass_s = particles(is)%class
148                         integral = integral +                             &
149                                    ( particles(is)%radius**3 *            &
150                                      ckernel(rclass_l,rclass_s,eclass) *  &
151                                      particles(is)%weight_factor )
152!
153!--                      Calculate volume of liquid water of the collected
154!--                      droplets which is the maximum liquid water available
155!--                      for droplet growth   
156                         lw_max = lw_max + ( particles(is)%radius**3 * &
157                                             particles(is)%weight_factor )
158
159                      ENDDO
160
161!
162!--                   Change in radius of collector droplet due to collision
163                      delta_r = 1.0 / ( 3.0 * particles(n)%radius**2 ) * &
164                                integral * dt_3d * ddx * ddy / dz
165
166!
167!--                   Change in volume of collector droplet due to collision
168                      delta_v = particles(n)%weight_factor                  &
169                                * ( ( particles(n)%radius + delta_r )**3    &
170                                    - particles(n)%radius**3 )
171
172                      IF ( lw_max < delta_v  .AND.  delta_v > 0.0 )  THEN
173!-- replace by message call
174                         PRINT*, 'Particle has grown to much because the',  &
175                                 ' change of volume of particle is larger', &
176                                 ' than liquid water available!'
177
178                      ELSEIF ( lw_max == delta_v  .AND.  delta_v > 0.0 ) THEN
179!-- can this case really happen??
180                         DO  is = psi, n-1
181
182                            particles(is)%weight_factor = 0.0
183                            particle_mask(is)  = .FALSE.
184                            deleted_particles = deleted_particles + 1
185
186                         ENDDO
187
188                      ELSEIF ( lw_max > delta_v  .AND.  delta_v > 0.0 )  THEN
189!
190!--                      Calculate new weighting factor of collected droplets
191                         DO  is = psi, n-1
192
193                            rclass_s = particles(is)%class
194                            particles(is)%weight_factor = &
195                               particles(is)%weight_factor - &
196                               ( ( ckernel(rclass_l,rclass_s,eclass) * particles(is)%weight_factor &
197                                 / integral ) * delta_v )
198
199                            IF ( particles(is)%weight_factor < 0.0 )  THEN
200                                  WRITE( message_string, * ) 'negative ',   &
201                                                     'weighting factor: ',  &
202                                                  particles(is)%weight_factor
203                                  CALL message( 'lpm_droplet_collision', '', &
204                                                2, 2, -1, 6, 1 )
205
206                            ELSEIF ( particles(is)%weight_factor == 0.0 )  &
207                            THEN
208
209                                particles(is)%weight_factor = 0.0
210                                particle_mask(is)  = .FALSE.
211                                deleted_particles = deleted_particles + 1
212
213                            ENDIF
214
215                         ENDDO
216
217                      ENDIF
218
219                      particles(n)%radius = particles(n)%radius + delta_r
220                      ql_vp(k,j,i) = ql_vp(k,j,i) + particles(n)%weight_factor &
221                                                    * particles(n)%radius**3
222
223                   ENDDO
224
225                ELSEIF ( ( hall_kernel .OR. wang_kernel )  .AND.  &
226                         .NOT. use_kernel_tables )  THEN
227!
228!--                Collision efficiencies are calculated for every new
229!--                grid box. First, allocate memory for kernel table.
230!--                Third dimension is 1, because table is re-calculated for
231!--                every new dissipation value.
232                   ALLOCATE( ckernel(prt_start_index(k,j,i):                 &
233                             prt_start_index(k,j,i)+prt_count(k,j,i)-1,      &
234                             prt_start_index(k,j,i):                         &
235                             prt_start_index(k,j,i)+prt_count(k,j,i)-1,1:1) )
236!
237!--                Now calculate collision efficiencies for this box
238                   CALL recalculate_kernel( i, j, k )
239
240                   DO  n = pse, psi+1, -1
241
242                      integral = 0.0
243                      lw_max   = 0.0
244!
245!--                   Calculate growth of collector particle radius using all
246!--                   droplets smaller than current droplet
247                      DO  is = psi, n-1
248
249                         integral = integral + particles(is)%radius**3 * &
250                                               ckernel(n,is,1) *         &
251                                               particles(is)%weight_factor
252!
253!--                      Calculate volume of liquid water of the collected
254!--                      droplets which is the maximum liquid water available
255!--                      for droplet growth   
256                         lw_max = lw_max + ( particles(is)%radius**3 * &
257                                             particles(is)%weight_factor )
258
259                      ENDDO
260
261!
262!--                   Change in radius of collector droplet due to collision
263                      delta_r = 1.0 / ( 3.0 * particles(n)%radius**2 ) * &
264                                integral * dt_3d * ddx * ddy / dz
265
266!
267!--                   Change in volume of collector droplet due to collision
268                      delta_v = particles(n)%weight_factor                  &
269                                * ( ( particles(n)%radius + delta_r )**3    &
270                                    - particles(n)%radius**3 )
271
272                      IF ( lw_max < delta_v  .AND.  delta_v > 0.0 )  THEN
273!-- replace by message call
274                         PRINT*, 'Particle has grown to much because the',  &
275                                 ' change of volume of particle is larger', &
276                                 ' than liquid water available!'
277
278                      ELSEIF ( lw_max == delta_v  .AND.  delta_v > 0.0 ) THEN
279!-- can this case really happen??
280                         DO  is = psi, n-1
281
282                            particles(is)%weight_factor = 0.0
283                            particle_mask(is)  = .FALSE.
284                            deleted_particles = deleted_particles + 1
285
286                         ENDDO
287
288                      ELSEIF ( lw_max > delta_v  .AND.  delta_v > 0.0 )  THEN
289!
290!--                      Calculate new weighting factor of collected droplets
291                         DO  is = psi, n-1
292
293                            particles(is)%weight_factor =                   &
294                                   particles(is)%weight_factor -            &
295                                   ( ckernel(n,is,1) / integral * delta_v * &
296                                     particles(is)%weight_factor )
297
298                            IF ( particles(is)%weight_factor < 0.0 )  THEN
299                                  WRITE( message_string, * ) 'negative ',   &
300                                                     'weighting factor: ',  &
301                                                  particles(is)%weight_factor
302                                  CALL message( 'lpm_droplet_collision', '', &
303                                                2, 2, -1, 6, 1 )
304
305                            ELSEIF ( particles(is)%weight_factor == 0.0 )  &
306                            THEN
307
308                                particles(is)%weight_factor = 0.0
309                                particle_mask(is)  = .FALSE.
310                                deleted_particles = deleted_particles + 1
311
312                            ENDIF
313
314                         ENDDO
315
316                      ENDIF
317
318                      particles(n)%radius = particles(n)%radius + delta_r
319                      ql_vp(k,j,i) = ql_vp(k,j,i) + particles(n)%weight_factor &
320                                                    * particles(n)%radius**3
321
322                   ENDDO
323
324                   DEALLOCATE( ckernel )
325
326                ELSEIF ( palm_kernel )  THEN
327!
328!--                PALM collision kernel
329!
330!--                Calculate the mean radius of all those particles which
331!--                are of smaller size than the current particle and
332!--                use this radius for calculating the collision efficiency
333                   DO  n = psi+prt_count(k,j,i)-1, psi+1, -1
334
335                      sl_r3 = 0.0
336                      sl_r4 = 0.0
337
338                      DO is = n-1, psi, -1
339                         IF ( particles(is)%radius < particles(n)%radius )  &
340                         THEN
341                            sl_r3 = sl_r3 + particles(is)%weight_factor     &
342                                            * particles(is)%radius**3
343                            sl_r4 = sl_r4 + particles(is)%weight_factor     &
344                                            * particles(is)%radius**4
345                         ENDIF
346                      ENDDO
347
348                      IF ( ( sl_r3 ) > 0.0 )  THEN
349                         mean_r = ( sl_r4 ) / ( sl_r3 )
350
351                         CALL collision_efficiency_rogers( mean_r,             &
352                                                    particles(n)%radius,       &
353                                                    effective_coll_efficiency )
354
355                      ELSE
356                         effective_coll_efficiency = 0.0
357                      ENDIF
358
359                      IF ( effective_coll_efficiency > 1.0  .OR.            &
360                           effective_coll_efficiency < 0.0 )                &
361                      THEN
362                         WRITE( message_string, * )  'collision_efficien' , &
363                                   'cy out of range:' ,effective_coll_efficiency
364                         CALL message( 'lpm_droplet_collision', 'PA0145', 2, &
365                                       2, -1, 6, 1 )
366                      ENDIF
367
368!
369!--                   Interpolation of ...
370                      ii = particles(n)%x * ddx
371                      jj = particles(n)%y * ddy
372                      kk = ( particles(n)%z + 0.5 * dz ) / dz
373
374                      x  = particles(n)%x - ii * dx
375                      y  = particles(n)%y - jj * dy
376                      aa = x**2          + y**2
377                      bb = ( dx - x )**2 + y**2
378                      cc = x**2          + ( dy - y )**2
379                      dd = ( dx - x )**2 + ( dy - y )**2
380                      gg = aa + bb + cc + dd
381
382                      ql_int_l = ( (gg-aa) * ql(kk,jj,ii)   + (gg-bb) *     &
383                                                           ql(kk,jj,ii+1)   &
384                                 + (gg-cc) * ql(kk,jj+1,ii) + ( gg-dd ) *   &
385                                                           ql(kk,jj+1,ii+1) &
386                                 ) / ( 3.0 * gg )
387
388                      ql_int_u = ( (gg-aa) * ql(kk+1,jj,ii)   + (gg-bb) *   &
389                                                         ql(kk+1,jj,ii+1)   &
390                                 + (gg-cc) * ql(kk+1,jj+1,ii) + (gg-dd) *   &
391                                                         ql(kk+1,jj+1,ii+1) &
392                                 ) / ( 3.0 * gg )
393
394                      ql_int = ql_int_l + ( particles(n)%z - zu(kk) ) / dz *&
395                                          ( ql_int_u - ql_int_l )
396
397!
398!--                   Interpolate u velocity-component
399                      ii = ( particles(n)%x + 0.5 * dx ) * ddx
400                      jj =   particles(n)%y * ddy
401                      kk = ( particles(n)%z + 0.5 * dz ) / dz ! only if eqist
402
403                      IF ( ( particles(n)%z - zu(kk) ) > (0.5*dz) ) kk = kk+1
404
405                      x  = particles(n)%x + ( 0.5 - ii ) * dx
406                      y  = particles(n)%y - jj * dy
407                      aa = x**2          + y**2
408                      bb = ( dx - x )**2 + y**2
409                      cc = x**2          + ( dy - y )**2
410                      dd = ( dx - x )**2 + ( dy - y )**2
411                      gg = aa + bb + cc + dd
412
413                      u_int_l = ( (gg-aa) * u(kk,jj,ii)   + (gg-bb) *       &
414                                                           u(kk,jj,ii+1)    &
415                                + (gg-cc) * u(kk,jj+1,ii) + (gg-dd) *       &
416                                                           u(kk,jj+1,ii+1)  &
417                                ) / ( 3.0 * gg ) - u_gtrans
418                      IF ( kk+1 == nzt+1 )  THEN
419                         u_int = u_int_l
420                      ELSE
421                         u_int_u = ( (gg-aa) * u(kk+1,jj,ii)   + (gg-bb) *  &
422                                                          u(kk+1,jj,ii+1)   &
423                                   + (gg-cc) * u(kk+1,jj+1,ii) + (gg-dd) *  &
424                                                          u(kk+1,jj+1,ii+1) &
425                                   ) / ( 3.0 * gg ) - u_gtrans
426                         u_int = u_int_l + ( particles(n)%z - zu(kk) ) / dz &
427                                           * ( u_int_u - u_int_l )
428                      ENDIF
429
430!
431!--                   Same procedure for interpolation of the v velocity-com-
432!--                   ponent (adopt index k from u velocity-component)
433                      ii =   particles(n)%x * ddx
434                      jj = ( particles(n)%y + 0.5 * dy ) * ddy
435
436                      x  = particles(n)%x - ii * dx
437                      y  = particles(n)%y + ( 0.5 - jj ) * dy
438                      aa = x**2          + y**2
439                      bb = ( dx - x )**2 + y**2
440                      cc = x**2          + ( dy - y )**2
441                      dd = ( dx - x )**2 + ( dy - y )**2
442                      gg = aa + bb + cc + dd
443
444                      v_int_l = ( ( gg-aa ) * v(kk,jj,ii)   + ( gg-bb ) *   &
445                                                            v(kk,jj,ii+1)   &
446                                + ( gg-cc ) * v(kk,jj+1,ii) + ( gg-dd ) *   &
447                                                            v(kk,jj+1,ii+1) &
448                                ) / ( 3.0 * gg ) - v_gtrans
449                      IF ( kk+1 == nzt+1 )  THEN
450                         v_int = v_int_l
451                      ELSE
452                         v_int_u = ( (gg-aa) * v(kk+1,jj,ii)   + (gg-bb) *  &
453                                                            v(kk+1,jj,ii+1) &
454                                   + (gg-cc) * v(kk+1,jj+1,ii) + (gg-dd) *  &
455                                                          v(kk+1,jj+1,ii+1) &
456                                   ) / ( 3.0 * gg ) - v_gtrans
457                         v_int = v_int_l + ( particles(n)%z - zu(kk) ) / dz &
458                                           * ( v_int_u - v_int_l )
459                      ENDIF
460
461!
462!--                   Same procedure for interpolation of the w velocity-com-
463!--                   ponent (adopt index i from v velocity-component)
464                      jj = particles(n)%y * ddy
465                      kk = particles(n)%z / dz
466
467                      x  = particles(n)%x - ii * dx
468                      y  = particles(n)%y - jj * dy
469                      aa = x**2          + y**2
470                      bb = ( dx - x )**2 + y**2
471                      cc = x**2          + ( dy - y )**2
472                      dd = ( dx - x )**2 + ( dy - y )**2
473                      gg = aa + bb + cc + dd
474
475                      w_int_l = ( ( gg-aa ) * w(kk,jj,ii)   + ( gg-bb ) *   &
476                                                              w(kk,jj,ii+1) &
477                                + ( gg-cc ) * w(kk,jj+1,ii) + ( gg-dd ) *   &
478                                                            w(kk,jj+1,ii+1) &
479                                ) / ( 3.0 * gg )
480                      IF ( kk+1 == nzt+1 )  THEN
481                         w_int = w_int_l
482                      ELSE
483                         w_int_u = ( (gg-aa) * w(kk+1,jj,ii)   + (gg-bb) *  &
484                                                            w(kk+1,jj,ii+1) &
485                                   + (gg-cc) * w(kk+1,jj+1,ii) + (gg-dd) *  &
486                                                          w(kk+1,jj+1,ii+1) &
487                                   ) / ( 3.0 * gg )
488                         w_int = w_int_l + ( particles(n)%z - zw(kk) ) / dz &
489                                           * ( w_int_u - w_int_l )
490                      ENDIF
491
492!
493!--                   Change in radius due to collision
494                      delta_r = effective_coll_efficiency / 3.0             &
495                                * pi * sl_r3 * ddx * ddy / dz               &
496                                * SQRT( ( u_int - particles(n)%speed_x )**2 &
497                                      + ( v_int - particles(n)%speed_y )**2 &
498                                      + ( w_int - particles(n)%speed_z )**2 &
499                                      ) * dt_3d
500!
501!--                   Change in volume due to collision
502                      delta_v = particles(n)%weight_factor                  &
503                                * ( ( particles(n)%radius + delta_r )**3    &
504                                    - particles(n)%radius**3 )
505
506!
507!--                   Check if collected particles provide enough LWC for
508!--                   volume change of collector particle
509                      IF ( delta_v >= sl_r3  .AND.  sl_r3 > 0.0 )  THEN
510
511                         delta_r = ( ( sl_r3/particles(n)%weight_factor )   &
512                                     + particles(n)%radius**3 )**( 1./3. )  &
513                                     - particles(n)%radius
514
515                         DO  is = n-1, psi, -1
516                            IF ( particles(is)%radius < &
517                                 particles(n)%radius )  THEN
518                               particles(is)%weight_factor = 0.0
519                               particle_mask(is) = .FALSE.
520                               deleted_particles = deleted_particles + 1
521                            ENDIF
522                         ENDDO
523
524                      ELSE IF ( delta_v < sl_r3  .AND.  sl_r3 > 0.0 )  THEN
525
526                         DO  is = n-1, psi, -1
527                            IF ( particles(is)%radius < particles(n)%radius &
528                                 .AND.  sl_r3 > 0.0 )  THEN
529                               particles(is)%weight_factor =                &
530                                            ( ( particles(is)%weight_factor &
531                                            * ( particles(is)%radius**3 ) ) &
532                                            - ( delta_v                     &
533                                            * particles(is)%weight_factor   &
534                                            * ( particles(is)%radius**3 )   &
535                                            / sl_r3 ) )                     &
536                                            / ( particles(is)%radius**3 )
537
538                               IF ( particles(is)%weight_factor < 0.0 )  THEN
539                                  WRITE( message_string, * ) 'negative ',   &
540                                                  'weighting factor: ',     &
541                                                  particles(is)%weight_factor
542                                  CALL message( 'lpm_droplet_collision', '', &
543                                                2, 2, -1, 6, 1 )
544                               ENDIF
545                            ENDIF
546                         ENDDO
547
548                      ENDIF
549
550                      particles(n)%radius = particles(n)%radius + delta_r
551                      ql_vp(k,j,i) = ql_vp(k,j,i) +               &
552                                     particles(n)%weight_factor * &
553                                     ( particles(n)%radius**3 )
554                   ENDDO
555
556                ENDIF  ! collision kernel
557
558                ql_vp(k,j,i) = ql_vp(k,j,i) + particles(psi)%weight_factor  &
559                                              * particles(psi)%radius**3
560
561
562             ELSE IF ( prt_count(k,j,i) == 1 )  THEN
563
564                psi = prt_start_index(k,j,i)
565                ql_vp(k,j,i) =  particles(psi)%weight_factor *              &
566                                particles(psi)%radius**3
567             ENDIF
568
569!
570!--          Check if condensation of LWC was conserved during collision
571!--          process
572             IF ( ql_v(k,j,i) /= 0.0 )  THEN
573                IF ( ql_vp(k,j,i) / ql_v(k,j,i) >= 1.0001  .OR.             &
574                     ql_vp(k,j,i) / ql_v(k,j,i) <= 0.9999 )  THEN
575                   WRITE( message_string, * ) 'LWC is not conserved during',&
576                                              ' collision! ',               &
577                                              'LWC after condensation: ',   &
578                                              ql_v(k,j,i),                  &
579                                              ' LWC after collision: ',     &
580                                              ql_vp(k,j,i)
581                   CALL message( 'lpm_droplet_collision', '', 2, 2, -1, 6, 1 )
582                ENDIF
583             ENDIF
584
585          ENDDO
586       ENDDO
587    ENDDO
588
589    CALL cpu_log( log_point_s(43), 'lpm_droplet_coll', 'stop' )
590
591
592 END SUBROUTINE lpm_droplet_collision
Note: See TracBrowser for help on using the repository browser.