Ignore:
Timestamp:
Jul 14, 2017 8:26:51 PM (4 years ago)
Author:
hoffmann
Message:

various improvements of the LCM

File:
1 edited

Legend:

Unmodified
Added
Removed
  • palm/trunk/SOURCE/lpm_droplet_collision.f90

    r2274 r2312  
    2020! Current revisions:
    2121! ------------------
    22 ! 
    23 ! 
     22!
     23!
    2424! Former revisions:
    2525! -----------------
    2626! $Id$
     27! Consideration of aerosol mass during collision. Average impact algorithm has
     28! been removed.
     29!
     30! 2274 2017-06-09 13:27:48Z Giersch
    2731! Changed error messages
    2832!
     
    3943!
    4044! 1860 2016-04-13 13:21:28Z hoffmann
    41 ! Interpolation of dissipation rate adjusted to more reasonable values. 
     45! Interpolation of dissipation rate adjusted to more reasonable values.
    4246!
    4347! 1822 2016-04-07 07:49:42Z hoffmann
     
    4953!
    5054! 1682 2015-10-07 23:56:08Z knoop
    51 ! Code annotations made doxygen readable 
    52 ! 
     55! Code annotations made doxygen readable
     56!
    5357! 1359 2014-04-11 17:15:14Z hoffmann
    54 ! New particle structure integrated. 
     58! New particle structure integrated.
    5559! Kind definition added to all floating point numbers.
    5660!
     
    96100!>              the modification of the relative velocity between the droplets,
    97101!>              the effect of preferential concentration, and the enhancement of
    98 !>              collision efficiencies. 
     102!>              collision efficiencies.
    99103!------------------------------------------------------------------------------!
    100104 SUBROUTINE lpm_droplet_collision (i,j,k)
    101  
    102 
    103105
    104106    USE arrays_3d,                                                             &
     
    126128
    127129    USE particle_attributes,                                                   &
    128         ONLY:  all_or_nothing, average_impact, dissipation_classes,            &
    129                hall_kernel, iran_part, number_of_particles, particles,         &
    130                particle_type, prt_count, use_kernel_tables, wang_kernel
     130        ONLY:  curvature_solution_effects, dissipation_classes, hall_kernel,   &
     131               iran_part, number_of_particles, particles, particle_type,       &
     132               prt_count, rho_s, use_kernel_tables, wang_kernel
    131133
    132134    USE random_function_mod,                                                   &
     
    150152    REAL(wp) ::  epsilon                 !< dissipation rate
    151153    REAL(wp) ::  factor_volume_to_mass   !< 4.0 / 3.0 * pi * rho_l
    152     REAL(wp) ::  xm                      !< mean mass of droplet m
    153     REAL(wp) ::  xn                      !< mean mass of droplet n
    154 
    155     REAL(wp), DIMENSION(:), ALLOCATABLE ::  weight  !< weighting factor
    156     REAL(wp), DIMENSION(:), ALLOCATABLE ::  mass    !< total mass of super droplet
     154    REAL(wp) ::  xm                      !< droplet mass of super-droplet m
     155    REAL(wp) ::  xn                      !< droplet mass of super-droplet n
     156    REAL(wp) ::  xsm                     !< aerosol mass of super-droplet m
     157    REAL(wp) ::  xsn                     !< aerosol mass of super-droplet n
     158
     159    REAL(wp), DIMENSION(:), ALLOCATABLE ::  weight    !< weighting factor
     160    REAL(wp), DIMENSION(:), ALLOCATABLE ::  mass      !< total mass of super droplet
     161    REAL(wp), DIMENSION(:), ALLOCATABLE ::  aero_mass !< total aerosol mass of super droplet
    157162
    158163    CALL cpu_log( log_point_s(43), 'lpm_droplet_coll', 'start' )
    159164
    160165    number_of_particles   = prt_count(k,j,i)
    161     factor_volume_to_mass = 4.0_wp / 3.0_wp * pi * rho_l 
    162     ddV                   = 1 / ( dx * dy * dz )
     166    factor_volume_to_mass = 4.0_wp / 3.0_wp * pi * rho_l
     167    ddV                   = 1.0_wp / ( dx * dy * dz )
    163168!
    164169!-- Collision requires at least one super droplet inside the box
    165170    IF ( number_of_particles > 0 )  THEN
    166171
    167 !
    168 !--    Now apply the different kernels
    169172       IF ( use_kernel_tables )  THEN
    170173!
    171174!--       Fast method with pre-calculated collection kernels for
    172175!--       discrete radius- and dissipation-classes.
    173 !--
    174 !--       Determine dissipation class index of this gridbox
    175176          IF ( wang_kernel )  THEN
    176177             eclass = INT( diss(k,j,i) * 1.0E4_wp / 600.0_wp * &
     
    180181             epsilon = 0.0_wp
    181182          ENDIF
     183
    182184          IF ( hall_kernel  .OR.  epsilon * 1.0E4_wp < 0.001_wp )  THEN
    183185             eclass = 0   ! Hall kernel is used
     
    186188          ENDIF
    187189
    188 !
    189 !--       Droplet collision are calculated using collision-coalescence
    190 !--       formulation proposed by Wang (see PALM documentation)
    191 !--       Temporary fields for total mass of super-droplet and weighting factors
    192 !--       are allocated.
    193           ALLOCATE(mass(1:number_of_particles), weight(1:number_of_particles))
    194 
    195           mass(1:number_of_particles)   = particles(1:number_of_particles)%weight_factor * &
    196                                           particles(1:number_of_particles)%radius**3     * &
    197                                           factor_volume_to_mass
    198           weight(1:number_of_particles) = particles(1:number_of_particles)%weight_factor
    199 
    200           IF ( average_impact )  THEN  ! select collision algorithm
    201 
    202              DO  n = 1, number_of_particles
    203 
    204                 rclass_l = particles(n)%class
    205                 xn       = mass(n) / weight(n)
    206 
    207                 DO  m = n, number_of_particles
    208 
    209                    rclass_s = particles(m)%class
    210                    xm       = mass(m) / weight(m)
    211 
    212                    IF ( xm .LT. xn )  THEN
    213                      
    214 !
    215 !--                   Particle n collects smaller particle m
    216                       collection_probability = ckernel(rclass_l,rclass_s,eclass) * &
    217                                                weight(n) * ddV * dt_3d
    218 
    219                       mass(n)   = mass(n)   + mass(m)   * collection_probability
    220                       weight(m) = weight(m) - weight(m) * collection_probability
    221                       mass(m)   = mass(m)   - mass(m)   * collection_probability
    222                    ELSEIF ( xm .GT. xn )  THEN
    223 !
    224 !--                   Particle m collects smaller particle n
    225                       collection_probability = ckernel(rclass_l,rclass_s,eclass) * &
    226                                                weight(m) * ddV * dt_3d
    227 
    228                       mass(m)   = mass(m)   + mass(n)   * collection_probability
    229                       weight(n) = weight(n) - weight(n) * collection_probability
    230                       mass(n)   = mass(n)   - mass(n)   * collection_probability
    231                    ELSE
    232 !
    233 !--                   Same-size collections. If n = m, weight is reduced by the
    234 !--                   number of possible same-size collections; the total mass
    235 !--                   is not changed during same-size collection.
    236 !--                   Same-size collections of different
    237 !--                   particles ( n /= m ) are treated as same-size collections
    238 !--                   of ONE partilce with weight = weight(n) + weight(m) and
    239 !--                   mass = mass(n) + mass(m).
    240 !--                   Accordingly, each particle loses the same number of
    241 !--                   droplets to the other particle, but this has no effect on
    242 !--                   total mass mass, since the exchanged droplets have the
    243 !--                   same radius.
    244 
    245 !--                   Note: For m = n this equation is an approximation only
    246 !--                   valid for weight >> 1 (which is usually the case). The
    247 !--                   approximation is weight(n)-1 = weight(n).
    248                       weight(n) = weight(n) - 0.5_wp * weight(n) *                &
    249                                               ckernel(rclass_l,rclass_s,eclass) * &
    250                                               weight(m) * ddV * dt_3d
    251                       IF ( n .NE. m )  THEN
    252                          weight(m) = weight(m) - 0.5_wp * weight(m) *                &
    253                                                  ckernel(rclass_l,rclass_s,eclass) * &
    254                                                  weight(n) * ddV * dt_3d
    255                       ENDIF
    256                    ENDIF
    257 
    258                 ENDDO
    259 
    260                 ql_vp(k,j,i) = ql_vp(k,j,i) + mass(n) / factor_volume_to_mass
    261 
    262              ENDDO
    263 
    264           ELSEIF ( all_or_nothing )  THEN  ! select collision algorithm
    265 
    266              DO  n = 1, number_of_particles
    267 
    268                 rclass_l = particles(n)%class
    269                 xn       = mass(n) / weight(n) ! mean mass of droplet n
    270 
    271                 DO  m = n, number_of_particles
    272 
    273                    rclass_s = particles(m)%class
    274                    xm = mass(m) / weight(m) ! mean mass of droplet m
    275 
    276                    IF ( weight(n) .LT. weight(m) )  THEN
    277 !
    278 !--                   Particle n collects weight(n) droplets of particle m 
    279                       collection_probability = ckernel(rclass_l,rclass_s,eclass) * &
    280                                                weight(m) * ddV * dt_3d
    281 
    282                       IF ( collection_probability .GT. random_function( iran_part ) )  THEN
    283                          mass(n)   = mass(n)   + weight(n) * xm
    284                          weight(m) = weight(m) - weight(n)
    285                          mass(m)   = mass(m)   - weight(n) * xm
    286                       ENDIF
    287 
    288                    ELSEIF ( weight(m) .LT. weight(n) )  THEN
    289 !
    290 !--                   Particle m collects weight(m) droplets of particle n 
    291                       collection_probability = ckernel(rclass_l,rclass_s,eclass) * &
    292                                                weight(n) * ddV * dt_3d
    293 
    294                       IF ( collection_probability .GT. random_function( iran_part ) )  THEN
    295                          mass(m)   = mass(m)   + weight(m) * xn
    296                          weight(n) = weight(n) - weight(m)
    297                          mass(n)   = mass(n)   - weight(m) * xn
    298                       ENDIF
    299                    ELSE
    300 !
    301 !--                   Collisions of particles of the same weighting factor.
    302 !--                   Particle n collects 1/2 weight(n) droplets of particle m,
    303 !--                   particle m collects 1/2 weight(m) droplets of particle n.
    304 !--                   The total mass mass changes accordingly.
    305 !--                   If n = m, the first half of the droplets coalesces with the
    306 !--                   second half of the droplets; mass is unchanged because
    307 !--                   xm = xn for n = m.
    308 
    309 !--                   Note: For m = n this equation is an approximation only
    310 !--                   valid for weight >> 1 (which is usually the case). The
    311 !--                   approximation is weight(n)-1 = weight(n).
    312                       collection_probability = ckernel(rclass_l,rclass_s,eclass) * &
    313                                                weight(n) * ddV * dt_3d
    314 
    315                       IF ( collection_probability .GT. random_function( iran_part ) )  THEN
    316                          mass(n)   = mass(n)   + 0.5_wp * weight(n) * ( xm - xn )
    317                          mass(m)   = mass(m)   + 0.5_wp * weight(m) * ( xn - xm )
    318                          weight(n) = weight(n) - 0.5_wp * weight(m)
    319                          weight(m) = weight(n)
    320                       ENDIF
    321                    ENDIF
    322 
    323                 ENDDO
    324 
    325                 ql_vp(k,j,i) = ql_vp(k,j,i) + mass(n) / factor_volume_to_mass
    326 
    327              ENDDO
    328 
    329           ENDIF
    330 
    331 
    332 
    333 
    334           IF ( ANY(weight < 0.0_wp) )  THEN
    335                 WRITE( message_string, * ) 'negative weighting factor'
    336                 CALL message( 'lpm_droplet_collision', 'PA0028',      &
    337                                2, 2, -1, 6, 1 )
    338           ENDIF
    339 
    340           particles(1:number_of_particles)%radius = ( mass(1:number_of_particles) /   &
    341                                                       ( weight(1:number_of_particles) &
    342                                                         * factor_volume_to_mass       &
    343                                                       )                               &
    344                                                     )**0.33333333333333_wp
    345 
    346           particles(1:number_of_particles)%weight_factor = weight(1:number_of_particles)
    347 
    348           DEALLOCATE(weight, mass)
    349 
    350        ELSEIF ( .NOT. use_kernel_tables )  THEN
    351 !
    352 !--       Collection kernels are calculated for every new
     190       ELSE
     191!
     192!--       Collection kernels are re-calculated for every new
    353193!--       grid box. First, allocate memory for kernel table.
    354194!--       Third dimension is 1, because table is re-calculated for
     
    359199!--       the kernel is based on the previous time step
    360200          CALL recalculate_kernel( i, j, k )
    361 !
    362 !--       Droplet collision are calculated using collision-coalescence
    363 !--       formulation proposed by Wang (see PALM documentation)
    364 !--       Temporary fields for total mass of super-droplet and weighting factors
    365 !--       are allocated.
    366           ALLOCATE(mass(1:number_of_particles), weight(1:number_of_particles))
    367 
    368           mass(1:number_of_particles) = particles(1:number_of_particles)%weight_factor * &
    369                                         particles(1:number_of_particles)%radius**3     * &
    370                                         factor_volume_to_mass
    371 
    372           weight(1:number_of_particles) = particles(1:number_of_particles)%weight_factor
    373 
    374           IF ( average_impact )  THEN  ! select collision algorithm
    375 
    376              DO  n = 1, number_of_particles
    377 
    378                 xn = mass(n) / weight(n) ! mean mass of droplet n
    379 
    380                 DO  m = n, number_of_particles
    381 
    382                    xm = mass(m) / weight(m) !mean mass of droplet m
    383 
    384                    IF ( xm .LT. xn )  THEN
    385 !
    386 !--                   Particle n collects smaller particle m
    387                       collection_probability = ckernel(n,m,1) * weight(n) *    &
    388                                                ddV * dt_3d
    389 
    390                       mass(n)   = mass(n)   + mass(m)   * collection_probability
    391                       weight(m) = weight(m) - weight(m) * collection_probability
    392                       mass(m)   = mass(m)   - mass(m)   * collection_probability
    393                    ELSEIF ( xm .GT. xn )  THEN
    394 !
    395 !--                   Particle m collects smaller particle n
    396                       collection_probability = ckernel(n,m,1) * weight(m) *    &
    397                                                ddV * dt_3d
    398 
    399                       mass(m)   = mass(m)   + mass(n)   * collection_probability
    400                       weight(n) = weight(n) - weight(n) * collection_probability
    401                       mass(n)   = mass(n)   - mass(n)   * collection_probability
    402                    ELSE
    403 !
    404 !--                   Same-size collections. If n = m, weight is reduced by the
    405 !--                   number of possible same-size collections; the total mass
    406 !--                   mass is not changed during same-size collection.
    407 !--                   Same-size collections of different
    408 !--                   particles ( n /= m ) are treated as same-size collections
    409 !--                   of ONE partilce with weight = weight(n) + weight(m) and
    410 !--                   mass = mass(n) + mass(m).
    411 !--                   Accordingly, each particle loses the same number of
    412 !--                   droplets to the other particle, but this has no effect on
    413 !--                   total mass mass, since the exchanged droplets have the
    414 !--                   same radius.
     201
     202       ENDIF
     203!
     204!--    Temporary fields for total mass of super-droplet, aerosol mass, and
     205!--    weighting factor are allocated.
     206       ALLOCATE(mass(1:number_of_particles), weight(1:number_of_particles))
     207       IF ( curvature_solution_effects )  ALLOCATE(aero_mass(1:number_of_particles))
     208
     209       mass(1:number_of_particles)   = particles(1:number_of_particles)%weight_factor * &
     210                                       particles(1:number_of_particles)%radius**3     * &
     211                                       factor_volume_to_mass
     212
     213       weight(1:number_of_particles) = particles(1:number_of_particles)%weight_factor
     214
     215       IF ( curvature_solution_effects )  THEN
     216          aero_mass(1:number_of_particles) = particles(1:number_of_particles)%weight_factor * &
     217                                             particles(1:number_of_particles)%aux1**3       * &
     218                                             4.0 / 3.0 * pi * rho_s
     219       ENDIF
     220!
     221!--    Calculate collision/coalescence
     222       DO  n = 1, number_of_particles
     223
     224          DO  m = n, number_of_particles
     225!
     226!--          For collisions, the weighting factor of at least one super-droplet
     227!--          needs to be larger or equal to one.
     228             IF ( MIN( weight(n), weight(m) ) .LT. 1.0 )  CYCLE
     229!
     230!--          Get mass of individual droplets (aerosols)
     231             xn = mass(n) / weight(n)
     232             xm = mass(m) / weight(m)
     233             IF ( curvature_solution_effects )  THEN
     234                xsn = aero_mass(n) / weight(n)
     235                xsm = aero_mass(m) / weight(m)
     236             ENDIF
     237!
     238!--          Probability that the necessary collisions take place
     239             IF ( use_kernel_tables )  THEN
     240                rclass_l = particles(n)%class
     241                rclass_s = particles(m)%class
     242
     243                collection_probability  = MAX( weight(n), weight(m) ) *     &
     244                                          ckernel(rclass_l,rclass_s,eclass) * ddV * dt_3d
     245             ELSE
     246                collection_probability  = MAX( weight(n), weight(m) ) *     &
     247                                          ckernel(n,m,1) * ddV * dt_3d
     248             ENDIF
     249!
     250!--          Calculate the number of collections and consider multiple collections.
     251!--          (Accordingly, p_crit will be 0.0, 1.0, 2.0, ...)
     252             IF ( collection_probability - FLOOR(collection_probability)    &
     253                  .GT. random_function( iran_part ) )  THEN
     254                collection_probability = FLOOR(collection_probability) + 1.0_wp
     255             ELSE
     256                collection_probability = FLOOR(collection_probability)
     257             ENDIF
     258
     259             IF ( collection_probability .GT. 0.0 )  THEN
     260!
     261!--             Super-droplet n collects droplets of super-droplet m
     262                IF ( weight(n) .LT. weight(m) )  THEN
     263
     264                   mass(n)   = mass(n)   + weight(n) * xm * collection_probability
     265                   weight(m) = weight(m) - weight(n)      * collection_probability
     266                   mass(m)   = mass(m)   - weight(n) * xm * collection_probability
     267                   IF ( curvature_solution_effects )  THEN
     268                      aero_mass(n) = aero_mass(n) + weight(n) * xsm * collection_probability
     269                      aero_mass(m) = aero_mass(m) - weight(n) * xsm * collection_probability
     270                   ENDIF
     271
     272                ELSEIF ( weight(m) .LT. weight(n) )  THEN
     273
     274                   mass(m)   = mass(m)   + weight(m) * xn * collection_probability
     275                   weight(n) = weight(n) - weight(m)      * collection_probability
     276                   mass(n)   = mass(n)   - weight(m) * xn * collection_probability
     277                   IF ( curvature_solution_effects )  THEN
     278                      aero_mass(m) = aero_mass(m) + weight(m) * xsn * collection_probability
     279                      aero_mass(n) = aero_mass(n) - weight(m) * xsn * collection_probability
     280                   ENDIF
     281
     282                ELSE
     283!
     284!--                Collisions of particles of the same weighting factor.
     285!--                Particle n collects 1/2 weight(n) droplets of particle m,
     286!--                particle m collects 1/2 weight(m) droplets of particle n.
     287!--                The total mass mass changes accordingly.
     288!--                If n = m, the first half of the droplets coalesces with the
     289!--                second half of the droplets; mass is unchanged because
     290!--                xm = xn for n = m.
    415291!--
    416 !--                   Note: For m = n this equation is an approximation only
    417 !--                   valid for weight >> 1 (which is usually the case). The
    418 !--                   approximation is weight(n)-1 = weight(n).
    419                       weight(n) = weight(n) - 0.5_wp * weight(n) *             &
    420                                               ckernel(n,m,1) * weight(m) *     &
    421                                               ddV * dt_3d
    422                       IF ( n .NE. m )  THEN
    423                          weight(m) = weight(m) - 0.5_wp * weight(m) *          &
    424                                                  ckernel(n,m,1) * weight(n) *  &
    425                                                  ddV * dt_3d
    426                       ENDIF
     292!--                Note: For m = n this equation is an approximation only
     293!--                valid for weight >> 1 (which is usually the case). The
     294!--                approximation is weight(n)-1 = weight(n).
     295                   mass(n)   = mass(n)   + 0.5_wp * weight(n) * ( xm - xn )
     296                   mass(m)   = mass(m)   + 0.5_wp * weight(m) * ( xn - xm )
     297                   IF ( curvature_solution_effects )  THEN
     298                      aero_mass(n) = aero_mass(n) + 0.5_wp * weight(n) * ( xsm - xsn )
     299                      aero_mass(m) = aero_mass(m) + 0.5_wp * weight(m) * ( xsn - xsm )
    427300                   ENDIF
    428 
    429 
    430                 ENDDO
    431 
    432                 ql_vp(k,j,i) = ql_vp(k,j,i) + mass(n) / factor_volume_to_mass
    433 
    434              ENDDO
    435 
    436           ELSEIF ( all_or_nothing )  THEN  ! select collision algorithm
    437 
    438              DO  n = 1, number_of_particles
    439 
    440                 xn = mass(n) / weight(n) ! mean mass of droplet n
    441 
    442                 DO  m = n, number_of_particles
    443 
    444                    xm = mass(m) / weight(m) !mean mass of droplet m
    445 
    446                    IF ( weight(n) .LT. weight(m) )  THEN
    447 !
    448 !--                   Particle n collects smaller particle m
    449                       collection_probability = ckernel(n,m,1) * weight(m) *    &
    450                                                ddV * dt_3d
    451 
    452                       IF ( collection_probability .GT. random_function( iran_part ) )  THEN
    453                          mass(n)   = mass(n)   + weight(n) * xm 
    454                          weight(m) = weight(m) - weight(n)
    455                          mass(m)   = mass(m)   - weight(n) * xm
    456                       ENDIF
    457 
    458                    ELSEIF ( weight(m) .LT. weight(n) )  THEN
    459 !
    460 !--                   Particle m collects smaller particle n
    461                       collection_probability = ckernel(n,m,1) * weight(n) *    &
    462                                                ddV * dt_3d
    463 
    464                       IF ( collection_probability .GT. random_function( iran_part ) )  THEN
    465                          mass(m)   = mass(m)   + weight(m) * xn
    466                          weight(n) = weight(n) - weight(m)
    467                          mass(n)   = mass(n)   - weight(m) * xn
    468                       ENDIF
    469                    ELSE
    470 !
    471 !--                   Collisions of particles of the same weighting factor.
    472 !--                   Particle n collects 1/2 weight(n) droplets of particle m,
    473 !--                   particle m collects 1/2 weight(m) droplets of particle n.
    474 !--                   The total mass mass changes accordingly.
    475 !--                   If n = m, the first half of the droplets coalesces with the
    476 !--                   second half of the droplets; mass is unchanged because
    477 !--                   xm = xn for n = m.
    478 !--
    479 !--                   Note: For m = n this equation is an approximation only
    480 !--                   valid for weight >> 1 (which is usually the case). The
    481 !--                   approximation is weight(n)-1 = weight(n).
    482                       collection_probability = ckernel(n,m,1) * weight(n) *    &
    483                                                ddV * dt_3d
    484 
    485                       IF ( collection_probability .GT. random_function( iran_part ) )  THEN
    486                          mass(n)   = mass(n)   + 0.5_wp * weight(n) * ( xm - xn )
    487                          mass(m)   = mass(m)   + 0.5_wp * weight(m) * ( xn - xm )
    488                          weight(n) = weight(n) - 0.5_wp * weight(m)
    489                          weight(m) = weight(n)
    490                       ENDIF
    491                    ENDIF
    492 
    493 
    494                 ENDDO
    495 
    496                 ql_vp(k,j,i) = ql_vp(k,j,i) + mass(n) / factor_volume_to_mass
    497 
    498              ENDDO
    499 
    500           ENDIF
    501 
    502           IF ( ANY(weight < 0.0_wp) )  THEN
    503                 WRITE( message_string, * ) 'negative weighting factor'
    504                 CALL message( 'lpm_droplet_collision', 'PA0028',      &
    505                                2, 2, -1, 6, 1 )
    506           ENDIF
    507 
    508           particles(1:number_of_particles)%radius = ( mass(1:number_of_particles) /   &
    509                                                       ( weight(1:number_of_particles) &
    510                                                         * factor_volume_to_mass       &
    511                                                       )                               &
    512                                                     )**0.33333333333333_wp
    513 
    514           particles(1:number_of_particles)%weight_factor = weight(1:number_of_particles)
    515 
    516           DEALLOCATE( weight, mass, ckernel )
    517 
    518        ENDIF
    519  
     301                   weight(n) = weight(n) - 0.5_wp * weight(m)
     302                   weight(m) = weight(n)
     303
     304                ENDIF
     305
     306             ENDIF
     307
     308          ENDDO
     309
     310          ql_vp(k,j,i) = ql_vp(k,j,i) + mass(n) / factor_volume_to_mass
     311
     312       ENDDO
     313
     314       IF ( ANY(weight < 0.0_wp) )  THEN
     315             WRITE( message_string, * ) 'negative weighting factor'
     316             CALL message( 'lpm_droplet_collision', 'PA0028',      &
     317                            2, 2, -1, 6, 1 )
     318       ENDIF
     319
     320       particles(1:number_of_particles)%radius = ( mass(1:number_of_particles) /   &
     321                                                   ( weight(1:number_of_particles) &
     322                                                     * factor_volume_to_mass       &
     323                                                   )                               &
     324                                                 )**0.33333333333333_wp
     325
     326       IF ( curvature_solution_effects )  THEN
     327          particles(1:number_of_particles)%aux1 = ( aero_mass(1:number_of_particles) / &
     328                                                    ( weight(1:number_of_particles)    &
     329                                                      * 4.0_wp / 3.0_wp * pi * rho_s   &
     330                                                    )                                  &
     331                                                  )**0.33333333333333_wp
     332       ENDIF
     333
     334       particles(1:number_of_particles)%weight_factor = weight(1:number_of_particles)
     335
     336       DEALLOCATE( weight, mass )
     337       IF ( curvature_solution_effects )  DEALLOCATE( aero_mass )
     338       IF ( .NOT. use_kernel_tables )  DEALLOCATE( ckernel )
     339
    520340!
    521341!--    Check if LWC is conserved during collision process
     
    532352
    533353    ENDIF
    534  
     354
    535355    CALL cpu_log( log_point_s(43), 'lpm_droplet_coll', 'stop' )
    536356
Note: See TracChangeset for help on using the changeset viewer.