source: palm/trunk/SOURCE/lpm_collision_kernels.f90 @ 1318

Last change on this file since 1318 was 1318, checked in by raasch, 8 years ago

former files/routines cpu_log and cpu_statistics combined to one module,
which also includes the former data module cpulog from the modules-file,
module interfaces removed

  • Property svn:keywords set to Id
File size: 36.1 KB
Line 
1 MODULE lpm_collision_kernels_mod
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-2014 Leibniz Universitaet Hannover
18!--------------------------------------------------------------------------------!
19!
20! Current revisions:
21! -----------------
22! module interfaces removed
23!
24! Former revisions:
25! -----------------
26! $Id: lpm_collision_kernels.f90 1318 2014-03-17 13:35:16Z raasch $
27!
28! 1092 2013-02-02 11:24:22Z raasch
29! unused variables removed
30!
31! 1071 2012-11-29 16:54:55Z franke
32! Bugfix: collision efficiencies for Hall kernel should not be < 1.0E-20
33!
34! 1036 2012-10-22 13:43:42Z raasch
35! code put under GPL (PALM 3.9)
36!
37! 1007 2012-09-19 14:30:36Z franke
38! converted all units to SI units and replaced some parameters by corresponding
39! PALM parameters
40! Bugfix: factor in calculation of enhancement factor for collision efficencies
41! changed from 10. to 1.0
42!
43! 849 2012-03-15 10:35:09Z raasch
44! routine collision_efficiency_rogers added (moved from former advec_particles
45! to here)
46!
47! 835 2012-02-22 11:21:19Z raasch $
48! Bugfix: array diss can be used only in case of Wang kernel
49!
50! 828 2012-02-21 12:00:36Z raasch
51! code has been completely reformatted, routine colker renamed
52! recalculate_kernel,
53! routine init_kernels added, radius is now communicated to the collision
54! routines by array radclass
55!
56! Bugfix: transformation factor for dissipation changed from 1E5 to 1E4
57!
58! 825 2012-02-19 03:03:44Z raasch
59! routine renamed from wang_kernel to lpm_collision_kernels,
60! turbulence_effects on collision replaced by wang_kernel
61!
62! 799 2011-12-21 17:48:03Z franke
63! speed optimizations and formatting
64! Bugfix: iq=1 is not allowed (routine effic)
65! Bugfix: replaced stop by ec=0.0 in case of very small ec (routine effic)
66!
67! 790 2011-11-29 03:11:20Z raasch
68! initial revision
69!
70! Description:
71! ------------
72! This module calculates collision efficiencies either due to pure gravitational
73! effects (Hall kernel, see Hall, 1980: J. Atmos. Sci., 2486-2507) or
74! including the effects of (SGS) turbulence (Wang kernel, see Wang and
75! Grabowski, 2009: Atmos. Sci. Lett., 10, 1-8). The original code has been
76! provided by L.-P. Wang but is substantially reformatted and speed optimized
77! here.
78!
79! ATTENTION:
80! Physical quantities (like g, densities, etc.) used in this module still
81! have to be adjusted to those values used in the main PALM code.
82! Also, quantities in CGS-units should be converted to SI-units eventually.
83!------------------------------------------------------------------------------!
84
85    USE arrays_3d
86    USE cloud_parameters
87    USE constants
88    USE particle_attributes
89    USE pegrid
90
91
92    IMPLICIT NONE
93
94    PRIVATE
95
96    PUBLIC  ckernel, collision_efficiency_rogers, init_kernels, &
97            rclass_lbound, rclass_ubound, recalculate_kernel
98
99    REAL ::  epsilon, eps2, rclass_lbound, rclass_ubound, urms, urms2
100
101    REAL, DIMENSION(:),   ALLOCATABLE ::  epsclass, radclass, winf
102    REAL, DIMENSION(:,:), ALLOCATABLE ::  ec, ecf, gck, hkernel, hwratio
103    REAL, DIMENSION(:,:,:), ALLOCATABLE ::  ckernel
104
105    SAVE
106
107!
108!-- Public interfaces
109    INTERFACE collision_efficiency_rogers
110       MODULE PROCEDURE collision_efficiency_rogers
111    END INTERFACE collision_efficiency_rogers
112
113    INTERFACE init_kernels
114       MODULE PROCEDURE init_kernels
115    END INTERFACE init_kernels
116
117    INTERFACE recalculate_kernel
118       MODULE PROCEDURE recalculate_kernel
119    END INTERFACE recalculate_kernel
120
121
122    CONTAINS
123
124
125    SUBROUTINE init_kernels
126!------------------------------------------------------------------------------!
127! Initialization of the collision efficiency matrix with fixed radius and
128! dissipation classes, calculated at simulation start only.
129!------------------------------------------------------------------------------!
130
131       IMPLICIT NONE
132
133       INTEGER ::  i, j, k
134
135
136!
137!--    Calculate collision efficiencies for fixed radius- and dissipation
138!--    classes
139       IF ( collision_kernel(6:9) == 'fast' )  THEN
140
141          ALLOCATE( ckernel(1:radius_classes,1:radius_classes,               &
142                    0:dissipation_classes), epsclass(1:dissipation_classes), &
143                    radclass(1:radius_classes) )
144
145!
146!--       Calculate the radius class bounds with logarithmic distances
147!--       in the interval [1.0E-6, 2.0E-4] m
148          rclass_lbound = LOG( 1.0E-6 )
149          rclass_ubound = LOG( 2.0E-4 )
150          radclass(1)   = 1.0E-6
151          DO  i = 2, radius_classes
152             radclass(i) = EXP( rclass_lbound +                                &
153                                ( rclass_ubound - rclass_lbound ) * ( i-1.0 ) /&
154                                ( radius_classes - 1.0 ) )
155!             IF ( myid == 0 )  THEN
156!                PRINT*, 'i=', i, ' r = ', radclass(i)*1.0E6
157!             ENDIF
158          ENDDO
159
160!
161!--       Set the class bounds for dissipation in interval [0.0, 0.1] m**2/s**3
162          DO  i = 1, dissipation_classes
163             epsclass(i) = 0.1 * REAL( i ) / dissipation_classes
164!             IF ( myid == 0 )  THEN
165!                PRINT*, 'i=', i, ' eps = ', epsclass(i)
166!             ENDIF
167          ENDDO
168!
169!--       Calculate collision efficiencies of the Wang/ayala kernel
170          ALLOCATE( ec(1:radius_classes,1:radius_classes),  &
171                    ecf(1:radius_classes,1:radius_classes), &
172                    gck(1:radius_classes,1:radius_classes), &
173                    winf(1:radius_classes) )
174
175          DO  k = 1, dissipation_classes
176
177             epsilon = epsclass(k)
178             urms    = 2.02 * ( epsilon / 0.04 )**( 1.0 / 3.0 )
179
180             CALL turbsd
181             CALL turb_enhance_eff
182             CALL effic
183
184             DO  j = 1, radius_classes
185                DO  i = 1, radius_classes
186                   ckernel(i,j,k) = ec(i,j) * gck(i,j) * ecf(i,j)
187                ENDDO
188             ENDDO
189
190          ENDDO
191
192!
193!--       Calculate collision efficiencies of the Hall kernel
194          ALLOCATE( hkernel(1:radius_classes,1:radius_classes), &
195                    hwratio(1:radius_classes,1:radius_classes) )
196
197          CALL fallg
198          CALL effic
199
200          DO  j = 1, radius_classes
201             DO  i =  1, radius_classes
202                hkernel(i,j) = pi * ( radclass(j) + radclass(i) )**2 &
203                                  * ec(i,j) * ABS( winf(j) - winf(i) )
204                ckernel(i,j,0) = hkernel(i,j)  ! hall kernel stored on index 0
205              ENDDO
206          ENDDO
207
208!
209!--       Test output of efficiencies
210          IF ( j == -1 )  THEN
211
212             PRINT*, '*** Hall kernel'
213             WRITE ( *,'(5X,20(F4.0,1X))' ) ( radclass(i)*1.0E6, &
214                                              i = 1,radius_classes )
215             DO  j = 1, radius_classes
216                WRITE ( *,'(F4.0,1X,20(F8.4,1X))' ) radclass(j),  &
217                                          ( hkernel(i,j), i = 1,radius_classes )
218             ENDDO
219
220             DO  k = 1, dissipation_classes
221                DO  i = 1, radius_classes
222                   DO  j = 1, radius_classes
223                      IF ( hkernel(i,j) == 0.0 )  THEN
224                         hwratio(i,j) = 9999999.9
225                      ELSE
226                         hwratio(i,j) = ckernel(i,j,k) / hkernel(i,j)
227                      ENDIF
228                   ENDDO
229                ENDDO
230
231                PRINT*, '*** epsilon = ', epsclass(k)
232                WRITE ( *,'(5X,20(F4.0,1X))' ) ( radclass(i)*1.0E6, &
233                                                 i = 1,radius_classes )
234                DO  j = 1, radius_classes
235!                   WRITE ( *,'(F4.0,1X,20(F4.2,1X))' ) radclass(j)*1.0E6, &
236!                                       ( ckernel(i,j,k), i = 1,radius_classes )
237                   WRITE ( *,'(F4.0,1X,20(F8.4,1X))' ) radclass(j)*1.0E6, &
238                                          ( hwratio(i,j), i = 1,radius_classes )
239                ENDDO
240             ENDDO
241
242          ENDIF
243
244          DEALLOCATE( ec, ecf, epsclass, gck, hkernel, winf )
245
246       ELSEIF( collision_kernel == 'hall'  .OR.  collision_kernel == 'wang' ) &
247       THEN
248!
249!--       Initial settings for Hall- and Wang-Kernel
250!--       To be done: move here parts from turbsd, fallg, ecoll, etc.
251       ENDIF
252
253    END SUBROUTINE init_kernels
254
255
256!------------------------------------------------------------------------------!
257! Calculation of collision kernels during each timestep and for each grid box
258!------------------------------------------------------------------------------!
259    SUBROUTINE recalculate_kernel( i1, j1, k1 )
260
261       USE arrays_3d
262       USE cloud_parameters
263       USE constants
264       USE cpulog
265       USE indices
266       USE particle_attributes
267
268       IMPLICIT NONE
269
270       INTEGER ::  i, i1, j, j1, k1, pend, pstart
271
272
273       pstart = prt_start_index(k1,j1,i1)
274       pend   = prt_start_index(k1,j1,i1) + prt_count(k1,j1,i1) - 1
275       radius_classes = prt_count(k1,j1,i1)
276
277       ALLOCATE( ec(1:radius_classes,1:radius_classes), &
278                 radclass(1:radius_classes), winf(1:radius_classes) )
279
280!
281!--    Store particle radii on the radclass array
282       radclass(1:radius_classes) = particles(pstart:pend)%radius
283
284       IF ( wang_kernel )  THEN
285          epsilon = diss(k1,j1,i1)   ! dissipation rate in m**2/s**3
286       ELSE
287          epsilon = 0.0
288       ENDIF
289       urms    = 2.02 * ( epsilon / 0.04 )**( 0.33333333333 )
290
291       IF ( wang_kernel  .AND.  epsilon > 1.0E-7 )  THEN
292!
293!--       Call routines to calculate efficiencies for the Wang kernel
294          ALLOCATE( gck(1:radius_classes,1:radius_classes), &
295                    ecf(1:radius_classes,1:radius_classes) )
296
297          CALL turbsd
298          CALL turb_enhance_eff
299          CALL effic
300
301          DO  j = 1, radius_classes
302             DO  i =  1, radius_classes
303                ckernel(pstart+i-1,pstart+j-1,1) = ec(i,j) * gck(i,j) * ecf(i,j)
304             ENDDO
305          ENDDO
306
307          DEALLOCATE( gck, ecf )
308
309       ELSE
310!
311!--       Call routines to calculate efficiencies for the Hall kernel
312          CALL fallg
313          CALL effic
314
315          DO  j = 1, radius_classes
316             DO  i =  1, radius_classes
317                ckernel(pstart+i-1,pstart+j-1,1) = pi *                       &
318                                          ( radclass(j) + radclass(i) )**2    &
319                                          * ec(i,j) * ABS( winf(j) - winf(i) )
320             ENDDO
321          ENDDO
322
323       ENDIF
324
325       DEALLOCATE( ec, radclass, winf )
326
327    END SUBROUTINE recalculate_kernel
328
329
330!------------------------------------------------------------------------------!
331! Calculation of gck
332! This is from Aayala 2008b, page 37ff.
333! Necessary input parameters: water density, radii of droplets, air density,
334! air viscosity, turbulent dissipation rate, taylor microscale reynolds number,
335! gravitational acceleration  --> to be replaced by PALM parameters
336!------------------------------------------------------------------------------!
337    SUBROUTINE turbsd
338
339       USE constants
340       USE cloud_parameters
341       USE particle_attributes
342       USE arrays_3d
343       USE control_parameters
344
345       IMPLICIT NONE
346
347       INTEGER ::  i, j
348
349       LOGICAL, SAVE ::  first = .TRUE.
350
351       REAL ::  ao, ao_gr, bbb, be, b1, b2, ccc, c1, c1_gr, c2, d1, d2, eta, &
352                e1, e2, fao_gr, fr, grfin, lambda, lambda_re, lf, rc, rrp,   &
353                sst, tauk, tl, t2, tt, t1, vk, vrms1xy, vrms2xy, v1, v1v2xy, &
354                v1xysq, v2, v2xysq, wrfin, wrgrav2, wrtur2xy, xx, yy, z
355
356       REAL, DIMENSION(1:radius_classes) ::  st, tau
357
358
359!
360!--    Initial assignment of constants
361       IF ( first )  THEN
362
363          first = .FALSE.
364
365       ENDIF
366
367       lambda    = urms * SQRT( 15.0 * molecular_viscosity / epsilon )    ! in m
368       lambda_re = urms**2 * SQRT( 15.0 / epsilon / molecular_viscosity )
369       tl        = urms**2 / epsilon                       ! in s
370       lf        = 0.5 * urms**3 / epsilon                 ! in m
371       tauk      = SQRT( molecular_viscosity / epsilon )                  ! in s
372       eta       = ( molecular_viscosity**3 / epsilon )**0.25             ! in m
373       vk        = eta / tauk
374
375       ao = ( 11.0 + 7.0 * lambda_re ) / ( 205.0 + lambda_re )
376       tt = SQRT( 2.0 * lambda_re / ( SQRT( 15.0 ) * ao ) ) * tauk   ! in s
377
378       CALL fallg    ! gives winf in m/s
379
380       DO  i = 1, radius_classes
381          tau(i) = winf(i) / g    ! in s
382          st(i)  = tau(i) / tauk
383       ENDDO
384
385!
386!--    Calculate wr (from Aayala 2008b, page 38f)
387       z   = tt / tl
388       be  = SQRT( 2.0 ) * lambda / lf
389       bbb = SQRT( 1.0 - 2.0 * be**2 )
390       d1  = ( 1.0 + bbb ) / ( 2.0 * bbb )
391       e1  = lf * ( 1.0 + bbb ) * 0.5   ! in m
392       d2  = ( 1.0 - bbb ) * 0.5 / bbb
393       e2  = lf * ( 1.0 - bbb ) * 0.5   ! in m
394       ccc = SQRT( 1.0 - 2.0 * z**2 )
395       b1  = ( 1.0 + ccc ) * 0.5 / ccc
396       c1  = tl * ( 1.0 + ccc ) * 0.5   ! in s
397       b2  = ( 1.0 - ccc ) * 0.5 / ccc
398       c2  = tl * ( 1.0 - ccc ) * 0.5   ! in s
399
400       DO  i = 1, radius_classes
401
402          v1 = winf(i)        ! in m/s
403          t1 = tau(i)         ! in s
404
405          DO  j = 1, i
406             rrp = radclass(i) + radclass(j)
407             v2  = winf(j)                                 ! in m/s
408             t2  = tau(j)                                  ! in s
409
410             v1xysq  = b1 * d1 * phi_w(c1,e1,v1,t1) - b1 * d2 * phi_w(c1,e2,v1,t1) &
411                     - b2 * d1 * phi_w(c2,e1,v1,t1) + b2 * d2 * phi_w(c2,e2,v1,t1)
412             v1xysq  = v1xysq * urms**2 / t1                ! in m**2/s**2
413             vrms1xy = SQRT( v1xysq )                       ! in m/s
414
415             v2xysq  = b1 * d1 * phi_w(c1,e1,v2,t2) - b1 * d2 * phi_w(c1,e2,v2,t2) &
416                     - b2 * d1 * phi_w(c2,e1,v2,t2) + b2 * d2 * phi_w(c2,e2,v2,t2)
417             v2xysq  = v2xysq * urms**2 / t2                ! in m**2/s**2
418             vrms2xy = SQRT( v2xysq )                       ! in m/s
419
420             IF ( winf(i) >= winf(j) )  THEN
421                v1 = winf(i)
422                t1 = tau(i)
423                v2 = winf(j)
424                t2 = tau(j)
425             ELSE
426                v1 = winf(j)
427                t1 = tau(j)
428                v2 = winf(i)
429                t2 = tau(i)
430             ENDIF
431
432             v1v2xy   =  b1 * d1 * zhi(c1,e1,v1,t1,v2,t2) - &
433                         b1 * d2 * zhi(c1,e2,v1,t1,v2,t2) - &
434                         b2 * d1 * zhi(c2,e1,v1,t1,v2,t2) + &
435                         b2 * d2* zhi(c2,e2,v1,t1,v2,t2)
436             fr       = d1 * EXP( -rrp / e1 ) - d2 * EXP( -rrp / e2 )
437             v1v2xy   = v1v2xy * fr * urms**2 / tau(i) / tau(j)  ! in m**2/s**2
438             wrtur2xy = vrms1xy**2 + vrms2xy**2 - 2.0 * v1v2xy   ! in m**2/s**2
439             IF ( wrtur2xy < 0.0 )  wrtur2xy = 0.0
440             wrgrav2  = pi / 8.0 * ( winf(j) - winf(i) )**2
441             wrfin    = SQRT( ( 2.0 / pi ) * ( wrtur2xy + wrgrav2) )   ! in m/s
442
443!
444!--          Calculate gr
445             IF ( st(j) > st(i) )  THEN
446                sst = st(j)
447             ELSE
448                sst = st(i)
449             ENDIF
450
451             xx = -0.1988 * sst**4 + 1.5275 * sst**3 - 4.2942 * sst**2 + &
452                   5.3406 * sst
453             IF ( xx < 0.0 )  xx = 0.0
454             yy = 0.1886 * EXP( 20.306 / lambda_re )
455
456             c1_gr  =  xx / ( g / vk * tauk )**yy
457
458             ao_gr  = ao + ( pi / 8.0) * ( g / vk * tauk )**2
459             fao_gr = 20.115 * SQRT( ao_gr / lambda_re )
460             rc     = SQRT( fao_gr * ABS( st(j) - st(i) ) ) * eta   ! in cm
461
462             grfin  = ( ( eta**2 + rc**2 ) / ( rrp**2 + rc**2) )**( c1_gr*0.5 )
463             IF ( grfin < 1.0 )  grfin = 1.0
464
465             gck(i,j) = 2.0 * pi * rrp**2 * wrfin * grfin           ! in cm**3/s
466             gck(j,i) = gck(i,j)
467
468          ENDDO
469       ENDDO
470
471    END SUBROUTINE turbsd
472
473
474!------------------------------------------------------------------------------!
475! phi_w as a function
476!------------------------------------------------------------------------------!
477    REAL FUNCTION phi_w( a, b, vsett, tau0 )
478
479       IMPLICIT NONE
480
481       REAL ::  a, aa1, b, tau0, vsett
482
483       aa1 = 1.0 / tau0 + 1.0 / a + vsett / b
484       phi_w = 1.0 / aa1  - 0.5 * vsett / b / aa1**2  ! in s
485
486    END FUNCTION phi_w
487
488
489!------------------------------------------------------------------------------!
490! zhi as a function
491!------------------------------------------------------------------------------!
492    REAL FUNCTION zhi( a, b, vsett1, tau1, vsett2, tau2 )
493
494       IMPLICIT NONE
495
496       REAL ::  a, aa1, aa2, aa3, aa4, aa5, aa6, b, tau1, tau2, vsett1, vsett2
497
498       aa1 = vsett2 / b - 1.0 / tau2 - 1.0 / a
499       aa2 = vsett1 / b + 1.0 / tau1 + 1.0 / a
500       aa3 = ( vsett1 - vsett2 ) / b + 1.0 / tau1 + 1.0 / tau2
501       aa4 = ( vsett2 / b )**2 - ( 1.0 / tau2 + 1.0 / a )**2
502       aa5 = vsett2 / b + 1.0 / tau2 + 1.0 / a
503       aa6 = 1.0 / tau1 - 1.0 / a + ( 1.0 / tau2 + 1.0 / a) * vsett1 / vsett2
504       zhi = (1.0 / aa1 - 1.0 / aa2 ) * ( vsett1 - vsett2 ) * 0.5 / b / aa3**2 &
505           + (4.0 / aa4 - 1.0 / aa5**2 - 1.0 / aa1**2 ) * vsett2 * 0.5 / b /aa6&
506           + (2.0 * ( b / aa2 - b / aa1 ) - vsett1 / aa2**2 + vsett2 / aa1**2 )&
507           * 0.5 / b / aa3      ! in s**2
508
509    END FUNCTION zhi
510
511
512!------------------------------------------------------------------------------!
513! Calculation of terminal velocity winf following Equations 10-138 to 10-145
514! from (Pruppacher and Klett, 1997)
515!------------------------------------------------------------------------------!
516    SUBROUTINE fallg
517
518       USE constants
519       USE cloud_parameters
520       USE particle_attributes
521       USE arrays_3d
522       USE control_parameters
523
524       IMPLICIT NONE
525
526       INTEGER ::  i, j
527
528       LOGICAL, SAVE ::  first = .TRUE.
529
530       REAL, SAVE ::  cunh, eta, phy, py, rho_a, sigma, stb, stok, xlamb
531
532       REAL ::  bond, x, xrey, y
533
534       REAL, DIMENSION(1:7), SAVE  ::  b
535       REAL, DIMENSION(1:6), SAVE  ::  c
536
537!
538!--    Initial assignment of constants
539       IF ( first )  THEN
540
541          first = .FALSE.
542          b = (/  -0.318657E1,  0.992696E0, -0.153193E-2, -0.987059E-3, &
543                 -0.578878E-3, 0.855176E-4, -0.327815E-5 /)
544          c = (/  -0.500015E1,  0.523778E1,  -0.204914E1,   0.475294E0, &
545                 -0.542819E-1, 0.238449E-2 /)
546
547!
548!--       Parameter values for p = 1013,25 hPa and T = 293,15 K
549          eta   = 1.818E-5         ! in kg/(m s)
550          xlamb = 6.6E-8           ! in m
551          rho_a = 1.204            ! in kg/m**3
552          cunh  = 1.26 * xlamb     ! in m
553          sigma = 0.07363          ! in kg/s**2
554          stok  = 2.0  * g * ( rho_l - rho_a ) / ( 9.0 * eta ) ! in 1/(m s)
555          stb   = 32.0 * rho_a * ( rho_l - rho_a) * g / (3.0 * eta * eta)
556          phy   = sigma**3 * rho_a**2 / ( eta**4 * g * ( rho_l - rho_a ) )
557          py    = phy**( 1.0 / 6.0 )
558
559       ENDIF
560
561       DO  j = 1, radius_classes
562
563          IF ( radclass(j) <= 1.0E-5 ) THEN
564
565             winf(j) = stok * ( radclass(j)**2 + cunh * radclass(j) )
566
567          ELSEIF ( radclass(j) > 1.0E-5  .AND.  radclass(j) <= 5.35E-4 )  THEN
568
569             x = LOG( stb * radclass(j)**3 )
570             y = 0.0
571
572             DO  i = 1, 7
573                y = y + b(i) * x**(i-1)
574             ENDDO
575!
576!--          Note: this Eq. is wrong in (Pruppacher and Klett, 1997, p. 418)
577!--          for correct version see (Beard, 1976)
578             xrey = ( 1.0 + cunh / radclass(j) ) * EXP( y ) 
579
580             winf(j) = xrey * eta / ( 2.0 * rho_a * radclass(j) )
581
582          ELSEIF ( radclass(j) > 5.35E-4 )  THEN
583
584             IF ( radclass(j) > 0.0035 )  THEN
585                bond = g * ( rho_l - rho_a ) * 0.0035**2 / sigma
586             ELSE
587               bond = g * ( rho_l - rho_a ) * radclass(j)**2 / sigma
588             ENDIF
589
590             x = LOG( 16.0 * bond * py / 3.0 )
591             y = 0.0
592
593             DO  i = 1, 6
594                y = y + c(i) * x**(i-1)
595             ENDDO
596
597             xrey = py * EXP( y )
598
599             IF ( radclass(j) > 0.0035 )  THEN
600                winf(j) = xrey * eta / ( 2.0 * rho_a * 0.0035 )
601             ELSE
602                winf(j) = xrey * eta / ( 2.0 * rho_a * radclass(j) )
603             ENDIF
604
605          ENDIF
606
607       ENDDO
608
609    END SUBROUTINE fallg
610
611
612!------------------------------------------------------------------------------!
613! Calculation of collision efficiencies for the Hall kernel
614!------------------------------------------------------------------------------!
615    SUBROUTINE effic
616
617       USE arrays_3d
618       USE cloud_parameters
619       USE constants
620       USE particle_attributes
621
622       IMPLICIT NONE
623
624       INTEGER ::  i, iq, ir, j, k
625
626       INTEGER, DIMENSION(:), ALLOCATABLE ::  ira
627
628       LOGICAL, SAVE ::  first = .TRUE.
629
630       REAL ::  ek, particle_radius, pp, qq, rq
631
632       REAL, DIMENSION(1:21), SAVE ::  rat
633       REAL, DIMENSION(1:15), SAVE ::  r0
634       REAL, DIMENSION(1:15,1:21), SAVE ::  ecoll
635
636!
637!--    Initial assignment of constants
638       IF ( first )  THEN
639
640         first = .FALSE.
641         r0  = (/ 6.0, 8.0, 10.0, 15.0, 20.0, 25.0, 30.0, 40.0, 50.0, 60., &
642                  70.0, 100.0, 150.0, 200.0, 300.0 /)
643         rat = (/ 0.00, 0.05, 0.10, 0.15, 0.20, 0.25, 0.30, 0.35, 0.40, 0.45, &
644                  0.50, 0.55, 0.60, 0.65, 0.70, 0.75, 0.80, 0.85, 0.90, 0.95, &
645                  1.00 /)
646
647         ecoll(:,1) = (/0.001, 0.001, 0.001, 0.001, 0.001, 0.001, 0.001, &
648                        0.001, 0.001, 0.001, 0.001, 0.001, 0.001, 0.001, 0.001/)
649         ecoll(:,2) = (/0.003, 0.003, 0.003, 0.004, 0.005, 0.005, 0.005, &
650                        0.010, 0.100, 0.050, 0.200, 0.500, 0.770, 0.870, 0.970/)
651         ecoll(:,3) = (/0.007, 0.007, 0.007, 0.008, 0.009, 0.010, 0.010, &
652                        0.070, 0.400, 0.430, 0.580, 0.790, 0.930, 0.960, 1.000/)
653         ecoll(:,4) = (/0.009, 0.009, 0.009, 0.012, 0.015, 0.010, 0.020, &
654                        0.280, 0.600, 0.640, 0.750, 0.910, 0.970, 0.980, 1.000/)
655         ecoll(:,5) = (/0.014, 0.014, 0.014, 0.015, 0.016, 0.030, 0.060, &
656                        0.500, 0.700, 0.770, 0.840, 0.950, 0.970, 1.000, 1.000/)
657         ecoll(:,6) = (/0.017, 0.017, 0.017, 0.020, 0.022, 0.060, 0.100, &
658                        0.620, 0.780, 0.840, 0.880, 0.950, 1.000, 1.000, 1.000/)
659         ecoll(:,7) = (/0.030, 0.030, 0.024, 0.022, 0.032, 0.062, 0.200, &
660                        0.680, 0.830, 0.870, 0.900, 0.950, 1.000, 1.000, 1.000/)
661         ecoll(:,8) = (/0.025, 0.025, 0.025, 0.036, 0.043, 0.130, 0.270, &
662                        0.740, 0.860, 0.890, 0.920, 1.000, 1.000, 1.000, 1.000/)
663         ecoll(:,9) = (/0.027, 0.027, 0.027, 0.040, 0.052, 0.200, 0.400, &
664                        0.780, 0.880, 0.900, 0.940, 1.000, 1.000, 1.000, 1.000/)
665         ecoll(:,10)= (/0.030, 0.030, 0.030, 0.047, 0.064, 0.250, 0.500, &
666                        0.800, 0.900, 0.910, 0.950, 1.000, 1.000, 1.000, 1.000/)
667         ecoll(:,11)= (/0.040, 0.040, 0.033, 0.037, 0.068, 0.240, 0.550, &
668                        0.800, 0.900, 0.910, 0.950, 1.000, 1.000, 1.000, 1.000/)
669         ecoll(:,12)= (/0.035, 0.035, 0.035, 0.055, 0.079, 0.290, 0.580, &
670                        0.800, 0.900, 0.910, 0.950, 1.000, 1.000, 1.000, 1.000/)
671         ecoll(:,13)= (/0.037, 0.037, 0.037, 0.062, 0.082, 0.290, 0.590, &
672                        0.780, 0.900, 0.910, 0.950, 1.000, 1.000, 1.000, 1.000/)
673         ecoll(:,14)= (/0.037, 0.037, 0.037, 0.060, 0.080, 0.290, 0.580, &
674                        0.770, 0.890, 0.910, 0.950, 1.000, 1.000, 1.000, 1.000/)
675         ecoll(:,15)= (/0.037, 0.037, 0.037, 0.041, 0.075, 0.250, 0.540, &
676                        0.760, 0.880, 0.920, 0.950, 1.000, 1.000, 1.000, 1.000/)
677         ecoll(:,16)= (/0.037, 0.037, 0.037, 0.052, 0.067, 0.250, 0.510, &
678                        0.770, 0.880, 0.930, 0.970, 1.000, 1.000, 1.000, 1.000/)
679         ecoll(:,17)= (/0.037, 0.037, 0.037, 0.047, 0.057, 0.250, 0.490, &
680                        0.770, 0.890, 0.950, 1.000, 1.000, 1.000, 1.000, 1.000/)
681         ecoll(:,18)= (/0.036, 0.036, 0.036, 0.042, 0.048, 0.230, 0.470, &
682                        0.780, 0.920, 1.000, 1.020, 1.020, 1.020, 1.020, 1.020/)
683         ecoll(:,19)= (/0.040, 0.040, 0.035, 0.033, 0.040, 0.112, 0.450, &
684                        0.790, 1.010, 1.030, 1.040, 1.040, 1.040, 1.040, 1.040/)
685         ecoll(:,20)= (/0.033, 0.033, 0.033, 0.033, 0.033, 0.119, 0.470, &
686                        0.950, 1.300, 1.700, 2.300, 2.300, 2.300, 2.300, 2.300/)
687         ecoll(:,21)= (/0.027, 0.027, 0.027, 0.027, 0.027, 0.125, 0.520, &
688                        1.400, 2.300, 3.000, 4.000, 4.000, 4.000, 4.000, 4.000/)
689       ENDIF
690
691!
692!--    Calculate the radius class index of particles with respect to array r
693!--    Radius has to be in µm
694       ALLOCATE( ira(1:radius_classes) )
695       DO  j = 1, radius_classes
696          particle_radius = radclass(j) * 1.0E6
697          DO  k = 1, 15
698             IF ( particle_radius < r0(k) )  THEN
699                ira(j) = k
700                EXIT
701             ENDIF
702          ENDDO
703          IF ( particle_radius >= r0(15) )  ira(j) = 16
704       ENDDO
705
706!
707!--    Two-dimensional linear interpolation of the collision efficiency.
708!--    Radius has to be in µm
709       DO  j = 1, radius_classes
710          DO  i = 1, j
711
712             ir = ira(j)
713             rq = radclass(i) / radclass(j)
714             iq = INT( rq * 20 ) + 1
715             iq = MAX( iq , 2)
716
717             IF ( ir < 16 )  THEN
718                IF ( ir >= 2 )  THEN
719                   pp = ( ( radclass(j) * 1.0E06 ) - r0(ir-1) ) / &
720                        ( r0(ir) - r0(ir-1) )
721                   qq = ( rq- rat(iq-1) ) / ( rat(iq) - rat(iq-1) )
722                   ec(j,i) = ( 1.0-pp ) * ( 1.0-qq ) * ecoll(ir-1,iq-1)  &
723                             + pp * ( 1.0-qq ) * ecoll(ir,iq-1)          &
724                             + qq * ( 1.0-pp ) * ecoll(ir-1,iq)          &
725                             + pp * qq * ecoll(ir,iq)
726                ELSE
727                   qq = ( rq - rat(iq-1) ) / ( rat(iq) - rat(iq-1) )
728                   ec(j,i) = (1.0-qq) * ecoll(1,iq-1) + qq * ecoll(1,iq)
729                ENDIF
730             ELSE
731                qq = ( rq - rat(iq-1) ) / ( rat(iq) - rat(iq-1) )
732                ek = ( 1.0 - qq ) * ecoll(15,iq-1) + qq * ecoll(15,iq)
733                ec(j,i) = MIN( ek, 1.0 )
734             ENDIF
735
736             IF ( ec(j,i) < 1.0E-20 )  ec(j,i) = 0.0
737
738             ec(i,j) = ec(j,i)
739
740          ENDDO
741       ENDDO
742
743       DEALLOCATE( ira )
744
745    END SUBROUTINE effic
746
747
748!------------------------------------------------------------------------------!
749! Calculation of enhancement factor for collision efficencies due to turbulence
750!------------------------------------------------------------------------------!
751    SUBROUTINE turb_enhance_eff
752
753       USE constants
754       USE cloud_parameters
755       USE particle_attributes
756       USE arrays_3d
757
758       IMPLICIT NONE
759
760       INTEGER :: i, iq, ir, j, k, kk
761
762       INTEGER, DIMENSION(:), ALLOCATABLE ::  ira
763
764       REAL ::  particle_radius, pp, qq, rq, y1, y2, y3
765
766       LOGICAL, SAVE ::  first = .TRUE.
767
768       REAL, DIMENSION(1:11), SAVE ::  rat
769       REAL, DIMENSION(1:7), SAVE  ::  r0
770       REAL, DIMENSION(1:7,1:11), SAVE ::  ecoll_100, ecoll_400
771
772!
773!--    Initial assignment of constants
774       IF ( first )  THEN
775
776          first = .FALSE.
777
778          r0  = (/ 10.0, 20.0, 30.0, 40.0, 50.0, 60.0, 100.0 /)
779          rat = (/ 0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0 /)
780!
781!--       for 100 cm**2/s**3
782          ecoll_100(:,1) = (/1.74,  1.74,  1.773, 1.49,  1.207,  1.207,  1.0 /)
783          ecoll_100(:,2) = (/1.46,  1.46,  1.421, 1.245, 1.069,  1.069,  1.0 /)
784          ecoll_100(:,3) = (/1.32,  1.32,  1.245, 1.123, 1.000,  1.000,  1.0 /)
785          ecoll_100(:,4) = (/1.250, 1.250, 1.148, 1.087, 1.025,  1.025,  1.0 /)
786          ecoll_100(:,5) = (/1.186, 1.186, 1.066, 1.060, 1.056,  1.056,  1.0 /)
787          ecoll_100(:,6) = (/1.045, 1.045, 1.000, 1.014, 1.028,  1.028,  1.0 /)
788          ecoll_100(:,7) = (/1.070, 1.070, 1.030, 1.038, 1.046,  1.046,  1.0 /)
789          ecoll_100(:,8) = (/1.000, 1.000, 1.054, 1.042, 1.029,  1.029,  1.0 /)
790          ecoll_100(:,9) = (/1.223, 1.223, 1.117, 1.069, 1.021,  1.021,  1.0 /)
791          ecoll_100(:,10)= (/1.570, 1.570, 1.244, 1.166, 1.088,  1.088,  1.0 /)
792          ecoll_100(:,11)= (/20.3,  20.3,  14.6 , 8.61,  2.60,   2.60 ,  1.0 /)
793!
794!--       for 400 cm**2/s**3
795          ecoll_400(:,1) = (/4.976, 4.976,  3.593, 2.519, 1.445,  1.445,  1.0 /)
796          ecoll_400(:,2) = (/2.984, 2.984,  2.181, 1.691, 1.201,  1.201,  1.0 /)
797          ecoll_400(:,3) = (/1.988, 1.988,  1.475, 1.313, 1.150,  1.150,  1.0 /)
798          ecoll_400(:,4) = (/1.490, 1.490,  1.187, 1.156, 1.126,  1.126,  1.0 /)
799          ecoll_400(:,5) = (/1.249, 1.249,  1.088, 1.090, 1.092,  1.092,  1.0 /)
800          ecoll_400(:,6) = (/1.139, 1.139,  1.130, 1.091, 1.051,  1.051,  1.0 /)
801          ecoll_400(:,7) = (/1.220, 1.220,  1.190, 1.138, 1.086,  1.086,  1.0 /)
802          ecoll_400(:,8) = (/1.325, 1.325,  1.267, 1.165, 1.063,  1.063,  1.0 /)
803          ecoll_400(:,9) = (/1.716, 1.716,  1.345, 1.223, 1.100,  1.100,  1.0 /)
804          ecoll_400(:,10)= (/3.788, 3.788,  1.501, 1.311, 1.120,  1.120,  1.0 /)
805          ecoll_400(:,11)= (/36.52, 36.52,  19.16, 22.80,  26.0,   26.0,  1.0 /)
806
807       ENDIF
808
809!
810!--    Calculate the radius class index of particles with respect to array r0
811!--    Radius has to be in µm
812       ALLOCATE( ira(1:radius_classes) )
813
814       DO  j = 1, radius_classes
815          particle_radius = radclass(j) * 1.0E6
816          DO  k = 1, 7
817             IF ( particle_radius < r0(k) )  THEN
818                ira(j) = k
819                EXIT
820             ENDIF
821          ENDDO
822          IF ( particle_radius >= r0(7) )  ira(j) = 8
823       ENDDO
824
825!
826!--    Two-dimensional linear interpolation of the collision efficiencies
827!--    Radius has to be in µm
828       DO  j =  1, radius_classes
829          DO  i = 1, j
830
831             ir = ira(j)
832             rq = radclass(i) / radclass(j)
833
834             DO  kk = 2, 11
835                IF ( rq <= rat(kk) )  THEN
836                   iq = kk
837                   EXIT
838                ENDIF
839             ENDDO
840
841             y1 = 0.0001      ! for 0 m**2/s**3
842
843             IF ( ir < 8 )  THEN
844                IF ( ir >= 2 )  THEN
845                   pp = ( radclass(j)*1.0E6 - r0(ir-1) ) / ( r0(ir) - r0(ir-1) )
846                   qq = ( rq - rat(iq-1) ) / ( rat(iq) - rat(iq-1) )
847                   y2 = ( 1.0-pp ) * ( 1.0-qq ) * ecoll_100(ir-1,iq-1) +  &
848                                pp * ( 1.0-qq ) * ecoll_100(ir,iq-1)   +  &
849                                qq * ( 1.0-pp ) * ecoll_100(ir-1,iq)   +  &
850                                pp * qq         * ecoll_100(ir,iq)
851                   y3 = ( 1.0-pp ) * ( 1.0-qq ) * ecoll_400(ir-1,iq-1) +  &
852                                pp * ( 1.0-qq ) * ecoll_400(ir,iq-1)   +  &
853                                qq * ( 1.0-pp ) * ecoll_400(ir-1,iq)   +  &
854                                pp * qq         * ecoll_400(ir,iq)
855                ELSE
856                   qq = ( rq - rat(iq-1) ) / ( rat(iq) - rat(iq-1) )
857                   y2 = ( 1.0-qq ) * ecoll_100(1,iq-1) + qq * ecoll_100(1,iq)
858                   y3 = ( 1.0-qq ) * ecoll_400(1,iq-1) + qq * ecoll_400(1,iq)
859                ENDIF
860             ELSE
861                qq = ( rq - rat(iq-1) ) / ( rat(iq) - rat(iq-1) )
862                y2 = ( 1.0-qq ) * ecoll_100(7,iq-1) + qq * ecoll_100(7,iq)
863                y3 = ( 1.0-qq ) * ecoll_400(7,iq-1) + qq * ecoll_400(7,iq)
864             ENDIF
865!
866!--          Linear interpolation of dissipation rate in m**2/s**3
867             IF ( epsilon <= 0.01 )  THEN
868                ecf(j,i) = ( epsilon - 0.01 ) / (   0.0 - 0.01 ) * y1 &
869                         + ( epsilon -   0.0 ) / ( 0.01 -   0.0 ) * y2
870             ELSEIF ( epsilon <= 0.06 )  THEN
871                ecf(j,i) = ( epsilon - 0.04 ) / ( 0.01 - 0.04 ) * y2 &
872                         + ( epsilon - 0.01 ) / ( 0.04 - 0.01 ) * y3
873             ELSE
874                ecf(j,i) = (   0.06 - 0.04 ) / ( 0.01 - 0.04 ) * y2 &
875                         + (   0.06 - 0.01 ) / ( 0.04 - 0.01 ) * y3
876             ENDIF
877
878             IF ( ecf(j,i) < 1.0 )  ecf(j,i) = 1.0
879
880             ecf(i,j) = ecf(j,i)
881
882          ENDDO
883       ENDDO
884
885    END SUBROUTINE turb_enhance_eff
886
887
888
889    SUBROUTINE collision_efficiency_rogers( mean_r, r, e)
890!------------------------------------------------------------------------------!
891! Collision efficiencies from table 8.2 in Rogers and Yau (1989, 3rd edition).
892! Values are calculated from table by bilinear interpolation.
893!------------------------------------------------------------------------------!
894
895       IMPLICIT NONE
896
897       INTEGER       ::  i, j, k
898
899       LOGICAL, SAVE ::  first = .TRUE.
900
901       REAL          ::  aa, bb, cc, dd, dx, dy, e, gg, mean_r, mean_rm, r, &
902                         rm, x, y
903
904       REAL, DIMENSION(1:9), SAVE      ::  collected_r = 0.0
905       REAL, DIMENSION(1:19), SAVE     ::  collector_r = 0.0
906       REAL, DIMENSION(1:9,1:19), SAVE ::  ef = 0.0
907
908       mean_rm = mean_r * 1.0E06
909       rm      = r      * 1.0E06
910
911       IF ( first )  THEN
912
913          collected_r = (/ 2.0, 3.0, 4.0, 6.0, 8.0, 10.0, 15.0, 20.0, 25.0 /)
914          collector_r = (/ 10.0, 20.0, 30.0, 40.0, 50.0, 60.0, 80.0, 100.0,  &
915                           150.0, 200.0, 300.0, 400.0, 500.0, 600.0, 1000.0, &
916                           1400.0, 1800.0, 2400.0, 3000.0 /)
917
918          ef(:,1) = (/0.017, 0.027, 0.037, 0.052, 0.052, 0.052, 0.052, 0.0, &
919                      0.0 /)
920          ef(:,2) = (/0.001, 0.016, 0.027, 0.060, 0.12, 0.17, 0.17, 0.17, 0.0 /)
921          ef(:,3) = (/0.001, 0.001, 0.02,  0.13,  0.28, 0.37, 0.54, 0.55, 0.47/)
922          ef(:,4) = (/0.001, 0.001, 0.02,  0.23,  0.4,  0.55, 0.7,  0.75, 0.75/)
923          ef(:,5) = (/0.01,  0.01,  0.03,  0.3,   0.4,  0.58, 0.73, 0.75, 0.79/)
924          ef(:,6) = (/0.01,  0.01,  0.13,  0.38,  0.57, 0.68, 0.80, 0.86, 0.91/)
925          ef(:,7) = (/0.01,  0.085, 0.23,  0.52,  0.68, 0.76, 0.86, 0.92, 0.95/)
926          ef(:,8) = (/0.01,  0.14,  0.32,  0.60,  0.73, 0.81, 0.90, 0.94, 0.96/)
927          ef(:,9) = (/0.025, 0.25,  0.43,  0.66,  0.78, 0.83, 0.92, 0.95, 0.96/)
928          ef(:,10)= (/0.039, 0.3,   0.46,  0.69,  0.81, 0.87, 0.93, 0.95, 0.96/)
929          ef(:,11)= (/0.095, 0.33,  0.51,  0.72,  0.82, 0.87, 0.93, 0.96, 0.97/)
930          ef(:,12)= (/0.098, 0.36,  0.51,  0.73,  0.83, 0.88, 0.93, 0.96, 0.97/)
931          ef(:,13)= (/0.1,   0.36,  0.52,  0.74,  0.83, 0.88, 0.93, 0.96, 0.97/)
932          ef(:,14)= (/0.17,  0.4,   0.54,  0.72,  0.83, 0.88, 0.94, 0.98, 1.0 /)
933          ef(:,15)= (/0.15,  0.37,  0.52,  0.74,  0.82, 0.88, 0.94, 0.98, 1.0 /)
934          ef(:,16)= (/0.11,  0.34,  0.49,  0.71,  0.83, 0.88, 0.94, 0.95, 1.0 /)
935          ef(:,17)= (/0.08,  0.29,  0.45,  0.68,  0.8,  0.86, 0.96, 0.94, 1.0 /)
936          ef(:,18)= (/0.04,  0.22,  0.39,  0.62,  0.75, 0.83, 0.92, 0.96, 1.0 /)
937          ef(:,19)= (/0.02,  0.16,  0.33,  0.55,  0.71, 0.81, 0.90, 0.94, 1.0 /)
938
939       ENDIF
940
941       DO  k = 1, 8
942          IF ( collected_r(k) <= mean_rm )  i = k
943       ENDDO
944
945       DO  k = 1, 18
946          IF ( collector_r(k) <= rm )  j = k
947       ENDDO
948
949       IF ( rm < 10.0 )  THEN
950          e = 0.0
951       ELSEIF ( mean_rm < 2.0 )  THEN
952          e = 0.001
953       ELSEIF ( mean_rm >= 25.0 )  THEN
954          IF( j <= 2 )  e = 0.0
955          IF( j == 3 )  e = 0.47
956          IF( j == 4 )  e = 0.8
957          IF( j == 5 )  e = 0.9
958          IF( j >=6  )  e = 1.0
959       ELSEIF ( rm >= 3000.0 )  THEN
960          IF( i == 1 )  e = 0.02
961          IF( i == 2 )  e = 0.16
962          IF( i == 3 )  e = 0.33
963          IF( i == 4 )  e = 0.55
964          IF( i == 5 )  e = 0.71
965          IF( i == 6 )  e = 0.81
966          IF( i == 7 )  e = 0.90
967          IF( i >= 8 )  e = 0.94
968       ELSE
969          = mean_rm - collected_r(i)
970          y  = rm - collector_r(j)
971          dx = collected_r(i+1) - collected_r(i)
972          dy = collector_r(j+1) - collector_r(j)
973          aa = x**2 + y**2
974          bb = ( dx - x )**2 + y**2
975          cc = x**2 + ( dy - y )**2
976          dd = ( dx - x )**2 + ( dy - y )**2
977          gg = aa + bb + cc + dd
978
979          e = ( (gg-aa)*ef(i,j) + (gg-bb)*ef(i+1,j) + (gg-cc)*ef(i,j+1) + &
980                (gg-dd)*ef(i+1,j+1) ) / (3.0*gg)
981       ENDIF
982
983    END SUBROUTINE collision_efficiency_rogers
984
985 END MODULE lpm_collision_kernels_mod
Note: See TracBrowser for help on using the repository browser.