LCOV - code coverage report
Current view: | top level - chemistry/aerosol - aerosol_properties_mod.F90 (source / functions) |  |  | Hit | Total | Coverage
Test: | coverage.info |  | Lines: | 0 | 93 | 0.0 %
Date: | 2025-01-13 21:54:50 |  | Functions: | 0 | 14 | 0.0 %

              Line data    Source code
           1             : module aerosol_properties_mod
           2             :   use shr_kind_mod, only: r8 => shr_kind_r8
           3             :
           4             :   implicit none
           5             :
           6             :   private
           7             :
           8             :   public :: aerosol_properties
           9             :
          10             :   !> aerosol_properties defines the configuration of any aerosol package (using
          11             :   !! any aerosol representation) based on user specification. These values are
          12             :   !! set during initialization and do not vary during the simulation.
          13             :   !!
          14             :   !! Each aerosol package (e.g., MAM, CARMA, etc) must extend the abstract
          15             :   !! aerosol_properties class to define the details of their configuration. Any
          16             :   !! package must implement each of the deferred procedures of the abstract
          17             :   !! aerosol_properties class, may include additional private data members and
          18             :   !! type-bound procedures, and may override functions of the abstract class.
          19             :   !!
          20             :   !! Please see the modal_aerosol_properties module for an example of how the
          21             :   !! aerosol_properties class can be extended for a specific aerosol package.
          22             :   type, abstract :: aerosol_properties
          23             :      private
          24             :      integer :: nbins_ = 0  ! number of aerosol bins
          25             :      integer :: ncnst_tot_ = 0 ! total number of constituents
          26             :      integer, allocatable :: nmasses_(:) ! number of species masses
          27             :      integer, allocatable :: nspecies_(:) ! number of species
          28             :      integer, allocatable :: indexer_(:,:) ! unique indices of the aerosol elements
          29             :      real(r8), allocatable :: alogsig_(:) ! natural log of geometric deviation of the number distribution for aerosol bin
          30             :      real(r8), allocatable :: f1_(:) ! eq 28 Abdul-Razzak et al 1998
          31             :      real(r8), allocatable :: f2_(:) ! eq 29 Abdul-Razzak et al 1998
          32             :      ! Abdul-Razzak, H., S.J. Ghan, and C. Rivera-Carpio, A parameterization of aerosol activation,
          33             :      ! 1, Singleaerosoltype. J. Geophys. Res., 103, 6123-6132, 1998.
          34             :      real(r8) :: soa_equivso4_factor_ = -huge(1._r8)
          35             :      real(r8) :: pom_equivso4_factor_ = -huge(1._r8)
          36             :    contains
          37             :      procedure :: initialize => aero_props_init
          38             :      procedure,private :: nbins_0list
          39             :      procedure(aero_nbins_rlist), deferred :: nbins_rlist
          40             :      generic :: nbins => nbins_0list,nbins_rlist
          41             :      procedure :: ncnst_tot
          42             :      procedure,private :: nspecies_per_bin
          43             :      procedure(aero_nspecies_rlist), deferred :: nspecies_per_bin_rlist
          44             :      procedure,private :: nspecies_all_bins
          45             :      generic :: nspecies => nspecies_all_bins,nspecies_per_bin,nspecies_per_bin_rlist
          46             :      procedure,private :: n_masses_all_bins
          47             :      procedure,private :: n_masses_per_bin
          48             :      generic :: nmasses => n_masses_all_bins,n_masses_per_bin
          49             :      procedure :: indexer
          50             :      procedure :: maxsat
          51             :      procedure(aero_amcube), deferred :: amcube
          52             :      procedure :: alogsig_0list
          53             :      procedure(aero_alogsig_rlist), deferred :: alogsig_rlist
          54             :      generic :: alogsig =>  alogsig_0list,alogsig_rlist
          55             :      procedure(aero_number_transported), deferred :: number_transported
          56             :      procedure(aero_props_get), deferred :: get
          57             :      procedure(aero_actfracs), deferred :: actfracs
          58             :      procedure(aero_num_names), deferred :: num_names
          59             :      procedure(aero_mmr_names), deferred :: mmr_names
          60             :      procedure(aero_amb_num_name), deferred :: amb_num_name
          61             :      procedure(aero_amb_mmr_name), deferred :: amb_mmr_name
          62             :      procedure(aero_species_type), deferred :: species_type
          63             :      procedure(aero_icenuc_updates_num), deferred :: icenuc_updates_num
          64             :      procedure(aero_icenuc_updates_mmr), deferred :: icenuc_updates_mmr
          65             :      procedure(aero_apply_num_limits), deferred :: apply_number_limits
          66             :      procedure(aero_hetfrz_species), deferred :: hetfrz_species
          67             :      procedure :: soa_equivso4_factor ! SOA Hygroscopicity / Sulfate Hygroscopicity
          68             :      procedure :: pom_equivso4_factor ! POM Hygroscopicity / Sulfate Hygroscopicity
          69             :      procedure(aero_soluble), deferred :: soluble
          70             :      procedure(aero_min_mass_mean_rad), deferred :: min_mass_mean_rad
          71             :      procedure(aero_optics_params), deferred :: optics_params
          72             :      procedure(aero_bin_name), deferred :: bin_name
          73             :      procedure(aero_scav_diam), deferred :: scav_diam
          74             :      procedure(aero_resuspension_resize), deferred :: resuspension_resize
          75             :      procedure(aero_rebin_bulk_fluxes), deferred :: rebin_bulk_fluxes
          76             :      procedure(aero_hydrophilic), deferred :: hydrophilic
          77             :
          78             :      procedure :: final=>aero_props_final
          79             :   end type aerosol_properties
          80             :
          81             :   integer,public, parameter :: aero_name_len = 32 ! common length of aersols names, species, etc
          82             :
          83             :   abstract interface
          84             :
          85             :      !------------------------------------------------------------------------------
          86             :      ! returns number of transported aerosol constituents
          87             :      !------------------------------------------------------------------------------
          88             :      integer function aero_number_transported(self)
          89             :        import :: aerosol_properties
          90             :        class(aerosol_properties), intent(in) :: self
          91             :      end function aero_number_transported
          92             :
          93             :      !------------------------------------------------------------------------
          94             :      ! returns aerosol properties:
          95             :      !  density
          96             :      !  hygroscopicity
          97             :      !  species type
          98             :      !  species name
          99             :      !  short wave species refractive indices
         100             :      !  long wave species refractive indices
         101             :      !  species morphology
         102             :      !------------------------------------------------------------------------
         103             :      subroutine aero_props_get(self, bin_ndx, species_ndx, list_ndx, density, hygro, &
         104             :                                spectype, specname, specmorph, refindex_sw, refindex_lw)
         105             :        import :: aerosol_properties, r8
         106             :        class(aerosol_properties), intent(in) :: self
         107             :        integer, intent(in) :: bin_ndx             ! bin index
         108             :        integer, intent(in) :: species_ndx         ! species index
         109             :        integer, optional, intent(in) :: list_ndx  ! climate or a diagnostic list number
         110             :        real(r8), optional, intent(out) :: density ! density (kg/m3)
         111             :        real(r8), optional, intent(out) :: hygro   ! hygroscopicity
         112             :        character(len=*), optional, intent(out) :: spectype  ! species type
         113             :        character(len=*), optional, intent(out) :: specname  ! species name
         114             :        character(len=*), optional, intent(out) :: specmorph ! species morphology
         115             :        complex(r8), pointer, optional, intent(out) :: refindex_sw(:) ! short wave species refractive indices
         116             :        complex(r8), pointer, optional, intent(out) :: refindex_lw(:) ! long wave species refractive indices
         117             :
         118             :      end subroutine aero_props_get
         119             :
         120             :      !------------------------------------------------------------------------
         121             :      ! returns optics type and table parameters
         122             :      !------------------------------------------------------------------------
         123             :      subroutine aero_optics_params(self, list_ndx, bin_ndx, opticstype, extpsw, abspsw, asmpsw, absplw, &
         124             :           refrtabsw, refitabsw, refrtablw, refitablw, ncoef, prefr, prefi, sw_hygro_ext_wtp, &
         125             :           sw_hygro_ssa_wtp, sw_hygro_asm_wtp, lw_hygro_ext_wtp, wgtpct, nwtp, &
         126             :           sw_hygro_coreshell_ext, sw_hygro_coreshell_ssa, sw_hygro_coreshell_asm, lw_hygro_coreshell_ext, &
         127             :           corefrac, bcdust, kap, relh, nfrac, nbcdust, nkap, nrelh )
         128             :
         129             :        import :: aerosol_properties, r8
         130             :
         131             :        class(aerosol_properties), intent(in) :: self
         132             :        integer, intent(in) :: bin_ndx             ! bin index
         133             :        integer, intent(in) :: list_ndx            ! rad climate/diags list
         134             :
         135             :        character(len=*), optional, intent(out) :: opticstype
         136             :
         137             :        ! refactive index table parameters
         138             :        real(r8),  optional, pointer     :: extpsw(:,:,:,:) ! short wave specific extinction
         139             :        real(r8),  optional, pointer     :: abspsw(:,:,:,:) ! short wave specific absorption
         140             :        real(r8),  optional, pointer     :: asmpsw(:,:,:,:) ! short wave asymmetry factor
         141             :        real(r8),  optional, pointer     :: absplw(:,:,:,:) ! long wave specific absorption
         142             :        real(r8),  optional, pointer     :: refrtabsw(:,:)  ! table of short wave real refractive indices for aerosols
         143             :        real(r8),  optional, pointer     :: refitabsw(:,:)  ! table of short wave imaginary refractive indices for aerosols
         144             :        real(r8),  optional, pointer     :: refrtablw(:,:)  ! table of long wave real refractive indices for aerosols
         145             :        real(r8),  optional, pointer     :: refitablw(:,:)  ! table of long wave imaginary refractive indices for aerosols
         146             :        integer,   optional, intent(out) :: ncoef  ! number of chebychev polynomials
         147             :        integer,   optional, intent(out) :: prefr  ! number of real refractive indices in table
         148             :        integer,   optional, intent(out) :: prefi  ! number of imaginary refractive indices in table
         149             :
         150             :        ! hygrowghtpct table parameters
         151             :        real(r8),  optional, pointer     :: sw_hygro_ext_wtp(:,:) ! short wave extinction table
         152             :        real(r8),  optional, pointer     :: sw_hygro_ssa_wtp(:,:) ! short wave single-scatter albedo table
         153             :        real(r8),  optional, pointer     :: sw_hygro_asm_wtp(:,:) ! short wave asymmetry table
         154             :        real(r8),  optional, pointer     :: lw_hygro_ext_wtp(:,:) ! long wave absorption table
         155             :        real(r8),  optional, pointer     :: wgtpct(:)   ! weight precent of H2SO4/H2O solution
         156             :        integer,   optional, intent(out) :: nwtp        ! number of weight precent values
         157             :
         158             :        ! hygrocoreshell table parameters
         159             :        real(r8),  optional, pointer     :: sw_hygro_coreshell_ext(:,:,:,:,:) ! short wave extinction table
         160             :        real(r8),  optional, pointer     :: sw_hygro_coreshell_ssa(:,:,:,:,:) ! short wave single-scatter albedo table
         161             :        real(r8),  optional, pointer     :: sw_hygro_coreshell_asm(:,:,:,:,:) ! short wave asymmetry table
         162             :        real(r8),  optional, pointer     :: lw_hygro_coreshell_ext(:,:,:,:,:) ! long wave absorption table
         163             :        real(r8),  optional, pointer     :: corefrac(:) ! core fraction dimension values
         164             :        real(r8),  optional, pointer     :: bcdust(:)   ! bc/(bc + dust) fraction dimension values
         165             :        real(r8),  optional, pointer     :: kap(:)      ! hygroscopicity dimension values
         166             :        real(r8),  optional, pointer     :: relh(:)     ! relative humidity dimension values
         167             :        integer,   optional, intent(out) :: nfrac       ! core fraction dimension size
         168             :        integer,   optional, intent(out) :: nbcdust     ! bc/(bc + dust) fraction dimension size
         169             :        integer,   optional, intent(out) :: nkap        ! hygroscopicity dimension size
         170             :        integer,   optional, intent(out) :: nrelh       ! relative humidity dimension size
         171             :
         172             :      end subroutine aero_optics_params
         173             :
         174             :      !------------------------------------------------------------------------
         175             :      ! returns species type
         176             :      !------------------------------------------------------------------------
         177             :      subroutine aero_species_type(self, bin_ndx, species_ndx, spectype)
         178             :        import :: aerosol_properties
         179             :        class(aerosol_properties), intent(in) :: self
         180             :        integer, intent(in) :: bin_ndx           ! bin number
         181             :        integer, intent(in) :: species_ndx       ! species number
         182             :        character(len=*), intent(out) :: spectype ! species type
         183             :
         184             :      end subroutine aero_species_type
         185             :
         186             :      !------------------------------------------------------------------------
         187             :      ! returns mass and number activation fractions
         188             :      !------------------------------------------------------------------------
         189             :      subroutine aero_actfracs(self, bin_ndx, smc, smax, fn, fm )
         190             :        import :: aerosol_properties, r8
         191             :        class(aerosol_properties), intent(in) :: self
         192             :        integer, intent(in) :: bin_ndx   ! bin index
         193             :        real(r8),intent(in) :: smc       ! critical supersaturation for particles of bin radius
         194             :        real(r8),intent(in) :: smax      ! maximum supersaturation for multiple competing aerosols
         195             :        real(r8),intent(out) :: fn       ! activation fraction for aerosol number
         196             :        real(r8),intent(out) :: fm       ! activation fraction for aerosol mass
         197             :
         198             :      end subroutine aero_actfracs
         199             :
         200             :      !------------------------------------------------------------------------
         201             :      ! returns constituents names of aerosol number mixing ratios
         202             :      !------------------------------------------------------------------------
         203             :      subroutine aero_num_names(self, bin_ndx, name_a, name_c)
         204             :        import :: aerosol_properties
         205             :        class(aerosol_properties), intent(in) :: self
         206             :        integer, intent(in) :: bin_ndx           ! bin number
         207             :        character(len=*), intent(out) :: name_a ! constituent name of ambient aerosol number dens
         208             :        character(len=*), intent(out) :: name_c ! constituent name of cloud-borne aerosol number dens
         209             :      end subroutine aero_num_names
         210             :
         211             :      !------------------------------------------------------------------------
         212             :      ! returns constituents names of aerosol mass mixing ratios
         213             :      !------------------------------------------------------------------------
         214             :      subroutine aero_mmr_names(self, bin_ndx, species_ndx, name_a, name_c)
         215             :        import :: aerosol_properties
         216             :        class(aerosol_properties), intent(in) :: self
         217             :        integer, intent(in) :: bin_ndx           ! bin number
         218             :        integer, intent(in) :: species_ndx       ! species number
         219             :        character(len=*), intent(out) :: name_a ! constituent name of ambient aerosol MMR
         220             :        character(len=*), intent(out) :: name_c ! constituent name of cloud-borne aerosol MMR
         221             :      end subroutine aero_mmr_names
         222             :
         223             :      !------------------------------------------------------------------------
         224             :      ! returns constituent name of ambient aerosol number mixing ratios
         225             :      !------------------------------------------------------------------------
         226             :      subroutine aero_amb_num_name(self, bin_ndx, name)
         227             :        import :: aerosol_properties
         228             :        class(aerosol_properties), intent(in) :: self
         229             :        integer, intent(in) :: bin_ndx          ! bin number
         230             :        character(len=*), intent(out) :: name  ! constituent name of ambient aerosol number dens
         231             :
         232             :      end subroutine aero_amb_num_name
         233             :
         234             :      !------------------------------------------------------------------------
         235             :      ! returns constituent name of ambient aerosol mass mixing ratios
         236             :      !------------------------------------------------------------------------
         237             :      subroutine aero_amb_mmr_name(self, bin_ndx, species_ndx, name)
         238             :        import :: aerosol_properties
         239             :        class(aerosol_properties), intent(in) :: self
         240             :        integer, intent(in) :: bin_ndx           ! bin number
         241             :        integer, intent(in) :: species_ndx       ! species number
         242             :        character(len=*), intent(out) :: name   ! constituent name of ambient aerosol MMR
         243             :
         244             :      end subroutine aero_amb_mmr_name
         245             :
         246             :      !------------------------------------------------------------------------------
         247             :      ! returns radius^3 (m3) of a given bin number
         248             :      !------------------------------------------------------------------------------
         249             :      pure elemental real(r8) function aero_amcube(self, bin_ndx, volconc, numconc)
         250             :        import :: aerosol_properties, r8
         251             :
         252             :        class(aerosol_properties), intent(in) :: self
         253             :        integer, intent(in) :: bin_ndx  ! bin number
         254             :        real(r8), intent(in) :: volconc ! volume conc (m3/m3)
         255             :        real(r8), intent(in) :: numconc ! number conc (1/m3)
         256             :
         257             :      end function aero_amcube
         258             :
         259             :      !------------------------------------------------------------------------------
         260             :      ! returns TRUE if Ice Nucleation tendencies are applied to given aerosol bin number
         261             :      !------------------------------------------------------------------------------
         262             :      function aero_icenuc_updates_num(self, bin_ndx) result(res)
         263             :        import :: aerosol_properties
         264             :        class(aerosol_properties), intent(in) :: self
         265             :        integer, intent(in) :: bin_ndx  ! bin number
         266             :
         267             :        logical :: res
         268             :
         269             :      end function aero_icenuc_updates_num
         270             :
         271             :      !------------------------------------------------------------------------------
         272             :      ! returns TRUE if Ice Nucleation tendencies are applied to a given species within a bin
         273             :      !------------------------------------------------------------------------------
         274             :      function aero_icenuc_updates_mmr(self, bin_ndx, species_ndx) result(res)
         275             :        import :: aerosol_properties
         276             :        class(aerosol_properties), intent(in) :: self
         277             :        integer, intent(in) :: bin_ndx     ! bin number
         278             :        integer, intent(in) :: species_ndx ! species number
         279             :
         280             :        logical :: res
         281             :
         282             :      end function aero_icenuc_updates_mmr
         283             :
         284             :      !------------------------------------------------------------------------------
         285             :      ! apply max / min to number concentration
         286             :      !------------------------------------------------------------------------------
         287             :      subroutine aero_apply_num_limits( self, naerosol, vaerosol, istart, istop, m )
         288             :        import :: aerosol_properties, r8
         289             :        class(aerosol_properties), intent(in) :: self
         290             :        real(r8), intent(inout) :: naerosol(:)  ! number conc (1/m3)
         291             :        real(r8), intent(in)    :: vaerosol(:)  ! volume conc (m3/m3)
         292             :        integer,  intent(in) :: istart          ! start column index (1 <= istart <= istop <= pcols)
         293             :        integer,  intent(in) :: istop           ! stop column index
         294             :        integer,  intent(in) :: m               ! mode or bin index
         295             :
         296             :      end subroutine aero_apply_num_limits
         297             :
         298             :      !------------------------------------------------------------------------------
         299             :      ! returns TRUE if species `spc_ndx` in aerosol subset `bin_ndx` contributes to
         300             :      ! the particles' ability to act as heterogeneous freezing nuclei
         301             :      !------------------------------------------------------------------------------
         302             :      function aero_hetfrz_species(self, bin_ndx, spc_ndx) result(res)
         303             :        import :: aerosol_properties
         304             :        class(aerosol_properties), intent(in) :: self
         305             :        integer, intent(in) :: bin_ndx  ! bin number
         306             :        integer, intent(in) :: spc_ndx  ! species number
         307             :
         308             :        logical :: res
         309             :
         310             :      end function aero_hetfrz_species
         311             :
         312             :      !------------------------------------------------------------------------------
         313             :      ! returns minimum mass mean radius (meters)
         314             :      !------------------------------------------------------------------------------
         315             :      function aero_min_mass_mean_rad(self,bin_ndx,species_ndx) result(minrad)
         316             :        import :: aerosol_properties, r8
         317             :        class(aerosol_properties), intent(in) :: self
         318             :        integer, intent(in) :: bin_ndx           ! bin number
         319             :        integer, intent(in) :: species_ndx       ! species number
         320             :
         321             :        real(r8) :: minrad  ! meters
         322             :
         323             :      end function aero_min_mass_mean_rad
         324             :
         325             :      !------------------------------------------------------------------------------
         326             :      ! returns TRUE if soluble
         327             :      !------------------------------------------------------------------------------
         328             :      logical function aero_soluble(self,bin_ndx)
         329             :        import :: aerosol_properties
         330             :        class(aerosol_properties), intent(in) :: self
         331             :        integer, intent(in) :: bin_ndx           ! bin number
         332             :
         333             :      end function aero_soluble
         334             :
         335             :      !------------------------------------------------------------------------------
         336             :      ! returns the total number of bins for a given radiation list index
         337             :      !------------------------------------------------------------------------------
         338             :      function aero_nbins_rlist(self, list_ndx)  result(res)
         339             :        import :: aerosol_properties
         340             :        class(aerosol_properties), intent(in) :: self
         341             :        integer, intent(in) :: list_ndx  ! radiation list number
         342             :
         343             :        integer :: res
         344             :
         345             :      end function aero_nbins_rlist
         346             :
         347             :      !------------------------------------------------------------------------------
         348             :      ! returns number of species in a bin for a given radiation list index
         349             :      !------------------------------------------------------------------------------
         350             :      function aero_nspecies_rlist(self, list_ndx,  bin_ndx)  result(res)
         351             :        import :: aerosol_properties
         352             :        class(aerosol_properties), intent(in) :: self
         353             :        integer, intent(in) :: list_ndx ! radiation list number
         354             :        integer, intent(in) :: bin_ndx  ! bin number
         355             :
         356             :        integer :: res
         357             :
         358             :      end function aero_nspecies_rlist
         359             :
         360             :      !------------------------------------------------------------------------------
         361             :      ! returns the natural log of geometric standard deviation of the number
         362             :      ! distribution for radiation list number and aerosol bin
         363             :      !------------------------------------------------------------------------------
         364             :      function aero_alogsig_rlist(self, list_ndx,  bin_ndx)  result(res)
         365             :        import :: aerosol_properties, r8
         366             :        class(aerosol_properties), intent(in) :: self
         367             :        integer, intent(in) :: list_ndx ! radiation list number
         368             :        integer, intent(in) :: bin_ndx  ! bin number
         369             :
         370             :        real(r8) :: res
         371             :
         372             :      end function aero_alogsig_rlist
         373             :
         374             :      !------------------------------------------------------------------------------
         375             :      ! returns name for a given radiation list number and aerosol bin
         376             :      !------------------------------------------------------------------------------
         377             :      function aero_bin_name(self, list_ndx,  bin_ndx) result(name)
         378             :        import :: aerosol_properties, r8
         379             :        class(aerosol_properties), intent(in) :: self
         380             :        integer, intent(in) :: list_ndx ! radiation list number
         381             :        integer, intent(in) :: bin_ndx  ! bin number
         382             :
         383             :        character(len=32) name
         384             :
         385             :      end function aero_bin_name
         386             :
         387             :      !------------------------------------------------------------------------------
         388             :      ! returns scavenging diameter for a given aerosol bin number
         389             :      !------------------------------------------------------------------------------
         390             :      function aero_scav_diam(self, bin_ndx) result(diam)
         391             :        import :: aerosol_properties, r8
         392             :        class(aerosol_properties), intent(in) :: self
         393             :        integer, intent(in) :: bin_ndx  ! bin number
         394             :
         395             :        real(r8) :: diam
         396             :
         397             :      end function aero_scav_diam
         398             :
         399             :      !------------------------------------------------------------------------------
         400             :      ! adjust aerosol concentration tendencies to create larger sizes of aerosols
         401             :      ! during resuspension
         402             :      !------------------------------------------------------------------------------
         403             :      subroutine aero_resuspension_resize(self, dcondt)
         404             :        import :: aerosol_properties, r8
         405             :
         406             :        class(aerosol_properties), intent(in) :: self
         407             :        real(r8), intent(inout) :: dcondt(:)
         408             :
         409             :      end subroutine aero_resuspension_resize
         410             :
         411             :      !------------------------------------------------------------------------------
         412             :      ! returns bulk deposition fluxes of the specified species type
         413             :      ! rebinned to specified diameter limits
         414             :      !------------------------------------------------------------------------------
         415             :      subroutine aero_rebin_bulk_fluxes(self, bulk_type, dep_fluxes, diam_edges, bulk_fluxes, &
         416             :                                        error_code, error_string)
         417             :        import :: aerosol_properties, r8
         418             :        class(aerosol_properties), intent(in) :: self
         419             :        character(len=*),intent(in) :: bulk_type       ! aerosol type to rebin
         420             :        real(r8), intent(in) :: dep_fluxes(:)          ! kg/m2
         421             :        real(r8), intent(in) :: diam_edges(:)          ! meters
         422             :        real(r8), intent(out) :: bulk_fluxes(:)        ! kg/m2
         423             :        integer,  intent(out) :: error_code            ! error code (0 if no error)
         424             :        character(len=*), intent(out) :: error_string  ! error string
         425             :
         426             :      end subroutine aero_rebin_bulk_fluxes
         427             :
         428             :      !------------------------------------------------------------------------------
         429             :      ! Returns TRUE if bin is hydrophilic, otherwise FALSE
         430             :      !------------------------------------------------------------------------------
         431             :      logical function aero_hydrophilic(self, bin_ndx)
         432             :        import :: aerosol_properties
         433             :        class(aerosol_properties), intent(in) :: self
         434             :        integer, intent(in) :: bin_ndx ! bin number
         435             :      end function aero_hydrophilic
         436             :
         437             :   end interface
         438             :
         439             : contains
         440             :
         441             :   !------------------------------------------------------------------------------
         442             :   ! object initializer
         443             :   !------------------------------------------------------------------------------
         444           0 :   subroutine aero_props_init(self, nbin, ncnst, nspec, nmasses, alogsig, f1,f2, ierr )
         445             :     class(aerosol_properties), intent(inout) :: self
         446             :     integer, intent(in) :: nbin               ! number of bins
         447             :     integer, intent(in) :: ncnst              ! total number of constituents
         448             :     integer, intent(in) :: nspec(nbin)        ! number of species in each bin
         449             :     integer, intent(in) :: nmasses(nbin)      ! number of masses in each bin
         450             :     real(r8),intent(in) :: alogsig(nbin)      ! natural log of the standard deviation (sigma) of the aerosol bins
         451             :     real(r8),intent(in) :: f1(nbin)           ! eq 28 Abdul-Razzak et al 1998
         452             :     real(r8),intent(in) :: f2(nbin)           ! eq 29 Abdul-Razzak et al 1998
         453             :     integer,intent(out) :: ierr
         454             :
         455             :     integer :: imas,ibin,indx
         456             :     character(len=*),parameter :: prefix = 'aerosol_properties::aero_props_init: '
         457             :
         458             :     real(r8), parameter :: spechygro_so4 = 0.507_r8          ! Sulfate hygroscopicity
         459             :     real(r8), parameter :: spechygro_soa = 0.14_r8           ! SOA hygroscopicity
         460             :     real(r8), parameter :: spechygro_pom = 0.1_r8            ! POM hygroscopicity
         461             :
         462           0 :     ierr = 0
         463             :
         464           0 :     allocate(self%nspecies_(nbin),stat=ierr)
         465           0 :     if( ierr /= 0 ) then
         466             :        return
         467             :     end if
         468           0 :     allocate(self%nmasses_(nbin),stat=ierr)
         469           0 :     if( ierr /= 0 ) then
         470             :        return
         471             :     end if
         472           0 :     allocate(self%alogsig_(nbin),stat=ierr)
         473           0 :     if( ierr /= 0 ) then
         474             :        return
         475             :     end if
         476           0 :     allocate(self%f1_(nbin),stat=ierr)
         477           0 :     if( ierr /= 0 ) then
         478             :        return
         479             :     end if
         480           0 :     allocate(self%f2_(nbin),stat=ierr)
         481           0 :     if( ierr /= 0 ) then
         482             :        return
         483             :     end if
         484             :
         485           0 :     allocate( self%indexer_(nbin,0:maxval(nmasses)),stat=ierr )
         486           0 :     if( ierr /= 0 ) then
         487             :        return
         488             :     end if
         489             :
         490             :     ! Local indexing compresses the mode and number/mass indices into one index.
         491             :     ! This indexing is used by the pointer arrays used to reference state and pbuf
         492             :     ! fields. We add number = 0, total mass = 1 (if available), and mass from each
         493             :     ! constituency into mm.
         494             :
         495           0 :     self%indexer_ = -1
         496             :     indx = 0
         497             :
         498           0 :     do ibin=1,nbin
         499           0 :        do imas = 0,nmasses(ibin)
         500           0 :           indx = indx+1
         501           0 :           self%indexer_(ibin,imas) = indx
         502             :        end do
         503             :     end do
         504             :
         505           0 :     self%nbins_ = nbin
         506           0 :     self%ncnst_tot_ = ncnst
         507           0 :     self%nmasses_(:) = nmasses(:)
         508           0 :     self%nspecies_(:) = nspec(:)
         509           0 :     self%alogsig_(:) = alogsig(:)
         510           0 :     self%f1_(:) = f1(:)
         511           0 :     self%f2_(:) = f2(:)
         512             :
         513           0 :     self%soa_equivso4_factor_ = spechygro_soa/spechygro_so4
         514           0 :     self%pom_equivso4_factor_ = spechygro_pom/spechygro_so4
         515             :
         516             :   end subroutine aero_props_init
         517             :
         518             :   !------------------------------------------------------------------------------
         519             :   ! Object clean
         520             :   !------------------------------------------------------------------------------
         521           0 :   subroutine aero_props_final(self)
         522             :     class(aerosol_properties), intent(inout) :: self
         523             :
         524           0 :     if (allocated(self%nspecies_)) then
         525           0 :        deallocate(self%nspecies_)
         526             :     end if
         527           0 :     if (allocated(self%nmasses_)) then
         528           0 :        deallocate(self%nmasses_)
         529             :     end if
         530           0 :     if (allocated(self%indexer_)) then
         531           0 :        deallocate(self%indexer_)
         532             :     endif
         533           0 :     if (allocated(self%alogsig_)) then
         534           0 :        deallocate(self%alogsig_)
         535             :     endif
         536           0 :     if (allocated(self%f1_)) then
         537           0 :        deallocate(self%f1_)
         538             :     endif
         539           0 :     if (allocated(self%f2_)) then
         540           0 :        deallocate(self%f2_)
         541             :     endif
         542             :
         543           0 :     self%nbins_ = 0
         544           0 :     self%ncnst_tot_ = 0
         545             :
         546           0 :   end subroutine aero_props_final
         547             :
         548             :   !------------------------------------------------------------------------------
         549             :   ! returns number of species in a bin
         550             :   !------------------------------------------------------------------------------
         551           0 :   pure function nspecies_per_bin(self,bin_ndx) result(val)
         552             :     class(aerosol_properties), intent(in) :: self
         553             :     integer, intent(in) :: bin_ndx           ! bin number
         554             :     integer :: val
         555             :
         556           0 :     val = self%nspecies_(bin_ndx)
         557           0 :   end function nspecies_per_bin
         558             :
         559             :   !------------------------------------------------------------------------------
         560             :   ! returns number of species for all bins
         561             :   !------------------------------------------------------------------------------
         562           0 :   pure function nspecies_all_bins(self) result(arr)
         563             :     class(aerosol_properties), intent(in) :: self
         564             :     integer :: arr(self%nbins_)
         565             :
         566           0 :     arr(:) = self%nspecies_(:)
         567             :
         568           0 :   end function nspecies_all_bins
         569             :
         570             :   !------------------------------------------------------------------------------
         571             :   ! returns number of species masses in a given bin number
         572             :   !------------------------------------------------------------------------------
         573           0 :   pure function n_masses_per_bin(self,bin_ndx) result(val)
         574             :     class(aerosol_properties), intent(in) :: self
         575             :     integer, intent(in) :: bin_ndx           ! bin number
         576             :     integer :: val
         577             :
         578           0 :     val = self%nmasses_(bin_ndx)
         579           0 :   end function n_masses_per_bin
         580             :
         581             :   !------------------------------------------------------------------------------
         582             :   ! returns an array of number of species masses for all bins
         583             :   !------------------------------------------------------------------------------
         584           0 :   pure function n_masses_all_bins(self) result(arr)
         585             :     class(aerosol_properties), intent(in) :: self
         586             :     integer :: arr(self%nbins_)
         587             :
         588           0 :     arr(:) = self%nmasses_(:)
         589           0 :   end function n_masses_all_bins
         590             :
         591             :   !------------------------------------------------------------------------------
         592             :   ! returns a single index for given bin and species
         593             :   !------------------------------------------------------------------------------
         594           0 :   pure integer function indexer(self,bin_ndx,species_ndx)
         595             :     class(aerosol_properties), intent(in) :: self
         596             :     integer, intent(in) :: bin_ndx           ! bin number
         597             :     integer, intent(in) :: species_ndx       ! species number
         598             :
         599           0 :     indexer = self%indexer_(bin_ndx,species_ndx)
         600           0 :   end function indexer
         601             :
         602             :   !------------------------------------------------------------------------------
         603             :   ! returns the total number of bins
         604             :   !------------------------------------------------------------------------------
         605           0 :   pure function nbins_0list(self) result(nbins)
         606             :     class(aerosol_properties), intent(in) :: self
         607             :     integer :: nbins
         608             :
         609           0 :     nbins = self%nbins_
         610           0 :   end function nbins_0list
         611             :
         612             :   !------------------------------------------------------------------------------
         613             :   ! returns number of constituents (or elements) totaled across all bins
         614             :   !------------------------------------------------------------------------------
         615           0 :   pure integer function ncnst_tot(self)
         616             :     class(aerosol_properties), intent(in) :: self
         617             :
         618           0 :     ncnst_tot = self%ncnst_tot_
         619           0 :   end function ncnst_tot
         620             :
         621             :   !------------------------------------------------------------------------------
         622             :   ! returns the natural log of geometric standard deviation of the number distribution for aerosol bin
         623             :   !------------------------------------------------------------------------------
         624           0 :   pure real(r8) function alogsig_0list(self, bin_ndx)
         625             :     class(aerosol_properties), intent(in) :: self
         626             :     integer, intent(in) :: bin_ndx           ! bin number
         627             :
         628           0 :     alogsig_0list = self%alogsig_(bin_ndx)
         629           0 :   end function alogsig_0list
         630             :
         631             :   !------------------------------------------------------------------------------
         632             :   ! returns maximum supersaturation
         633             :   !------------------------------------------------------------------------------
         634           0 :   function maxsat(self, zeta,eta,smc) result(smax)
         635             :
         636             :     !-------------------------------------------------------------------------
         637             :     ! Calculates maximum supersaturation for multiple competing aerosols.
         638             :     !
         639             :     ! Abdul-Razzak and Ghan, A parameterization of aerosol activation.
         640             :     ! 2. Multiple aerosol types. J. Geophys. Res., 105, 6837-6844., 2000
         641             :     !-------------------------------------------------------------------------
         642             :
         643             :     class(aerosol_properties), intent(in) :: self
         644             :     real(r8), intent(in)  :: zeta(self%nbins_) ! Abdul-Razzak and Ghan eq 10
         645             :     real(r8), intent(in)  :: eta(self%nbins_)  ! Abdul-Razzak and Ghan eq 11
         646             :     real(r8), intent(in)  :: smc(self%nbins_)  ! critical supersaturation
         647             :
         648             :     real(r8) :: smax ! maximum supersaturation
         649             :
         650             :     integer  :: m
         651             :     integer  :: nbins
         652             :     real(r8) :: sum, g1, g2, g1sqrt, g2sqrt
         653             :
         654             :     real(r8), parameter :: small_maxsat = 1.e-20_r8 ! for weak forcing
         655             :     real(r8), parameter :: large_maxsat = 1.e20_r8  ! for small eta
         656             :
         657           0 :     smax=0.0_r8
         658           0 :     nbins = self%nbins_
         659             :
         660           0 :     check_loop: do m=1,nbins
         661           0 :        if((zeta(m) > 1.e5_r8*eta(m)) .or. (smc(m)*smc(m) > 1.e5_r8*eta(m))) then
         662             :           ! weak forcing -- essentially none activated
         663           0 :           smax=small_maxsat
         664             :        else
         665             :           ! significant activation of this mode -- calc activation all modes
         666             :           exit check_loop
         667             :        endif
         668             :        ! No significant activation in any mode.  Do nothing.
         669           0 :        if (m == nbins) return
         670             :     enddo check_loop
         671             :
         672             :     sum=0.0_r8
         673             :
         674           0 :     do m=1,nbins
         675           0 :        if(eta(m) > 1.e-20_r8)then
         676             :           ! from Abdul-Razzak and Ghan 2000
         677           0 :           g1=zeta(m)/eta(m)
         678           0 :           g1sqrt=sqrt(g1)
         679           0 :           g1=g1sqrt*g1
         680           0 :           g2=smc(m)/sqrt(eta(m)+3._r8*zeta(m))
         681           0 :           g2sqrt=sqrt(g2)
         682           0 :           g2=g2sqrt*g2
         683           0 :           sum=sum+(self%f1_(m)*g1+self%f2_(m)*g2)/(smc(m)*smc(m))
         684             :        else
         685             :           sum=large_maxsat
         686             :        endif
         687             :     enddo
         688             :
         689           0 :     smax=1._r8/sqrt(sum)
         690             :
         691           0 :   end function maxsat
         692             :
         693             :   !------------------------------------------------------------------------------
         694             :   ! returns the ratio of SOA Hygroscopicity / Sulfate Hygroscopicity
         695             :   !------------------------------------------------------------------------------
         696           0 :   pure real(r8) function soa_equivso4_factor(self)
         697             :     class(aerosol_properties), intent(in) :: self
         698             :
         699           0 :     soa_equivso4_factor = self%soa_equivso4_factor_
         700             :
         701           0 :   end function soa_equivso4_factor
         702             :
         703             :   !------------------------------------------------------------------------------
         704             :   ! returns the ratio of POM Hygroscopicity / Sulfate Hygroscopicity
         705             :   !------------------------------------------------------------------------------
         706           0 :   pure real(r8) function pom_equivso4_factor(self)
         707             :     class(aerosol_properties), intent(in) :: self
         708             :
         709           0 :     pom_equivso4_factor = self%pom_equivso4_factor_
         710             :
         711           0 :   end function pom_equivso4_factor
         712             :
         713           0 : end module aerosol_properties_mod

Generated by: LCOV version 1.14