From 721e6f7cfdcf9934c038feddec45debdb6a1132c Mon Sep 17 00:00:00 2001 From: laurenchilutti <60401591+laurenchilutti@users.noreply.github.com> Date: Thu, 13 Oct 2022 13:53:44 -0400 Subject: [PATCH] Dev/gfdl test (#222) * updated fv_regional_bc.F90 to read levsp from GFS_ctl file (#152) * Updating a continue statement in fv_nudge (#153) * update in fv_nudge to fix 666 label logic * fix logic errors (#138) * update to external_ic::remap_scale to skip remapping non-existent IC tracers (#159) * Fix nudge logic (#157) * fix logic errors * fix answer changes * adding back a line that was mistakenly deleted in a previous commit (#166) * Release 042022 (#184) * Merge of updates from GFDL Weather and Climate Dynamics Division (202204): *add license header to missing files and fix typo in header *updates needed for fv3_gfsphysics to have access to bounded_domain *remove obsoleted driver/SHiELD files *updating to fix bug where long_name and units attributes were not being captured in the RESTARTS *remove unused function fv_diagnostics::max_vorticity_hy1 *remove avec timer remnants *adding ability to specify prefix and directory when reading and writing restarts *remove old style namelist read in favor of read from internal character variable *Added option for a mean wind *The planetary radius and rotation rate are now re-scalable by a namelist parameter (small_earth_scale) instead of using exclusively the hard-coded FMS constant. *fv_mapz: Cleanup and added helpful annotations to avoid getting lost so easily * remove duplicate code and fix lstatus on all grids depending on gfs_data and gfs_data.tile1 * New idealized tests *Makes the non-hydrostatic restart variables optional for reads to allow hydrostatic ICs *Fix the hydrostatic TE remapping; Add GMAO cubic for TE remapping, which is used if kord_tm=0 and remap_te=.true. *Add a TE remapping option (kord_tm=0) *Addressing GNU Warnings *Add the L75 vertical config from HAFS * clean up fms_mp_mod and remove mp_bcst * cherry pick 5193c6b60c02c744b1ffe27078eccbeed2a22ad8 from dev/emc * Attempt at integrating fixes on top of dev/emc branch. (#173) * remove outdated GFDL_tools/fv_diag_column.F90 which exists as the result of an improper merge. The correct file is tools/fv_diag_column.F90 (#191) * various io fixes (#192) * fixes io performance issues by making everyone a reader when io_layout=1,1 adds capability to use FMS feature to ignore data integrity checksums in restarts * rename enforce_rst_cksum to ignore_rst_cksum and change the default value for compatibility * fix index error (#196) * New notebooks (#190) * Moving source files into source directory * Added advection notebook * Fixed subplot spacing * New 3D case notebooks * New idealized tests Updated mtn_wave_tests_1km to restore missing graphics. * first try at held-suarez * Updated H-S superrotation notebook * New level placement tool in an interactive note * Minor updates to notebooks; deleted fv_eta binary. * Regional decomposition test fix (when nrows_blend > 0) (#194) (#200) * Regional bc blend changes to extend into interior halos and overlap on corners. Still not working for u and v. dyn_core.F90 : Fix from Jun Wang to correct sync of u,v fv_regional_bc.F90 : add check for nrows_blend > tile size; fix error when nrows_blend=1 Conflicts (not taken during chery-pick): driver/SHiELD/atmosphere.F90 model/fv_sg.F90 Co-authored-by: Ted Mansell <37668594+MicroTed@users.noreply.github.com> * Implementing CI (#207) * CI Parallelworks update (#211) * Update call to read_input_nml and remove unnecessary code. (#161) * Removing use of INTERNAL_FILE_NML and cleaning up read_namelist_test_cases to remove unused argument * deleting duplicate call to read_namelist_test_case_nml in fv_control * removing commented code in fv_control Co-authored-by: Rusty Benson <6594772+bensonr@users.noreply.github.com> Co-authored-by: menzel-gfdl <43218622+menzel-gfdl@users.noreply.github.com> Co-authored-by: Rusty Benson Co-authored-by: MatthewPyle-NOAA <48285220+MatthewPyle-NOAA@users.noreply.github.com> Co-authored-by: lharris4 <53020884+lharris4@users.noreply.github.com> Co-authored-by: Ted Mansell <37668594+MicroTed@users.noreply.github.com> --- .github/workflows/SHiELD_parallelworks.yml | 52 + CODE_STYLE.md | 2 +- GFDL_tools/fv_ada_nudge.F90 | 55 +- GFDL_tools/fv_climate_nudge.F90 | 18 +- GFDL_tools/fv_cmip_diag.F90 | 2 +- GFDL_tools/read_climate_nudge_data.F90 | 2 +- README.md | 2 +- RELEASE.md | 22 + .../FV3_level_transmogrifier.ipynb | 519 +++ .../FV3_level_transmogrifier/fv_eta.F90 | 2318 ++++++++++++ .../FV3_level_transmogrifier/fv_eta.h | 1241 ++++++ .../std_atmos_1976.txt | 861 +++++ docs/examples/HSzuritasuperrotation.ipynb | 1036 +++++ docs/examples/README.md | 8 +- driver/GFDL/atmosphere.F90 | 30 +- driver/SHiELD/atmosphere.F90 | 317 +- driver/solo/atmosphere.F90 | 608 +++ driver/solo/fv_phys.F90 | 2625 +++++++++++++ driver/solo/hswf.F90 | 232 ++ driver/solo/monin_obukhov_drag.F90 | 668 ++++ driver/solo/ocean_rough.F90 | 225 ++ driver/solo/qs_tables.F90 | 135 + model/a2b_edge.F90 | 3 +- model/boundary.F90 | 4 +- .../cld_eff_rad.F90 | 171 +- model/dyn_core.F90 | 100 +- model/{fv_cmp.F90 => fast_sat_adj.F90} | 440 ++- model/fv_arrays.F90 | 117 +- model/fv_control.F90 | 74 +- model/fv_dynamics.F90 | 302 +- model/fv_fill.F90 | 3 +- model/fv_grid_utils.F90 | 87 +- model/fv_mapz.F90 | 80 +- model/fv_nesting.F90 | 37 +- model/fv_regional_bc.F90 | 182 +- model/fv_sg.F90 | 11 +- model/fv_tracer2d.F90 | 5 +- model/fv_update_phys.F90 | 11 +- .../gfdl_cld_mp.F90 | 3334 +++++++++-------- model/gfdl_mp.F90 | 2880 +++++++++----- model/nh_core.F90 | 3 +- model/nh_utils.F90 | 20 +- model/sw_core.F90 | 33 +- model/tp_core.F90 | 3 +- tools/coarse_grained_diagnostics.F90 | 843 ++++- tools/coarse_grained_restart_files.F90 | 95 +- tools/coarse_graining.F90 | 2658 ++++++++++++- tools/external_ic.F90 | 123 +- tools/external_sst.F90 | 3 +- {GFDL_tools => tools}/fv_diag_column.F90 | 75 +- tools/fv_diagnostics.F90 | 604 ++- tools/fv_diagnostics.h | 13 +- tools/fv_eta.F90 | 53 +- tools/fv_eta.h | 386 +- tools/fv_grid_tools.F90 | 67 +- tools/fv_iau_mod.F90 | 528 +++ tools/fv_io.F90 | 505 ++- tools/fv_mp_mod.F90 | 387 +- tools/fv_nggps_diag.F90 | 100 +- tools/fv_nudge.F90 | 36 +- tools/fv_restart.F90 | 75 +- tools/fv_surf_map.F90 | 5 +- tools/fv_timing.F90 | 3 +- tools/fv_treat_da_inc.F90 | 96 +- tools/init_hydro.F90 | 186 +- tools/rad_ref.F90 | 235 ++ tools/sim_nc_mod.F90 | 14 +- tools/sorted_index.F90 | 3 +- tools/statistics.F90 | 266 ++ tools/test_cases.F90 | 1199 ++++-- 70 files changed, 22456 insertions(+), 4980 deletions(-) create mode 100644 .github/workflows/SHiELD_parallelworks.yml create mode 100644 docs/examples/FV3_level_transmogrifier/FV3_level_transmogrifier.ipynb create mode 100644 docs/examples/FV3_level_transmogrifier/fv_eta.F90 create mode 100644 docs/examples/FV3_level_transmogrifier/fv_eta.h create mode 100644 docs/examples/FV3_level_transmogrifier/std_atmos_1976.txt create mode 100644 docs/examples/HSzuritasuperrotation.ipynb create mode 100644 driver/solo/atmosphere.F90 create mode 100644 driver/solo/fv_phys.F90 create mode 100644 driver/solo/hswf.F90 create mode 100644 driver/solo/monin_obukhov_drag.F90 create mode 100644 driver/solo/ocean_rough.F90 create mode 100644 driver/solo/qs_tables.F90 rename driver/SHiELD/cloud_diagnosis.F90 => model/cld_eff_rad.F90 (79%) rename model/{fv_cmp.F90 => fast_sat_adj.F90} (76%) rename driver/SHiELD/gfdl_cloud_microphys.F90 => model/gfdl_cld_mp.F90 (56%) rename {GFDL_tools => tools}/fv_diag_column.F90 (91%) create mode 100644 tools/fv_iau_mod.F90 create mode 100644 tools/rad_ref.F90 create mode 100644 tools/statistics.F90 diff --git a/.github/workflows/SHiELD_parallelworks.yml b/.github/workflows/SHiELD_parallelworks.yml new file mode 100644 index 000000000..1102d40da --- /dev/null +++ b/.github/workflows/SHiELD_parallelworks.yml @@ -0,0 +1,52 @@ +name: Compile SHiELD SOLO and run tests + +on: + pull_request: + branches: + - main +jobs: + checkout: + runs-on: [self-hosted] + name: Checkout Code + steps: + - run: python3 /pw/storage/PWscripts/FV3checkoutStartClusters.py $GITHUB_REF + + build: + runs-on: [self-hosted] + name: SOLO SHiELD build + needs: [checkout] + strategy: + fail-fast: true + max-parallel: 3 + matrix: + runpath: [/pw/storage/PWscripts] + runscript: [FV3swStartClusters.py, FV3nhStartClusters.py, FV3hydroStartClusters.py] + steps: + - env: + RUNPATH: ${{ matrix.runpath }} + RUNSCRIPT: ${{ matrix.runscript }} + run: python3 $RUNPATH/$RUNSCRIPT $GITHUB_REF + + test: + runs-on: [self-hosted] + name: SOLO SHiELD test suite + needs: [checkout, build] + strategy: + fail-fast: false + max-parallel: 3 + matrix: + runpath: [/pw/storage/PWscripts] + runscript: [FV3C128r20.solo.superCStartClusters.py] + steps: + - env: + RUNPATH: ${{ matrix.runpath }} + RUNSCRIPT: ${{ matrix.runscript }} + run: python3 $RUNPATH/$RUNSCRIPT $GITHUB_REF + + shutdowncluster: + runs-on: [self-hosted] + name: Shutdown cluster + if: always() + needs: [checkout, build, test] + steps: + - run: python3 /home/Lauren.Chilutti/pw/storage/PWscripts/stopClusters.py cifv3 diff --git a/CODE_STYLE.md b/CODE_STYLE.md index 733885f36..74013dbdb 100644 --- a/CODE_STYLE.md +++ b/CODE_STYLE.md @@ -70,7 +70,7 @@ !* (at your option) any later version. !* !* The FV3 dynamical core is distributed in the hope that it will be -!* useful, but WITHOUT ANYWARRANTY; without even the implied warranty +!* useful, but WITHOUT ANY WARRANTY; without even the implied warranty !* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. !* See the GNU General Public License for more details. !* diff --git a/GFDL_tools/fv_ada_nudge.F90 b/GFDL_tools/fv_ada_nudge.F90 index b660b9a75..49b6ed6cd 100644 --- a/GFDL_tools/fv_ada_nudge.F90 +++ b/GFDL_tools/fv_ada_nudge.F90 @@ -10,7 +10,7 @@ !* (at your option) any later version. !* !* The FV3 dynamical core is distributed in the hope that it will be -!* useful, but WITHOUT ANYWARRANTY; without even the implied warranty +!* useful, but WITHOUT ANY WARRANTY; without even the implied warranty !* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. !* See the GNU General Public License for more details. !* @@ -262,7 +262,7 @@ module fv_ada_nudge_mod contains - subroutine fv_ada_nudge ( Time, dt, npx, npy, npz, ps_dt, u_dt, v_dt, t_dt, q_dt, zvir, ptop, & + subroutine fv_ada_nudge ( Time, dt, npx, npy, npz, ps_dt, u_dt, v_dt, t_dt, q_dt, zvir, & ak, bk, ts, ps, delp, ua, va, pt, nwat, q, phis, gridstruct, & bd, domain ) @@ -271,7 +271,7 @@ subroutine fv_ada_nudge ( Time, dt, npx, npy, npz, ps_dt, u_dt, v_dt, t_dt, q_dt integer, intent(in):: npz ! vertical dimension integer, intent(in):: nwat real, intent(in):: dt - real, intent(in):: zvir, ptop + real, intent(in):: zvir type(domain2d), intent(INOUT), target :: domain type(fv_grid_bounds_type), intent(IN) :: bd real, intent(in ), dimension(npz+1):: ak, bk @@ -435,7 +435,7 @@ subroutine fv_ada_nudge ( Time, dt, npx, npy, npz, ps_dt, u_dt, v_dt, t_dt, q_dt call get_obs(Time, dt, zvir, ak, bk, ps, ts, ps_obs, delp, pt, nwat, q, u_obs, v_obs, t_obs, q_obs, & - phis, gz_int, ua, va, u_dt, v_dt, npx, npy, npz, factor, mask, ptop, bd, gridstruct, domain) + phis, gz_int, ua, va, u_dt, v_dt, npx, npy, npz, factor, mask, bd, gridstruct, domain) ! *t_obs* is virtual temperature #ifdef ENABLE_ADA ! snz @@ -1269,10 +1269,10 @@ end subroutine compute_slp subroutine get_obs(Time, dt, zvir, ak, bk, ps, ts, ps_obs, delp, pt, nwat, q, u_obs, v_obs, t_obs, q_obs, & - phis, gz_int, ua, va, u_dt, v_dt, npx, npy, npz, factor, mask, ptop, bd, gridstruct, domain) + phis, gz_int, ua, va, u_dt, v_dt, npx, npy, npz, factor, mask, bd, gridstruct, domain) type(time_type), intent(in):: Time integer, intent(in):: npz, nwat, npx, npy - real, intent(in):: zvir, ptop + real, intent(in):: zvir real, intent(in):: dt, factor real, intent(in), dimension(npz+1):: ak, bk type(fv_grid_bounds_type), intent(IN) :: bd @@ -1423,26 +1423,26 @@ subroutine get_obs(Time, dt, zvir, ak, bk, ps, ts, ps_obs, delp, pt, nwat, q, u_ if ( nudge_winds ) then call remap_uv(npz, ak, bk, ps(is:ie,js:je), delp, ut, vt, & - km, ps_dat(is:ie,js:je,1), u_dat(:,:,:,1), v_dat(:,:,:,1), ptop, bd ) + km, ps_dat(is:ie,js:je,1), u_dat(:,:,:,1), v_dat(:,:,:,1), bd ) u_obs(:,:,:) = alpha*ut(:,:,:) v_obs(:,:,:) = alpha*vt(:,:,:) call remap_uv(npz, ak, bk, ps(is:ie,js:je), delp, ut, vt, & - km, ps_dat(is:ie,js:je,2), u_dat(:,:,:,2), v_dat(:,:,:,2), ptop, bd ) + km, ps_dat(is:ie,js:je,2), u_dat(:,:,:,2), v_dat(:,:,:,2), bd ) u_obs(:,:,:) = u_obs(:,:,:) + beta*ut(:,:,:) v_obs(:,:,:) = v_obs(:,:,:) + beta*vt(:,:,:) endif call remap_tq(npz, ak, bk, ps(is:ie,js:je), delp, ut, vt, & - km, ps_dat(is:ie,js:je,1), t_dat(:,:,:,1), q_dat(:,:,:,1), zvir, ptop, bd) + km, ps_dat(is:ie,js:je,1), t_dat(:,:,:,1), q_dat(:,:,:,1), zvir, bd) t_obs(:,:,:) = alpha*ut(:,:,:) q_obs(:,:,:) = alpha*vt(:,:,:) call remap_tq(npz, ak, bk, ps(is:ie,js:je), delp, ut, vt, & - km, ps_dat(is:ie,js:je,2), t_dat(:,:,:,2), q_dat(:,:,:,2), zvir, ptop, bd) + km, ps_dat(is:ie,js:je,2), t_dat(:,:,:,2), q_dat(:,:,:,2), zvir, bd) t_obs(:,:,:) = t_obs(:,:,:) + beta*ut(:,:,:) q_obs(:,:,:) = q_obs(:,:,:) + beta*vt(:,:,:) @@ -2309,9 +2309,9 @@ end subroutine get_int_hght subroutine remap_tq( npz, ak, bk, ps, delp, t, q, & - kmd, ps0, ta, qa, zvir, ptop, bd) + kmd, ps0, ta, qa, zvir, bd) integer, intent(in):: npz, kmd - real, intent(in):: zvir, ptop + real, intent(in):: zvir real, intent(in):: ak(npz+1), bk(npz+1) type(fv_grid_bounds_type), intent(IN) :: bd real, intent(in), dimension(bd%is:bd%ie,bd%js:bd%je):: ps0 @@ -2373,7 +2373,7 @@ subroutine remap_tq( npz, ak, bk, ps, delp, t, q, & qp(i,k) = qa(i,j,k) enddo enddo - call mappm(kmd, pe0, qp, npz, pe1, qn1, is,ie, 0, kord_data, ptop) + call mappm(kmd, pe0, qp, npz, pe1, qn1, is,ie, 0, kord_data) do k=1,npz do i=is,ie q(i,j,k) = qn1(i,k) @@ -2388,7 +2388,7 @@ subroutine remap_tq( npz, ak, bk, ps, delp, t, q, & tp(i,k) = ta(i,j,k) enddo enddo - call mappm(kmd, pn0, tp, npz, pn1, qn1, is,ie, 1, kord_data, ptop) + call mappm(kmd, pn0, tp, npz, pn1, qn1, is,ie, 1, kord_data) do k=1,npz do i=is,ie @@ -2401,9 +2401,8 @@ subroutine remap_tq( npz, ak, bk, ps, delp, t, q, & end subroutine remap_tq - subroutine remap_uv(npz, ak, bk, ps, delp, u, v, kmd, ps0, u0, v0, ptop, bd) + subroutine remap_uv(npz, ak, bk, ps, delp, u, v, kmd, ps0, u0, v0, bd) integer, intent(in):: npz - real, intent(IN):: ptop real, intent(in):: ak(npz+1), bk(npz+1) type(fv_grid_bounds_type), intent(IN) :: bd real, intent(inout):: ps(bd%is:bd%ie,bd%js:bd%je) @@ -2460,7 +2459,7 @@ subroutine remap_uv(npz, ak, bk, ps, delp, u, v, kmd, ps0, u0, v0, ptop, bd) qt(i,k) = u0(i,j,k) enddo enddo - call mappm(kmd, pe0, qt, npz, pe1, qn1, is,ie, -1, kord_data, ptop) + call mappm(kmd, pe0, qt, npz, pe1, qn1, is,ie, -1, kord_data) do k=1,npz do i=is,ie u(i,j,k) = qn1(i,k) @@ -2474,7 +2473,7 @@ subroutine remap_uv(npz, ak, bk, ps, delp, u, v, kmd, ps0, u0, v0, ptop, bd) qt(i,k) = v0(i,j,k) enddo enddo - call mappm(kmd, pe0, qt, npz, pe1, qn1, is,ie, -1, kord_data, ptop) + call mappm(kmd, pe0, qt, npz, pe1, qn1, is,ie, -1, kord_data) do k=1,npz do i=is,ie v(i,j,k) = qn1(i,k) @@ -2516,14 +2515,34 @@ subroutine fv_ada_nudge_end call fv_io_register_axis(ada_driver_restart, numx=1, numy=1, numz=1, zsize=(/size(Atm_var%u_adj,3)/)) call register_restart_field(ada_driver_restart, & & "u_adj", Atm_var%u_adj(:,:,:), dim_names_4d) + call register_variable_attribute(ada_driver_restart, & + & "u_adj", "long_name", "u_adj", str_len=len("u_adj")) + call register_variable_attribute(ada_driver_restart, & + & "u_adj", "units", "none", str_len=len("none")) call register_restart_field(ada_driver_restart, & & "v_adj", Atm_var%v_adj(:,:,:), dim_names_4d) + call register_variable_attribute(ada_driver_restart, & + & "v_adj", "long_name", "v_adj", str_len=len("v_adj")) + call register_variable_attribute(ada_driver_restart, & + & "v_adj", "units", "none", str_len=len("none")) call register_restart_field(ada_driver_restart, & & "t_adj", Atm_var%t_adj(:,:,:), dim_names_4d) + call register_variable_attribute(ada_driver_restart, & + & "t_adj", "long_name", "t_adj", str_len=len("t_adj")) + call register_variable_attribute(ada_driver_restart, & + & "t_adj", "units", "none", str_len=len("none")) call register_restart_field(ada_driver_restart, & & "q_adj", Atm_var%q_adj(:,:,:), dim_names_4d) + call register_variable_attribute(ada_driver_restart, & + & "q_adj", "long_name", "q_adj", str_len=len("q_adj")) + call register_variable_attribute(ada_driver_restart, & + & "q_adj", "units", "none", str_len=len("none")) call register_restart_field(ada_driver_restart, & & "ps_adj", Atm_var%ps_adj(:,:), dim_names_4d) + call register_variable_attribute(ada_driver_restart, & + & "ps_adj", "long_name", "ps_adj", str_len=len("ps_adj")) + call register_variable_attribute(ada_driver_restart, & + & "ps_adj", "units", "none", str_len=len("none")) call write_restart(ada_driver_restart) call close_file(ada_driver_restart) endif diff --git a/GFDL_tools/fv_climate_nudge.F90 b/GFDL_tools/fv_climate_nudge.F90 index b392bef2e..41cfd1134 100644 --- a/GFDL_tools/fv_climate_nudge.F90 +++ b/GFDL_tools/fv_climate_nudge.F90 @@ -10,7 +10,7 @@ !* (at your option) any later version. !* !* The FV3 dynamical core is distributed in the hope that it will be -!* useful, but WITHOUT ANYWARRANTY; without even the implied warranty +!* useful, but WITHOUT ANY WARRANTY; without even the implied warranty !* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. !* See the GNU General Public License for more details. !* @@ -262,12 +262,11 @@ end subroutine fv_climate_nudge_init !################################################################################### subroutine fv_climate_nudge (Time, dt, is, ie, js, je, npz, pfull, & - lon, lat, phis, ptop, ak, bk, & + lon, lat, phis, ak, bk, & ps, u, v, t, q, psdt, udt, vdt, tdt, qdt ) type(time_type), intent(in) :: Time real, intent(in) :: dt integer, intent(in) :: is, ie, js, je, npz -real, intent(IN) :: ptop real, intent(in) :: phis(is:ie,js:je) real, intent(in) :: lon (is:ie,js:je) @@ -439,15 +438,15 @@ subroutine fv_climate_nudge (Time, dt, is, ie, js, je, npz, pfull, & enddo if (get_wind) then - call remap_3d (is, ie, js, je, nlev_obs, npz, phaf_obs, u_obs, phaf, State(n)%u, -1, ptop) - call remap_3d (is, ie, js, je, nlev_obs, npz, phaf_obs, v_obs, phaf, State(n)%v, -1, ptop) + call remap_3d (is, ie, js, je, nlev_obs, npz, phaf_obs, u_obs, phaf, State(n)%u, -1) + call remap_3d (is, ie, js, je, nlev_obs, npz, phaf_obs, v_obs, phaf, State(n)%v, -1) endif if (get_qhum .or. get_temp) then - call remap_3d (is, ie, js, je, nlev_obs, npz, phaf_obs, q_obs, phaf, State(n)%q(:,:,:,1), 0, ptop) + call remap_3d (is, ie, js, je, nlev_obs, npz, phaf_obs, q_obs, phaf, State(n)%q(:,:,:,1), 0) endif if (get_temp) then ! use logp - call remap_3d (is, ie, js, je, nlev_obs, npz, lphaf_obs, t_obs, lphaf, State(n)%t, 1, ptop) + call remap_3d (is, ie, js, je, nlev_obs, npz, lphaf_obs, t_obs, lphaf, State(n)%t, 1) State(n)%t = State(n)%t/(1.+ZVIR*State(n)%q(:,:,:,1)) ! virtual effect endif @@ -1023,7 +1022,7 @@ end subroutine remap_ps !--------------------------------------------------- subroutine remap_3d( is, ie, js, je, km, npz, & - pe0, qn0, pe1, qn1, n, ptop ) + pe0, qn0, pe1, qn1, n ) !-------- ! Input: @@ -1035,7 +1034,6 @@ subroutine remap_3d( is, ie, js, je, km, npz, & real, intent(in):: qn0(is:ie,js:je,km) ! scalar quantity on input data levels real, intent(in):: pe1(is:ie,js:je,npz+1) ! pressure at layer interfaces for model data integer, intent(in):: n ! -1 wind; 0 sphum; +1 ptemp - real, intent(IN):: ptop !-------- ! Output: @@ -1046,7 +1044,7 @@ subroutine remap_3d( is, ie, js, je, km, npz, & integer :: i, j, k do j = js,je - call mappm(km, pe0(is:ie,j,:), qn0(is:ie,j,:), npz, pe1(is:ie,j,:), qn1(is:ie,j,:), is,ie, n, 8, ptop) + call mappm(km, pe0(is:ie,j,:), qn0(is:ie,j,:), npz, pe1(is:ie,j,:), qn1(is:ie,j,:), is,ie, n, 8) enddo end subroutine remap_3d diff --git a/GFDL_tools/fv_cmip_diag.F90 b/GFDL_tools/fv_cmip_diag.F90 index 0ef4e558a..c7fed4de0 100644 --- a/GFDL_tools/fv_cmip_diag.F90 +++ b/GFDL_tools/fv_cmip_diag.F90 @@ -10,7 +10,7 @@ !* (at your option) any later version. !* !* The FV3 dynamical core is distributed in the hope that it will be -!* useful, but WITHOUT ANYWARRANTY; without even the implied warranty +!* useful, but WITHOUT ANY WARRANTY; without even the implied warranty !* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. !* See the GNU General Public License for more details. !* diff --git a/GFDL_tools/read_climate_nudge_data.F90 b/GFDL_tools/read_climate_nudge_data.F90 index a792adb03..8435125b2 100644 --- a/GFDL_tools/read_climate_nudge_data.F90 +++ b/GFDL_tools/read_climate_nudge_data.F90 @@ -11,7 +11,7 @@ !* (at your option) any later version. !* !* The FV3 dynamical core is distributed in the hope that it will be -!* useful, but WITHOUT ANYWARRANTY; without even the implied warranty +!* useful, but WITHOUT ANY WARRANTY; without even the implied warranty !* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. !* See the GNU General Public License for more details. !* diff --git a/README.md b/README.md index 4c9f4348a..6d3020965 100644 --- a/README.md +++ b/README.md @@ -1,6 +1,6 @@ # GFDL_atmos_cubed_sphere -The source contained herein merges in the [2021 January Release](https://github.com/NOAA-GFDL/GFDL_atmos_cubed_sphere/releases/tag/FV3-202101-public) of the Finite Volume Cubed-Sphere Dynamical Core (FV3) for use in the current GFDL models (AM4/CM4/ESM4/SPEAR). +The source contained herein merges in the [2022 April Release](https://github.com/NOAA-GFDL/GFDL_atmos_cubed_sphere/releases/tag/FV3-202204-public) of the Finite Volume Cubed-Sphere Dynamical Core (FV3) for use in the current GFDL models (AM4/CM4/ESM4/SPEAR). # Where to find information diff --git a/RELEASE.md b/RELEASE.md index 40160733c..e19dfd9aa 100644 --- a/RELEASE.md +++ b/RELEASE.md @@ -1,4 +1,26 @@ # RELEASE NOTES for GFDL FV3: Summary +GFDL_2022.XX.YY --- July 2022 + +This version has been tested against the current SHiELD physics +and with FMS release 2022.01 from https://github.com/NOAA-GFDL/FMS + +This release includes the following: +- Release of stand-alone solo_core functionality with simple physics. +- Updated GFDL Microphysics, used for real-time 2021 C-SHiELD and T-SHiELD. (L Zhou) +- Merges numerous updates from dev/emc. +- Leverage DA functionality from UFS with additional changes (M Tong). +- Updates to use the latest FMS release, including fms2_io. +- Adds license header to missing files and fixes typo in header. +- Fixes a bug where long_name and units attributes were not being captured in restart files. +- Adds the ability to specify prefix and directory when reading and writing restarts. +- The planetary radius and rotation rate are now re-scalable by a namelist parameter (small_earth_scale) instead of using exclusively the hard-coded FMS constant. +- Removes obsolete driver/SHiELD files. +- Removes unused function fv_diagnostics::max_vorticity_hy1. +- Removes avec timer remnants. +- Removes old style namelist read in favor of read from internal character variable. +- Adds option for a mean wind. +- Addresses GNU warnings. + # RELEASE NOTES for GFDL_2021.03.01: Summary GFDL_2021.03.01 --- August 2021 diff --git a/docs/examples/FV3_level_transmogrifier/FV3_level_transmogrifier.ipynb b/docs/examples/FV3_level_transmogrifier/FV3_level_transmogrifier.ipynb new file mode 100644 index 000000000..c104e4d3e --- /dev/null +++ b/docs/examples/FV3_level_transmogrifier/FV3_level_transmogrifier.ipynb @@ -0,0 +1,519 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "218a1412", + "metadata": { + "tags": [] + }, + "source": [ + "This notebook takes a few ideas from a package developed from Xi Chen to help evaluate the placement of vertical levels, and to find discontinuous levels by inspection. This is an **interactive** notebook intended to be downloaded and played with, so you can modify the levels and then re-run to create the plots at the bottom. \n", + "\n", + "This requires the file `std_atmos_1976.py`, and also `fv_eta.F90` and `fv_eta.h` if you wish to use `set_eta()` from this notebook (instructions below)." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "b257bcf1", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from matplotlib import ticker, cm, colors\n", + "import os\n", + "from scipy import interpolate as sci_interp\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "904dde21", + "metadata": { + "jupyter": { + "source_hidden": true + }, + "tags": [] + }, + "outputs": [], + "source": [ + "large = 24; med = 20; small = 16\n", + "params = {'axes.titlesize': large,\n", + " 'legend.fontsize': med,\n", + " 'figure.figsize': (8, 4),\n", + " 'axes.labelsize': med,\n", + " 'axes.titlesize': large,\n", + " 'xtick.labelsize': small,\n", + " 'ytick.labelsize': small,\n", + " 'figure.titlesize': large,\n", + " 'axes.titlepad': 6}\n", + "plt.rcParams.update(params)" + ] + }, + { + "cell_type": "markdown", + "id": "5b51e6e8", + "metadata": {}, + "source": [ + "The following cell (hidden by default) contains several sample ak/bk sets:\n", + "\n", + "- ak_gfs, the GFS v15 63 level setup\n", + "- ak47, a well-designed 47-level setup for QBO simulation in HiRAM\n", + "- ak_bad, an example of a poor choice of levels with lots of discontinuities\n", + "\n", + "The first two are examples of well-chosen level setups, which show acceptable values of the different level quantities. The third shows how well-meaning level setups can go wrong; this one has significant instability problems when implemented within a model.\n", + "\n", + "You can edit the ak/bk and see below how new values change the results below. You can also add new sets of levels yourself.\n", + "See more levels at [https://gitlab.gfdl.noaa.gov/fv3team/atmos_cubed_sphere/-/blob/main/tools/fv_eta.h]" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "50f5c28f", + "metadata": { + "jupyter": { + "source_hidden": true + }, + "tags": [] + }, + "outputs": [], + "source": [ + "ak_bad = np.array([64.247, 221.958, 428.434, \\\n", + " 698.457, 1051.07995, 1510.71101, \\\n", + " 2108.36604, 2883.03811, 3883.05187, \\\n", + " 5167.14603, 6804.87379, 8875.64338, \\\n", + " 11264.35673, 12190.64366, 12905.42546, \\\n", + " 13430.87867, 13785.88765, 13986.77987, \\\n", + " 14047.96335, 13982.46770, 13802.40331, \\\n", + " 13519.33841, 13144.59486, 12689.45608, \\\n", + " 12165.28766, 11583.57006, 10955.84778, \\\n", + " 10293.60402, 9608.08306, 8910.07678, \\\n", + " 8209.70131, 7516.18560, 6837.69250, \\\n", + " 6181.19473, 5552.39653, 4955.72632, \\\n", + " 4394.37629, 3870.38682, 3384.76586, \\\n", + " 2937.63489, 2727.04570369, 2528.37666, 2336.65414612, 2155.78385, 1982.07937049, \\\n", + " 1818.20722, 1661.50963777, 1513.68173, 1372.87365583, 1240.03585, 1113.94503709, \\\n", + " 994.99144, 882.42791485, 776.23591, 676.02580495, 581.48797, 492.49223786, \\\n", + " 408.53400, 329.6675301, 255.26520, 185.5095999, 119.70243, 58.10797573, \\\n", + " 0. ])\n", + "\n", + "bk_bad = np.array([ 0.00000, 0.00000, 0.00000, \\\n", + " 0.00000, 0.00000, 0.00000, \\\n", + " 0.00000, 0.00000, 0.00000, \\\n", + " 0.00000, 0.00000, 0.00000, \\\n", + " 0.00201, 0.00792, 0.01755, \\\n", + " 0.03079, 0.04751, 0.06761, \\\n", + " 0.09097, 0.11746, 0.14690, \\\n", + " 0.17911, 0.21382, 0.25076, \\\n", + " 0.28960, 0.32994, 0.37140, \\\n", + " 0.41353, 0.45589, 0.49806, \\\n", + " 0.53961, 0.58015, 0.61935, \\\n", + " 0.65692, 0.69261, 0.72625, \\\n", + " 0.75773, 0.78698, 0.81398, \\\n", + " 0.83876, 0.85039942, 0.86138, 0.87194913, 0.88192, 0.89148058, \\\n", + " 0.90050, 0.9091035, 0.91722, 0.92494359, 0.93223, 0.93913544, \\\n", + " 0.94565, 0.95180932, 0.95762, 0.9631001, 0.96827, 0.97312748, \\\n", + " 0.97771, 0.98201689, 0.98608, 0.98988262, 0.99347, 0.9968301, \\\n", + " 1. ])\n", + "\n", + "ak_gfs = np.array([64.247, 137.790, 221.958, \\\n", + " 318.266, 428.434, 554.424, \\\n", + " 698.457, 863.05803, 1051.07995, \\\n", + " 1265.75194, 1510.71101, 1790.05098, \\\n", + " 2108.36604, 2470.78817, 2883.03811, \\\n", + " 3351.46002, 3883.05187, 4485.49315, \\\n", + " 5167.14603, 5937.04991, 6804.87379, \\\n", + " 7780.84698, 8875.64338, 10100.20534, \\\n", + " 11264.35673, 12190.64366, 12905.42546, \\\n", + " 13430.87867, 13785.88765, 13986.77987, \\\n", + " 14047.96335, 13982.46770, 13802.40331, \\\n", + " 13519.33841, 13144.59486, 12689.45608, \\\n", + " 12165.28766, 11583.57006, 10955.84778, \\\n", + " 10293.60402, 9608.08306, 8910.07678, \\\n", + " 8209.70131, 7516.18560, 6837.69250, \\\n", + " 6181.19473, 5552.39653, 4955.72632, \\\n", + " 4394.37629, 3870.38682, 3384.76586, \\\n", + " 2937.63489, 2528.37666, 2155.78385, \\\n", + " 1818.20722, 1513.68173, 1240.03585, \\\n", + " 994.99144, 776.23591, 581.48797, \\\n", + " 408.53400, 255.26520, 119.70243, 0. ])\n", + "\n", + "bk_gfs = np.array([0.00000, 0.00000, 0.00000, \\\n", + " 0.00000, 0.00000, 0.00000, \\\n", + " 0.00000, 0.00000, 0.00000, \\\n", + " 0.00000, 0.00000, 0.00000, \\\n", + " 0.00000, 0.00000, 0.00000, \\\n", + " 0.00000, 0.00000, 0.00000, \\\n", + " 0.00000, 0.00000, 0.00000, \\\n", + " 0.00000, 0.00000, 0.00000, \\\n", + " 0.00201, 0.00792, 0.01755, \\\n", + " 0.03079, 0.04751, 0.06761, \\\n", + " 0.09097, 0.11746, 0.14690, \\\n", + " 0.17911, 0.21382, 0.25076, \\\n", + " 0.28960, 0.32994, 0.37140, \\\n", + " 0.41353, 0.45589, 0.49806, \\\n", + " 0.53961, 0.58015, 0.61935, \\\n", + " 0.65692, 0.69261, 0.72625, \\\n", + " 0.75773, 0.78698, 0.81398, \\\n", + " 0.83876, 0.86138, 0.88192, \\\n", + " 0.90050, 0.91722, 0.93223, \\\n", + " 0.94565, 0.95762, 0.96827, \\\n", + " 0.97771, 0.98608, 0.99347, 1.\n", + "])\n", + "\n", + "ak47= np.array([ 10.00000, 24.45365, 48.76776, \\\n", + " 85.39458, 133.41983, 191.01402, \\\n", + " 257.94919, 336.63306, 431.52741, \\\n", + " 548.18995, 692.78825, 872.16512, \\\n", + " 1094.18467, 1368.11917, 1704.99489, \\\n", + " 2117.91945, 2622.42986, 3236.88281, \\\n", + " 3982.89623, 4885.84733, 5975.43260, \\\n", + " 7019.26669, 7796.15848, 8346.60209, \\\n", + " 8700.31838, 8878.27554, 8894.27179, \\\n", + " 8756.46404, 8469.60171, 8038.92687, \\\n", + " 7475.89006, 6803.68067, 6058.68992, \\\n", + " 5285.28859, 4526.01565, 3813.00206, \\\n", + " 3164.95553, 2589.26318, 2085.96929, \\\n", + " 1651.11596, 1278.81205, 962.38875, \\\n", + " 695.07046, 470.40784, 282.61654, \\\n", + " 126.92745, 0.00000, 0.00000 \n", + "])\n", + "bk47 = np.array([ 0.0000, 0.0000, 0.0000, \\\n", + " 0.00000, 0.00000, 0.00000, \\\n", + " 0.00000, 0.00000, 0.00000, \\\n", + " 0.00000, 0.00000, 0.00000, \\\n", + " 0.00000, 0.00000, 0.00000, \\\n", + " 0.00000, 0.00000, 0.00000, \\\n", + " 0.00000, 0.00000, 0.00000, \\\n", + " 0.00267, 0.01063, 0.02393, \\\n", + " 0.04282, 0.06771, 0.09917, \\\n", + " 0.13786, 0.18444, 0.23925, \\\n", + " 0.30193, 0.37100, 0.44379, \\\n", + " 0.51695, 0.58727, 0.65236, \\\n", + " 0.71094, 0.76262, 0.80757, \\\n", + " 0.84626, 0.87930, 0.90731, \\\n", + " 0.93094, 0.95077, 0.96733, \\\n", + " 0.98105, 0.99223, 1.00000 \n", + "])" + ] + }, + { + "cell_type": "markdown", + "id": "312b4454", + "metadata": { + "tags": [] + }, + "source": [ + "There are a few user configuration parameters you can set up. These are surface elevations, whether to plot the vertical coordinate as a log coordinate, or which vertical coordinate to use: either pressure, height (z), or individual model levels (k)." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "169121ad", + "metadata": {}, + "outputs": [], + "source": [ + "#User-configurable parameters\n", + "\n", + "zss = np.arange(0,5001.,2500.)\n", + "\n", + "do_ylog = False\n", + "zcoord_type='p' #p,z,or k\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "1805a854", + "metadata": { + "jupyter": { + "source_hidden": true + }, + "tags": [] + }, + "outputs": [], + "source": [ + "def fv3_level_make_plots(ak,bk,levname,zss,do_ylog,zcoord_type):\n", + " \n", + " #Load standard atmosphere\n", + " #Taken from /home/lmh/research/xic_levels\n", + "\n", + " data = np.loadtxt('std_atmos_1976.txt')\n", + " zstd = data[:,0]\n", + " Tstd = data[:,1]\n", + " pstd = data[:,2]\n", + "\n", + " #Prepare interpolation between z and p\n", + " Iz2p = sci_interp.interp1d(zstd,pstd,kind='linear')\n", + " Ip2z = sci_interp.interp1d(pstd,zstd,kind='linear')\n", + "\n", + " fig,ax = plt.subplots(1,6,figsize=(24,11),sharey=True)\n", + "\n", + " for zs in zss:\n", + " #Compute p and auxiliary quantities\n", + " ps = Iz2p(zs)\n", + " pe = ak + bk*ps\n", + " delp =np.diff(pe)\n", + " logpe = np.log(pe)\n", + " dlogp = np.diff(logpe)\n", + " pm = delp/dlogp\n", + "\n", + " ze = Ip2z(pe)\n", + " dz = -np.diff(ze)\n", + " zm = 0.5*(ze[:-1] + ze[1:])\n", + "\n", + " npz = pm.size\n", + " ke = np.arange(npz+1) - 0.5\n", + " km = np.arange(npz)\n", + "\n", + " zcoords_m = {'p':pm,'z':zm,'k':km}\n", + " zcoords_e = {'p':pe,'z':ze,'k':ke}\n", + "\n", + " zcoord_labels = {'p':'Pressure [Pa]','z':'Height ASL [m]','k':'Coordinate Layer'}\n", + "\n", + "\n", + " zcoord_m = zcoords_m[zcoord_type]\n", + " zcoord_e = zcoords_e[zcoord_type]\n", + "\n", + " ax[0].plot(delp,zcoord_m,'.-',markersize=10)\n", + " ax[0].set_title('delp [Pa]')\n", + " if zcoord_type != 'k':\n", + " dxax = np.diff(ax[0].get_xlim())[0]\n", + " ax[0].text(delp[-1]+dxax*0.05,zcoord_m[-1],'p_s = %d hPa\\nz_s = %d m' % (ps/100.,zs),\n", + " horizontalalignment='left',verticalalignment='center',)\n", + "\n", + " ax[1].plot(delp[:-1]/delp[1:],zcoord_e[1:-1],'.-',markersize=10)\n", + " ax[1].set_title('ratio delp')\n", + "\n", + "\n", + " ax[2].plot(dlogp,zcoord_m,'.-',markersize=10)\n", + " ax[2].set_title('dlogp [Pa]')\n", + "\n", + " ax[3].plot(dlogp[:-1]/dlogp[1:],zcoord_e[1:-1],'.-',markersize=10)\n", + " ax[3].set_title('ratio dlogp')\n", + "\n", + "\n", + " ax[4].plot(dz,zcoord_m,'.-',markersize=10)\n", + " ax[4].set_title('dz[m]')\n", + "\n", + " ax[5].plot(dz[:-1]/dz[1:],zcoord_e[1:-1],'.-',markersize=10)\n", + " ax[5].set_title('ratio dz')\n", + "\n", + " if zcoord_type in ('p','k'):\n", + " ax[0].invert_yaxis()\n", + " if do_ylog:\n", + " ax[0].set_yscale('log')\n", + "\n", + " ax[0].set_ylabel(zcoord_labels[zcoord_type])\n", + "\n", + " #plt.suptitle('%s (%d): p_s = %d hPa, z_s = %d m' % (levname, npz, ps/100., zs));\n", + " plt.suptitle('%s (%d)' % (levname, npz)); " + ] + }, + { + "cell_type": "markdown", + "id": "aa3c78ce", + "metadata": {}, + "source": [ + "This will make plots of different pressure/height increments on model levels with different surface elevations. The goal is to eliminate discontinuities or spikes in any of these fields, which can lead to numerical error or instability. Be sure to check the x-axes, which may differ greatly between variables and level setups.\n", + "\n", + "For the three sample levels shown here (GFS, HiRAM QBO, and \"Bad\") you can see some interesting features:\n", + "- The GFS v15 levels are pretty well-made, with mostly smooth profiles. There is some evidence of their heritage in relatively coarse-resolution, hydrostatic spectral global models (this level setup dates to 2002 when the GFS ran with a 100 km nominal resolution): in particular there is a noticable (but small---check the x-axis again!) kink in the ratios at about 100 mb where the hybridization transitions to a pure-pressure coordinate, which is more noticable over high topography that wouldn't be resolved in a coarser model. \n", + "- The HiRAM QBO levels uses a higher level to transition to a pure pressure coordinate, has a decidedly coarser spacing in the mid-troposphere (common in many climate models), and isn't quite as smooth as the GFS levels. The kinks in the coordinates are about of the same size as in the GFS L63.\n", + "- The \"Bad\" levels have some serious problems, as seen by the kinks several places in the profile and by the poor hybridization.\n", + "\n", + "Note that this is for a **standard** atmosphere; pathological temperature structures may exist that can cause odd results." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "ce7df1c7", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABaQAAALJCAYAAABLFySuAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAEAAElEQVR4nOzdd5wU9f3H8ddn927vjs4B0qSDgAgBS2woWLAl0Rg1auzRaJoxRU3/xTRNNMU0EzSWWGLsGjUWLKDYaYIICCJFkN65smW+vz9m5m7vbq+3vbv3k8c+9nZ2yneX/c5n5jvf+XzNOYeIiIiIiIiIiIiISHOLtHYBRERERERERERERKRjUIO0iIiIiIiIiIiIiLQINUiLiIiIiIiIiIiISItQg7SIiIiIiIiIiIiItAg1SIuIiIiIiIiIiIhIi1CDtIiIiIiIiIiIiIi0CDVIi4iIiIiIiIiIiEiLUIO0iIiIiEgrMLOpZubMbFVrl6WxzGxV8FmmtuA2x5hZ0sxmtdQ2a2NmPw6+h2+0dllEREREspUapEVERETaKTPLN7OvmNkjZvaRme0xs1Iz22BmL5nZL81sQg3Luzo+emRY9gtm9riZrQ22ucvMPjCzGWb2MzObYmbWrF9AxfIcZmZXmdm9ZrbUzLyg7L+pw7Iz6/Ad/LUlPodUcD0QBX5Z00xmNtHMbjWzFWZWbGbbzGyhmd1iZhMzzD/azH5iZv81s2XB/HEz22hmz5nZRWZW3XnUX4AdwE/NrHMjP5+IiIhIu5TT2gUQERERkaZnZp8DpgP90yaXAHuBPsAxweMnZjYD+JJzbks1q9sFFNewOS9tu52Ah4GT096PA0lgBDAKOD6Y3hO/8a4lPAt0b+Q6avoedjVy3VIPZnYocDrwlnPuhRrm+wlwHX7DNfj/T52A8cFjPbCg0mKnU7GRuxj/N7wPcELwuMzMPuOcq/D/7pzbFVyc+AnwbeDX9f90IiIiIu2bekiLiIiItDNmdinwOH5j9DLgy8AA51yBc64QiAEHAT/Fb5CbBuxbwyqvcs71q+GR3ij3R/zG6AR+D9ahQH6w3S7AUcBNwMam+8R1Ugy8DfwNuISqjZB1UdP38KOmLKzU6rvB863VzWBm38dvWPaAnwMDnXPdgQJgMPBV4L0Miy4GfggcAfRwznVyznXBb5D+Pv7Flcn4v/VM/hk8X2lm6gAkIiIiUokOkERERETaETM7ELgFv+PBE8A5zrmS9HmccylgHjDPzG7Eb5hONMG2uwEXBy9/5Jz7XaXtFgOzgdlBz9VkY7dZD/sGnxsAM7u4BbctTcjMegGn4fdafrSaecZR3sv5Iufc/eF7zjkHrMW/g6AK59yTwJMZpm8GbjSzrvg9oL9kZl91ziUqzbfazN4ADgc+i39xSEREREQC6iEtIiIi0r78Cr8H9Grg/MqN0ZU55+LOuZ865xY3wbZHB9sGeKoO2/VqmidkZgVBDmpnZp+tZd6lwXzfqrS9VHXLZDMzG2pmfwlyGReZ2W4zm2tm36+co9jMJgefPW5mhTWsc6CZpYJ5q+QQr8826/gZPmVmd5s/8GFpsL6VZvasmX07SPNSH+cBecAM59yOaua5GsgN5rm/mnka6p3gOR+o7nt+MHi+pIm3LSIiItLmqUFaREREpJ0ws0GU527+k3NuTysWZ2BTrSjoWf148PJL1c0X9A4fDaSAB5pq+63FzL4ALAG+CewXTI4BBwK/Ad4ws75pi7yGfyEiFzizhlWfjX8esNg5t7CR26ztM5yC34B7ATAEcPgpNIYBJ+KnvRhc1/UFTgieX6tmm7nAF4OXd9Vz3XVxRPBcBGyqZp6wbMcqbYeIiIhIRWqQFhEREWk/pqT9/XQrbH8x5YP+3WRmQ5tw3f8Onk+toUftucHzS8655shRfbWZrQ96IG82sxfN7Gtmlt/UGzKzQ4D/4Dcu/xa/Mbcz/oB8hwFv4Q/Kd3e4TJCK4j/By3OpXvjev9MnNmSbdfCXYH1PAaOdc/lBHufuwNHAbfiDbdaJmRl+KgyAudXMNiEoM/jpYc40s1eDXva7zWy+mf3IzLrUY7sFZjbazH4BXBNM/lvwnWfyLn5KkS7AxLpuR0RERKQjUIO0iIiISPsxNnguAZY34Xr/ZGYbqnmcFM7knCvCH7AQYBKwwsxeM7ObzOysoAd3Q83A743aGT9/cAVBQ+XZwct/V36/iYzDT9GwF+gNHIufr/ttM6tvL9/a/BG/Ifca59wPnHNrnC/lnHsLvyf8euAEMzs4bbn7guejzaxKL3UzGwmE81dOZdHQbWZkZvsAw4OXlznnPgjfc87tcs696py73Dm3qrZ1pRlJeZqMhdXMMyp4TgBfBx7CH4TQCz7fRODXwFtm1q+Wz5A0M4ffG3opfr51D////cfVLeeci+MPKApwaI2fSERERKSDUYO0iIiISPsRNtTtqK7nppn9uJqG5T/VsN5uQN9qHpV7B18H/AjYA0Tx0xtcjZ9Td42ZLTazbwZpFeosyAH9UPAyU+/fycAg/Mb4jAPdNcJM4EKgP1DgnOuJ/9l/BJTi9xr+n5nFql1DPZjZCOBI/N7m/8g0j3NuO/BM8HJa2vRFwHv4x/lnZ1g0/O7ecM591BTbrMFu/MZb8L+7ppC+nq3VzNMjeM4Bvg+8Aox1zvUAugLn419U2B+4p5btbQA2Ut7zH+DvwK8rD2aYwZYMZRYRERHp8NQgLSIiItKxdCVzw3L3Gpa5xDln1TweT58x6FF7A34O6YuAO/FTeYSDCu6Pn8bhpQYMZhf2fD4pw6B9YW7pp51zu+q53ho5565zzt3jnNsQNvQ75zYFn/OMYLZxwMVNtMkwR3EM+Ki63unAOcF8lXuehz2fM+Xbzpiuowm2WUWQ+3tW8PI5M/uJmU00s2hty9agd/C8p4YG4fAcx4DtwGnOuaVBmRLOufvwG6oBjg9SlVT3GfZ1zvXD75k/BPg98DVgkZlNqW65wPZKZRYRERER1CAtIiIi0p5sC557BCksqghSMZQ1KFOe4qFJBSkZ7nbOfdk5dwB+o9y5+I3T4Pdo/nU91/k68BF+2oWwIZhg0LhwEL/mStdRXZmexu+BC/C5Jlpt2KM2SvU90/viN5JCeb7kUPgdHGRmYfoKzGwiflqXFH6P9abcZnUuwx8kcR/gl8B8YIeZPW1m5zdgwL+84Dlewzzpg3ne7ZzbkWGeW/F7SQMcX9tGgwsta5xzVwPfxb8b4X4z61zDYmFu7ILa1i8iIiLSkahBWkRERKT9WBI851OeRzcrOOd2OOf+g5+/OGyUvsjM6ns8Gg7al977dxp+g/dOWmcwx7eC5+E1zlV34Xcyv4ae6emPi9MXDnIyvxG8TP+ewt7RLzjnNjXlNqvjnFuJP8jg6fiNwEvwB/o7BT9dxlv1GVyQ8osu3au76IKf5zq0LNMMQe/qlcHL+uY2vxU/VUt/4KQa5usZPFeXWkRERESkQ1KDtIiIiEj7MSvt78+0Wilq4JwrobxXdk+gTz1XkT5o34Dg77Ch9VHnXGkji9gQYcNoxrzdDbAxeB7VgB7EobCX9LlQNujjOZXea+ptZuScSzrnHnfOXeGc2x+/Ifca/B7EBwI/q8fqwrzMUfz0M5ksTvu7Lv8n9fp/C35jYSPziBpmDRukt9Qwj4iIiEiHowZpERERkXbCObeW8kHnrqpnz9OWtDft75pSL1ThnFsMLMI/jj3HzPKBzwdvt2i6jjSfDp5XNdH6wt7NXYATGriOB4AkMNrMDsTPET0Yf3C+x5ppm3US5OL+HXBzMKm2XMzpllM+UOKwatb/CeV3C4zJNE8wqGbYo311PbZPUK/CCyl7aph1aPC8tD7rFxEREWnv1CAtIiIi0r78BL+Rdwhwb9Bg2yLMrHeQp7imeSLA2cHL1c657TXNX4303r+fw+8puwF4uQHrqlENaSHC908Cjg5eNkm6kGAAvjeDl7+tKU+xmRWYWV7l6c65zcCLwctzKU/d8ZRzbndzbDPDfLm1fH/FwXOt60or5y7gveDlwTXMek/wfJGZ9czw/uWU58N+Jv2NOvQQvwo/jznAq5lmMLN9gX7By9m1rE9ERESkQ1GDtIiIiEg74pybB3wdvxfpacACM/uymYWD1mG+EWZ2DXBiE26+HzDfzGaY2cVmNiRtm/lmNhV4Hr+3LsCfG7idf+OnWTgY+GEw7QHnXKq6BcysS9Bg3tvMelPeoFiQPt3MKg/W9wMzu8PMpplZ17T19TGza4FHg0nLgDsa+HkyuRI/T/EBwKtmdnzYUGpmETMbZ2Y/AT6kfEDCysKG+3OAsypNa65tphsHvGdm3zaz/cLG6aCh+gz8wQEBnqvDutKFDbyH1DDPn4G1QA/gMTMbk7btLwG/DeZ72Dm3qNKy75vZlUEdKWtQN7PRZvYn/MEZAR7LsGwoLNuyDPm6RURERDo0c66pUt2JiIiISLYws8/hD77WL21yCX6Kga5U7JX6DPAd51yFAeDMLDxQvMQ5d1cdtjkGeJ/ynMrgN3AWUZ5PN3QLcKVzzqMBzGw2cGTapEOdc2/XMP9dwEV1WPXPnXPXpS13HeU5jh2wK3jukbbMIuDUYDDBOgsa6F/G7yk+NMP7JwP3A92DSXFgN9CN8gZ1gKHOuSppJ4IG9I1AQTBpB9CvpjzbDd2mma3C75V/jHNuZjBtIjA/bZlS/HQtPSjvGDMHOC7o+VwnZnY0fr70NUE5Mp7QmNmngBmUp9fYgf9dhL/9N4CTnXM7Ky2Xvr5S/M/fmfLvEeBZ4CznXMaUHWb2T+BS4BfOufrkyBYRERFp95p0wBIRERERyQ7OuSfNbDhwPnAy/uBxffAbFrfh9+h9DbjPOfd+E21zadAr+nP4aSwmAIOCbe7Gz7H8BnCnc+7N6tZTR/dR3iD9YU2N0Y30EP4x8xH4A9j1wm+Y/QRYADyM/x02+WCKzrlnzGw//J7LpwAj8Rtzd+D//z0LPJSpMTpYfreZPQl8MZj0SG3lbOw2K1kCnAkcDxwKDMD//sK0Gw8Atzrn6ptH/BUz+wDYD///5bVq5nvXzA4Avo//mxyE38A+D//3c1s12z4VOA7/9zUAv94kgBXA2/j/3/+rrnxBfurT8S9c3FmfzyYiIiLSEaiHtIiIiIiItClmdjVwE/A359w3W7s86YK7E/4LPO+ca8qUOCIiIiLtghqkRURERESkTQkGXVyBn35miHNuaysXqYyZzcK/Q+DwJrgTQERERKTd0aCGIiIiIiLSpjjn9gK/wM/t/J1WLk4ZM5uM3xj9hBqjRURERDJTDmkREREREWmLbsPPSZ1xYMFW0gP4OX6OahERERHJQCk7RERERERERERERKRFKGWHiIiIiIiIiIiIiLQINUiLiIiIiIiIiIiISItQg7SIiIiIiIiIiIiItAg1SIuIiIiIiIiIiIhIi1CDtIiIiIiIiIiIiIi0CDVIi4iIiIiIiIiIiEiLUIO0iIiIiIiIiIiIiLQINUiLiIiIiIiIiIiISItQg7SIiIiIiIiIiIiItAg1SIuIiIiIiIiIiIhIi1CDtIiIiIiIiIiIiIi0CDVIi4iIiIiIiIiIiEiLUIO0iIiIiIiIiIiIiLQINUiLiIiIiIiIiIiISItQg7SIiIiIiIiIiIiItAg1SIuIiIiIiIiIiIhIi1CDtIiIiIiIiIiIiIi0CDVIi4iIiIiIiIiIiEiLUIO0iIiIiIiIiIiIiLQINUiLiIiIiIiIiIiISItQg7SIiIiIiIiIiIiItAg1SIuIiIiIiIiIiIhIi1CDtIiIiIiIiIiIiIi0CDVIi4iIiIiIiIiIiEiLUIO0iIiIiIiIiIiIiLQINUiLiIiIiIiIiIiISItQg7SIiIiIiIiIiIiItAg1SIuIiIiIiIiIiIhIi1CDtIiIiIiIiIiIiIi0CDVIS7MxMxc8hjbhOmcG67y4qdZZh21el/ZZwsd1LbX9Gsr1eIZyTW3tcknHY2Z3ZUu9SGdmq5q6XmTrZ5XsVl08TIsvd7VOyVqOmU3NELNmZkG5vp2NMV7anmyND9XFQjO7OFvqoYiISEO0tdgrFalBWqTuSoCNwWNP5TfTGsvTH56Z7TCzt83s/8yssAnLsz2tPF4TrlcEADPrETSYXdfaZRGRdsOjPHZtq/xmNReBnZntMbMlZnaLmY1uwvLsTStPSROuV9oJxUKR9qUpOk1lw0VWM/t8hjLc1ZJlEGkuir0dQ05rF0CkDXnAOXdxHeYrAXYGf0eB3sAhweNyMzvOObessYVxzl0S/m1mq4AhjV2nSCU9gJ8Ff19Xw3yfAMuALc1cHhFp+9Y654bWYT4P2Jz2ujcwJnh82czOd8493NjCOOduA24Dv5cNcFFj1yntTg8UC0Uks/RYVeUiazMLO0sBdAE6t/D2RZpTDxR72z31kBZpeg845/oFjz5Ad+A7QCkwEPiPmVmrllCkCTnnfuicG+Oc+2trl0VE2o21abG0H9AJ+BzwMZAH3G1mA1q1hCJpFAtFOqT0WPWFltywc+7ZtBj5u5bctki2UOxt29QgLdLMnHO7nHM3A78OJk0EDmu1AomIiLQxzrm4c+4p4LxgUgHqzSwiIiIi0iapQVoazMwiZnalmb1rZsVmttnMnjSzw+u4fB8zu8HMFgW5Ifea2Xtm9uv65lpOy+O1Knj9OTN72cy2B+t+w8y+1ICP2ZTuT/v7IAAzi5nZZ8zstuB73GJmJWa22szuM7ODWqms0gakD5ZgZgOD3KorzazUzBakzdffzL5mZk+b2XIzKzKzXWY238x+bmY9Mqx7JvBR2utqB/2qbTAJM8szs++a2VtmtjPYXywzsz+YWb9GfgfnmdmbQT3fZmYvmdln6rhsFzP7kZm9E5SrJPh+/mxmg+pZjqHhdxO8PtLMngr2i0VmtsDMvmlmirvtUGPjYS3rvdTMZgW/7xIz+8jMbjWzkbUsu6+Z3W5m64LlVprZH82sp9UwmFlaHR9qZgeY2X/MbEOwjqVm9lMzy2vM52oM59wrwLrgZVmMNLNDg2OKN4PPHDezTWb2rJmd2TqllZagWNi4WFjLer8Q1KHNwff5sfnHpwfWslzPYH+zKlhurZn908wGWaVj9krLpf9fDg6WWZu27/udmXVv7OcSEZHGUeytf+y18uPv2h6rGlOutkQ5pKVBzCwHeBg4LZiUxP89fRY4yczOrmX5ycATQNjwHAdSwLjgcYGZTWtIrmUzuwq4GXD4uZwL8HskH2ZmhzvnrqzvOpvIurS/uwXPJwBPpk0vwi/3YOBLwBfN7MvOuXtapojSRu0HPISfY7UISFR6/y/AGWmvd+D/BicGj/PMbKpz7uO0ebbh5+LqHbzeSEVVBvbMxMz6AM8Bk4JJpfj1fb/gcbGZneKce7Mu66u07r8C3wheevifeypwTLAfqGnZscAzlOdeTwZlGwlcCZxvZp9zzr3WgHKdAfwHf5+4A8gFPoX//3CcmZ3lnEvWd72SnRobD2tYbyfgMfw4Af7vuwgYCnwFP06e45x7IsOyE4CXKY+xe4B+wLfx017cUociHAHcip+TchdgwGjgF8ApQYyu036gGazDT4HVDfyLS0D6PiSBn1uzD3AicKKZ3eqcu6KlCyotSrGwnrGwhnVGgDuBC4NJKWA3fr37EnCOmX3TOff3DMvuC7yKv68CKMbPBXopcCrwozoUYSTwIH4d3oN/bDwU+B5wmpkd7Zz7pAEfTTqA4Pf7DeAy/Pq1Bz9GXO+ceyPD/NdRnqu2JrOcc1PrWZaZwBTgEuBR4Cf4+6EB+Llv7w3KVRLMfxxwLf4F1wJgLvBj59yr9dmuSAtS7K177C2m6mdJ1w2/3ncY6qklDfV9/JNvD7gG6O6c6wkMB14A7qhuQTMbgt8IWwj8E3+AogL8k94DgGeBQcCjZhatZ7n6ADcBdwP9gzL1Bn4fvP9Na72e0oPT/t4RPO/BP+A/DujtnOvsnCvAbyS7Gb9R41YzS19WpLLf4x/UHhn8hroA6T0Cl+MfAI8DCoJ6kY8fNN8BRgDT01cY5ME7JO11v0qPuuaquxv/IGA78EWgs3OuW7DuRUBP4HEz6139Kqoys/MoPwj4HdAr+Fz9g23+Dn9/kGnZ7sD/8OvZ48CB+N9LF2AYcE9QrkcyXbWvg9vx94PDgzL1wD+58IDPB39L+9HgeFiLP+A3RpcCXwW6Oud64DcKz8Svw/82s/3SFzK/9/JD+DF2OTDZOdcVf8CjU/Bj7U/rsP1bgPeBCc657kBX/BPqYvyLvH9o4OdqCmFM3BE8e/h1+lz8BrP8YD/TE/8C0x78QYXPauFySstSLKxHLKzFtfiN0Q5/f9EzWO+++PuXCPBXMzs6w7L34jceb8S/MNcl2Acdgd/IcFMdtv87/E4lRwXLdsaPn1vwG6v/1YDPJB1AcJH4UeDPwAT8c6nwIvErZpYpz/Me/N9rdY94ExStJ/AW/nFCX/yB74fh168Hg7J/HZgBHI/fmaETcBTwgpkd2QRlEGkOir11jL3OuQcyfJYwD/wh+Bd+we801TE45/TQo14P/IPCnfgHqddleD8PWBy874Chld6/N5j+p2rWHwMWBPOcWem9mcH0iytNn5q2vecBy7Deu4L3l2d6v4bPe12w3F21zDezpvnwd0xhGQ+q47ZvD+b/WS3zrQrmm9ravw89Wu6R9v++HejbwHUUApuC9Qyr9N7Q8DdbyzrCunVdpelHpf3mT8qwXF/8k1MH/KIeZbagHmesb8H7M9K2PbXS+78Kpj9e3b4AeDqY5+o6ftahadt7D8jLsM5wX7IT/4Co1X9DejTuQePjYcb4gn+xJBW8d0WG9XYCVgTv313pvUuC6cX4F0UqL3sofgOuA2ZmeD8s60agMMP7Fwfvp4Ah9fiupgbLraplvutqmg/4TFoZv1fHbV8QzP9yLfNlrN96ZPcDxcKGxsKwLs+sND19v3ZDhvVG8XtAO+CVSu8dE0z38BsnKi87lPK7AVfV8H9ZDIzM8H64fod/sa3Vf396ZNcD+HFajLoa6BRMH4bfyLMj7Tc0tA7rm5T2m/1+2vS6xrSZwXw7gKXh7xb/fPcy/F6VDr9hOg5cD/QI5hkCvB68/3Yt27muun2BHno0xwPF3gbF3mrW2QmYF8w/G4i19v9vSz3UQ1oa4gT82wlKgT9WftM5V0o1I/2aWQEQ9lDK2LvKORfHv/0ZYFoDyneDC2p2JeGggiPxb59vdmYWNbNRZnYD/q3SAG845+bWcRVhOg9dFZea3O2cq+n2n2o557bhH+wCNCrfbQbh1fE5zrlnM2x7I/CP4OUX67Heifj1GOCGDOt1+Af01bkoeP5jNfsKKM/53pB90O+D/WBlf8BPI9CtgeuV7NPgeFiLL+D3QNyAfydR5fUWATeG81a6myjs/fWwc25lhmXfwj9Brs0/gv1DZXcDHwflO70O62kSZjbAzC4Ntg9+GpG7a1gkXRhLD2vAnVfSdigWVlxvbbGwOuF+LU75fiZ9vSngl8HLoyrl4Az3P6+5DCmvnHOr8FNa1eZB59yKDMu/TPn/k3LDSwVm1pnyu9B+6Zz7XRAvcc59hN/Lfl01i2da3z74nRcK8H+Tv21E8ToDn3XOzQ7KE3fO/ZPyOPYL4F7n3I+cczuCeVbj3/njgEN0x6xkKcXeiuttSOy9Hf/i11rgC0F7WIegBmlpiHAgkwXOuZ3VzDOrmukH418RBnjL/IGSqjzwb2cCP3VHfSSAjDlfnXPL8W8ngfLP0BwusvLBzZLAB8AP8HuULAPOSZ/ZzArNHyTqdTPbambJtOUfC2Yb0IzllbavSj68yszs02Z2h/mDku1JHziB8ty3Tf07C+vZyzXM81LwvF9wIlGf9W5y1eeZfx2//lVg/mCF+wYvH6phH/TnYJ767oOgmsY+59wuYH6lzyBtW2PiYV3W+2rQ+JNJWHc646fxCIV58mbXsP665KKcmWmic85LW745f8dDKu2n1uE3zhfi9948yzm3OZzZzHLMHwDyWTP7xPxBdcJltwez5ePfnintk2JhVRljYR3X+65zbns187yStt70/UCz7n8C4T5VcVQqa7KLxGaWi99BajD+sdsljSzbQ5kusuCn9gplatxajX9HFPipLUWyjWJvVXWOvWb2Q/z2oSLgNOfcpjqWo13QoIbSEGE+nPU1zFPd1ef+aX/3rcO2OtWpROW21HJFaV1Qhobk06urEvyTZfBvWdyNf1vH08C/wiv1AGa2P/6OMP272I1/q6LDb7zvid/gIFKdzTW9aWZX4/dysmBSCr+BJqwr3fEbapr6dxbWs5p6o4QDWBh+vve9TbFe51ypmW3BH8gtXfo+qC77gfrug2osV9p7zbkPkpbTmHhYl/XWpe6kzw/lA8DUNOBXTeUNtfbv2KN83xbewr8Gv6HqVudc2WcIBjV8Dj9Hbag4WN4LXodxtjN+HlppfxQLK6khFjZ2vSVmthW/XrXH/Y+0TU15kfgv+Lf8bwI+n37+1kCLqpkeNj6VUN7wXNlGYBS6oCrZSbG3krrGXjP7DH4qSYAvO+fm1zR/e6QGaWlpYa/87c65wlbYvtU+S6M94Jy7uI7z3ol/MD8Pf9Tx15xzZaPGBiMtv0DLlFvarup6UGJm44Df4v+G/gr8HViW3uvSzO4Bzqf5fmd5zbTe2mT6POl3BnUPei23JNVlqY+a6k516WZaQkv8jtc654bWcd6f4jdGbwG+Bzyb3sMkSNMR9lRRHWy/FAsza+jnaUh5W6J+qQ5LdZrkInEwuOAV+A1mZzjn1jRB2aq7SBPugzbWkEYunCe3Ccoh0tQUezOr8fOY2Rjg3/jnpr92zj3QIqXKMkrZIQ0RXgWr6baK6t4L8wv1rJRzrqn0NrNYDe+HvSNrvJLXEoI8YJ/G34mf6px7Lr0xOlCXXuQiNTkDf1//nHPuSufc+xlSADTX7yysZ0NqmCdMn+Goe6/FWvdBwX6gV4a30nOc7V/H7dVXTfvGrNkHSZNoTDysy3prqjvp6WTSf09hPUq/G6Cymt4LtaXfcTg2xZXOubsz3O6oWCqKhXVXa3nNLD9tven7gfDvjrT/kXbEzKYANwcvvxHmfBaRBlHszfx+D+C/+CmG/ovfsaJDUoO0NMS84HmimXWrZp4p1UyfQ3kvpS9UM09j5FJNQnwzG0n5jmNepnlaWLgD3Oycq+5q/fEtVRhpt8LfWcZbgIJ8WYdVs6yXNl9DrlqH9WxKDcsfGzx/4Jyry21S6evta2b7VTPPEWS4CygY1CZslG6OfRBUs/8zs66U306aDfsgabzGxMO6rPdQM6subUxYd/bij08QCuv65BrWf1QdylDd79jSls+W33GN+zkUS0WxsD7C9Y4ys4HVzHN02nrT9wPNuv+p9F627H8kezTqIrGZDQEewj+f/Gsw6KCINJxibyVmFgHux0/D8z5wfg13R7R7apCWhngOf3T7POCqym8GV4S+l2lB59xu4JHg5U/MrNorYsEARV0aUL4fVrPT+WHwvBx4twHrbWphbrO+wSjOFZjZeOBLLVskaYfC39n4at7/MdC1mvfS01n0aMC2Hw6ex1E+YEWZoP5/NXj5YD3Wu4DyPHvfz7Bewx9ItDp3Bc9fN7Ox1c1kvu71KFfoe9XcqfFt/Bxpu4DnG7BeyT4Njoe1eBT/QLwXcHmG9XaifPDfRyv1NgkHwz3DzIZmWPYQ4Jg6lOFrQQ+Oys7H753tBeXMBtXu54LjiB+3bHEkCykW1t3z+J85l/L9TPp6o5T35nrVObch7e1w/3OkmVXpIBLcHXhO5ekZnG1mwzMsfzRwZPDyoTqsRzqWBl8kDuLqE/hpP14GvtP0xRPpcBR7q/otcBKwDf8u+d312Ha7owZpqbdgUIcbg5c/M7PvmlkBQHDy+xgVbyWu7Af4FbA/8LqZnW5mZbl9zGykmX0bWAIcXM/iFeFf6bo9bOQ1sx5m9lvgy8E812XJVagl+In0DXgg6MGNmeWa2ReAGUDlFB4i9TUjeP6Mmf0o7G1pZn3M7Cb8CzVbMy3onNtBeR6+eo8u7px7FXg2eHmHmZ0ZnMhiZgfhn/T2xO+x/Kd6rNcB1wUvv2xmvw0bzoKDizvw9wPVDUDzG2Al/uAZs8zsovSLX2Y2yMy+AswFTq9rudIMBh4LGwPNrJOZfRf4WfD+b5tgcBzJAk0QD6tb72rg1uDlb8zs8jBOBr0xngZG4v/Gf1Vp8X/jHygXAM+GjULBBZYTgccpP0GoSX6w/AHB8rlmdhHwj+D925sor2ZTCPdzfzCzsp4wQeP7i5QPtCYdl2Jh3de7F7g+ePktM/txGCODHtP34/eA9oCfVFr8ZeBV/GPbR8zs5LT6eBj+91DT4OOhOPCMmR0RLBsxs89R3sAwwzn3Wn0+l3QIjblIfCfwKeAj4CznXLKa+USk7hR705jZOcDV+Clbv+ic+7C+n6vdcc7poUe9H/i3IDyOn2/HAQn80VLDv7+Q9t7QDMsfgj+oRPryW/BHGHZpjymVlpsZTL+40vSpwfRV+L0QHf6B8jb8Ch+u768N+KzXBcveVct8M+syX6VlTq9Uvl1AafD3avyeaA5YVct6VgXzTW3t34YeLfeo6/87/l0J4W8srBde8Pp2/B7DDv9iTeVlf5627J5gm6uAb6fNU9PyffBv0wrXURz8zsPX24DDG/j5/5q2nmSlz/Wtmr4f/Ma899OWT+EfEBVV2gddVGm5jJ8VGJq2zBn4+zSHv19MpL33OJDT2r8dPZruQSPiITXEF6AT/sFyuGw8bb0OP16eVk2ZJlaad3fab3sZ8N3g7+cyLBsu8yX8dCAO2EF5bHLAG0CXen5PU6lbPLuuLvNVWmY4/q3a6fuZPcHfRcAJ1f0fVFpPxvqtR3Y/atrXV5pPsbDichcH02dmWGcU+FcN600BX6+mPIPxj2HDZYuCfZADNgCXBn8vq+H/8jJgE1X3Xw7/Tsf+rf270yM7H/g9LsPf7HeBgmD6UPyLuTsqxwP8zlLhb+2AOm5nKnWLaTPJcO5an/XUto5gnuuo53moHno05lFdbMkwn2Jv1bImgnhY3eOd1v7/bamHekhLgzj/qvEZ+JVtIX4lTOEH+inOuRpv43XOvQOMwb/N4XX8A4Ae+DuJOfi3MhzinJvVgLLdDJwKzMK/C6AEeBM/P88367u+5uScewz/CtoM/O8gF/8g/nfAJPwe1CKNdTb+wfYS/ABowGv4ja2X1rLsL/Dr6cJguSHBo0ddNuyc24yf1/17+HU7AcTwTyhvBsY5596o16cpX/c38S/avIXfWGb49f6zzrk/17LsCvw69nX8Hl3b8AeWSOJ/1r/g39Z5TwPK9Qh+SoSn8feLSfw0QVcCX3DqddOuNDYe1rDeIuBk/IaZV/EbZDrhx4h/AuOdc09Us+wC/J5ed+If2OYGz3/AH0w3zMu3o4YivA4cin8bY9gYvQz4P/yD66y5g8c5txL/c92L34gVxf9s9+EfSyhFjoBiYX3WmXLOXQSciX9hbAfQBfgEv4f0p51zt1Sz7Br88RL+DKyhvD7eBhxEeW+4HTUUYQX+XZJ34N/REcU/uf89cLBz7pOGfC7pEH6Ln3ojiv972WVm2/F7Pp9A+R2z6U4KnnOBF8xsQzWPbElTJdKWKPZWlYM/mGN1jz4NKVNbZEFLvUibZmZT8RuVVjvnhjbxuq/Dv9X+X865i5ty3U3FzFbh75yPcc7NbN3SiHQ8QXqGjwCccw0ZeEOkxZjZPfgH0T93zl1X6b3wwHCYc25VE25zKs0Up5uKmd0FXESG70VEmoaZ/RI/1UeV42odz0pTCG7L/zr+Bd398O/2eRO43jn3euU4Z2YzqdsAxLOcc1ODbUylDjEtbd2XOOfuyvB+reupbR3BPNeR5eerIiKV1XfUZRERERFpo4KBws4IXs6oaV4RkaZkZoX4KTtA+x9pJs4f6PcvwSPT+1bp9dRmLEuN6w4uvNTYkaE5yyci0pqUskOk7i4yMxc8rmvtwpjZ42F58HuTiIiIYGanmdn1ZjbOzHKDaXlmdhrwEv6Ah2+61hkUbEhaLJ3ZCtuvwMy+nRZLL2rt8oi0dWZ2qJn9xcwONrP8YFqOmR2L3xO0P376jUdasZgiIiLSytRDWqR2e/BHX608rbVtp2q56jJyuYiItG998Ecu/yHgmdkO/Bzp4XFfOGhuS4pTNWZta+EyZLKX7IzxIm1VV+CbwYMgf29n/Lyd4Nf7s51zJa1TPJEmNSQtBcisluzNbGafBx5rqe2JiDQ1NUiL1MI59zv8QQazinPuktYug4iIZKUXgF/jD5o7BOiNPyjiCuC/wJ+ccztaskDOudeBfi25zbpwzt2GP9iaiDSNBfg5oqcBw4F98AeSWg48C/xegxJKO5ANF1lLMpRhZwuXQUSkwTSooYiIiIiIiIiIiIi0CPWQzhK9e/d2Q4cObe1iiLS4uXPnbnHO9WntcmSieikdVbbWS9VJ6aiytU6C6qV0XNlaL1UnpSNTvRTJLjXVSTVIZ4mhQ4cyZ86c1i6GSIszs9WtXYbqqF5KR5Wt9VJ1UjqqbK2ToHopHVe21kvVSenIVC9FsktNdTLSkgURERERERERERERkY5LDdIiIiIiIiIiIiIi0iLUIC0iIiIiIiIiIiIiLUIN0iIiIiIiIiIiIiLSItQgLSIiIiIiIiIiIiItQg3SIiIiIiIiIiIiItIi1CAtIiIiIiIiIiIiIi1CDdIiIiIiIiIiIiIi0iLUIC0iIiIiIiIiIiIiLUIN0iIiIiIiIiIiIiLSItQgLSIiIiIiIiIiIiItQg3SIiIiIiIiIiIiItIi1CAtIiIiIiIiIiIiIi1CDdIiIiIiIiIiIiIi0iLUIC0iIiIiIiIiIiIiLUIN0iIiIiIiIiIiIiLSItQgLSIiIiIiIiIiIiItQg3SIiIiIiIiIiIiItIi1CAtIiIiIiIiIiIiIi1CDdJNyMwGmdnDZrbTzHaZ2aNmNri1yyUiIiIiIiIiIiKSDdQg3UTMrBPwEjAGuAi4ABgFvGxmnVuzbCIiIiIiIiIiIiLZIKe1C9COfAUYDox2zq0AMLOFwHLgCuAPrVg2ERERERERERERkVanBummcyrwZtgYDeCc+8jMXgNOoxEN0nv27uJXD5zPqsRahuYO4idn30uXzt2aoMgi0hDxeCn3PX8jKzbPZ2SfSZx3wrXEYnmtXSwRkTZD+1GfvgeR7KI6Ka1Nv8Gq9J2IZJemqpNqkG4644AnMkxfDJzV0JXu2buLEx44nN0RgzxYzEpmPHAYT5/6PP1679vgwopIw8TjpVxw56EsjyVImBHdvIxH7nqQ/5z3mi4UiUhWaOhBYkud8MXjpVx452GsjMUpMSN/8zKeu/NR7r7kzQ51gqnvof3IhsaSbChDW6c62T41pm60dL3Sb7AqfSftVzbErWwoQ1vTlHXSnHPNVMyOxcziwB+ccz+oNP1XwA+cczU2/h988MFuzpw5Vab/4I5TeTqyEszKJzpHjnO8+IWZFHbv0yTlF2ktZjbXOXdwa5cjk0z18p9PXMeftz+Mq1QnB8Xh8YvnKoBJu5Ct9bK6WNmR1HbgXOUg0TmGx2O1HiQ2ZDkvlSKeLKU0UUJJaTHxeBHF8WISyTiliWLiiWKSyTjxRAnxZCmJZCnJVJx5q1/gGbeU0kj5fjTmOY7zhjCicAKe83A4/9lL4eHhnP+atL9dMJ//7OE5yv4um+4cHh6E63PO/xsHzsNB2frB4ZwL301bd6V/LngvmI8Kf4X/CNYVviIsVdl8uy3OqpjDS4snBZ7H1/qcwyWf/WmF7zpb6yRkX72sz8llU5yINrTONZVkMsHuop189T/H81FughIz8pxjWCKXX51wN5FIpLwuOQ/POVJeEpxH0kuB50/zvCQeHp6XwnN+/Uh5KZwrn+ach+dSfr3yUn698zy/bjovWL9X4X0XbJNgXr/+hu8RvO9Vqt/+9sO66SrVd6+svpbvKwjrW9m0ynXaf4+gDqfvFwjq9Mb4J8zN202yDnUSsrdeZludbC51qb+NqZ8NXTaZTFAaL6EkvpfSRCmJRCmliSLiiVLi8RLiqdKy2JhI+c+pVIJEKsGCNS/xrH1AvFJ8PDY1hOG9JlSsF1XioyurTxXiV4Y6UxYrK9WFCjEyqD8eafWrrE6lxbdKr6uLk2VxNVyH4S9r6fOnz+cvV59YCaqXDdXRYqeXSrGneBdfue8YPoqlxc54Lr868W5yolE/RuKRSqXqHDudlyyb7pwrj6MujIepjHHTj4/++359TAXxr/zvsvhaaZ4qMdNLlcfGSs9lMbWO8dJzaXU2WP+m+Abm5O1qklipBukmEjRI/94598NK038NfD9Tg7SZXQ5cDjB48OCDVq9eXWW950yfxOK8RMUGaQDn6JHyeOacN9UrU9q0bDtoqK1efmX6EbyZtytjnbyy++lcfvovW6qoIs0mm+plXWJle5TpYB+o8eC9qGQv/3zyx9yzZwYlkfJxq2Oe48hkX/bJH0jcKyGRKiHulRJ3cRIuQcIl2WpFfBTzKpzwmXP0SDlygCTgGSQNkhgpo8KBaFsVca5shO+IA8N/RHD+c3CYHKH8PUubr+I8RviNRMrmswrz+sv703ZEUmzJsQrxxJzjVDeaX13ySIVyZlOdhNatlzWdCNfnBDfTvMPiufzmM/dTEi9ib/Fu9pbspLh0D8WluymO7w0amPZSmiwmniwmniplbdGHvJ23s0J9iDrH/qUxultngssleM4jhYdn/kmhh8MzR9A0m/bav3iRMvCAlLngGVJlz1b22rWDepjNqquTkF31sj3HyobEQ4Cde7Zx5/+u4769L1aJiZOTfdmnYBCJVAmlXgkJr5SElyDh4iRIknBJtltxlYZQc47uKUcu6fXRj4fh3147qpMR56rEO/9vl2Fa9XEynBYJomTVeZsmVoLqZXWaO3Zef/J9xJMl7CneQVHJHopKdlES31seO5PFlCb2Ek+VEE+WsLZoJW/n7ag2djocwSWXIGZ6abHSqxg7KY+VleOoXyczxM92VE+zQUPrpFJ2NJ3tQGGG6T2D96pwzt0K3Ar+FbNM8wzNHcRiVlZ9w4wd0Qifv/8wHj9XjdIiTaUu9bI6MzY9weWoQVqkKTWmTrYVlU8SzjrmKi67d0rZwX7e5mU8cdeDDLcBfJCXIGH+iXWxGe/nJTjungOJR6AoPOFOO/EGiEeMl2ObwNvkT4hCvjnynCPPQcwZRebwqHhw7oDuXoSBrgdRokQtQsSiwd/+I2I5RCM5wetcciI5RCI55ERyyYnkEo36z7nRPHKiueREc1nyyds845ZU6CGd5zm+kHMQR4z9PGYRopEokUgUMyNq/joj0SgRMyIRf5sRM6JRvwz+37lEIjlYJEJOJEo0GiUnkotFzC9jNJeIGTnRXCIWIRKNNtv/aV3c+dQv+fvm/1CcdlKU7xwj+kxsvULVUUvVy9rqRuXbRP/1zK/4MBYva3wqNuODvATfuPMYuka7UuwVUeLilFicrZE4G/IMl16f8lOc+uIX61fIfKBS3UkBK3JL6eJKiTiIYkSAqPOfI2bB30YUI9dFiGBEiBBxwTPm/06J+HXP/4uIRYiGzxYlYlE+jK+q2oHFOSaW5rN/l/GYRYIGH/P/Nn/dYdNPJJxGBMyfJxIsE7FwmhGxaDC/XzfN8P8mQiTirwMi5euznGA+IxouE4n6641EgvWE80eCuh8p2weYRaDyNIL9QNT/Dvz9RLRsfwB+/bdI+H75PsEsQiRiFfYLEYsG7+dwz7M3MH3rQxSn7UNVJ1tWXer8k3c9xKicoXwQS5BIq+tL8hKcfPeBpAz2RKw8xmSIiS/FNkEqiIkRiOHIM0csiIkxZ+w1L2Nc7OFF2Nf1IFIhLkb8eBjUyWj4d8SPjdGIH48ilkNOJIecaIxoJIfcaB7RSE4QH2O8v/4NnvYWV42PuQdzxJjTyupFJIiREfzfeFmdCGNjJMevV5FoWX3IiUTB/NgYjeRUqQvZFiNDipV1V12jc20pFm5/+mcZY+fX7pxC12hXSrxiil0pxZZgeyTBxgyx8/Mvn1O/wtYQOzu7UqLBBYwoBHExLYbix89cIkTC+BnGTosEy0XSXqfX02jZ46P46oyx81Ol+YzrMr48ZqbFzvDvTLEzEsQ3s6jfMSHilzZSIc5VjZsVY2skiI/BdsNj4Ui4TLRsmUwxM/3Y2SL+M0EM9ONpTp3jZU40+K6CeBvuI+577sYmi5XqId1EzOwlIOacm1xp+kz873lKTctXdwvHnr27mPLAYcQjkao9MgGco2/SU6O0tFnZdBW7skz18vYnfsbN2x/J2EO6T9Ljpcveb8ESijSPbK2X2X67Y32EJw3LN89jUWIFG3I9Ss3IddDZc+yMWt16WTnHsLgxItKfTtEu7Exs443cLRVu983zPL7U6RjOOvoqunXtRdeC7lVONMtO+NIOLmu6/a4xWvs2zWxRn+8hW+skNG29TD+ZHl44nuc3PFF2K22+c+yTiPBJrucfFwcizrFP0lESgR3RSLXrLvA8OntQ4BmdXJQ9lmRdrmU4Ec1jfNdJ5OUUkJfTibzcTuTHOpGX25lOeV3plN+NTvld6FLQgy4F3fjfW3dy+/YnWqTuVKcl6297Vt99U7bWy7YWK6uLhzEHXTzH9nrEw0EJGOJ60inSmU45Xdke38IbuZurxMRzO03lC5OvpFvnHnTt1DPj/29r1CvFx6pULzOr9eJN8D39/dwZ3PbUD3mw9I0KFzoiztEr6SiKwt5I9bGzc1nsjFDgouy2JOtyyRg7J3Q9kFhOgR8/czuTHyugINaV/FhnCvK60LmgG53yu9OtU3eefvNO7tih2NkWNWWdVIN0EzGzbwO/A/Zzzq0Mpg0FluPnkP59TcvXtIPasOVjTn7yRP92hmoapXumPC7qfRYXnPyjDhuspG3K1oMGyFwv4/FSjrx3kn8FuVIgzvMcr58/T3VQ2rxsrZdt7SS7skwn3SXhfiTDRa5MvR2XxYprPHBuyRzSjRF+Fx9uXsCIPhM77CAydf0esrVOQuPrZU0XZxJGlTEbMtWVgQkY4XoTd3HmxnaRSDvpzvc8Li/8Al85reIdTE11IpoNDUjZUIb2oj77pmytl20lVsbjpdzzzPX8Z/PDbItCvB7xcHxpjOWx0gqpODLV39bIId1Yio9VqV76qouX+c7RJxFhQ66rcPGFsK2vmjakQQkYRT9KvBLmxHZUWDbf8/hq4ZlcetrPKyym2CnQdHVSDdJNxMw6A+8CxcBP8O/o+SXQFZjgnNtT0/K17aC27dzMaQ9P8Xt+VLNDiToYlDDuP+819ZaWNiNbDxqg+np56fRDeTtvb8YD5qt6nsllp13XMgUUaSbZWi/bykl2ZXU+6Q45f/DiZKWD/SsKz2TGhv/WeuDc0JNZnQRnr2ytk9C4epl+MlhcW72AsuPdVNpJc/qJcGPzYDb0RDQb6k42lKGjydZ6me2xMj0mbokaSaPZ4mG4vYbWDdWrtqe91st6x0sA59i/NIf+kd7MztlQoYe0Ymf2lKG9U4N0CzGzwcAfgWn4CXFeBL7tnFtV27J12UHt2buLz99/GBtzqmmUBvWWljYnWw8aoPp6WVPajsNKu3HbFa+3UAlFmke21stsP8nOZM/eXZx735GszfUHV6n15AH/JKFvIsLGoAd1+sE+oAPnDihb6yQ0vF7G46X8371n8Zx9WKGxqYJKPSNrqhvpgzPVtY7oRFQaI1vrZbbGyno1RAcUD6W+2mO9rGu8jDpHKkPP5fNOuLbWRmTFTmkuapBuA+q6g6pro3TMwah4rm43kKyXrQcNUH29jMdLOe6eSVXvWHCOT5d05vavvtWCpRRpetlaL7P1JLs68XgpZ9x1MKtiGdIMVBYcjxUEJwn/PH8WD738Jx3sC5C9dRLqXy/TG6U25RgeVFs/IkHvyETaCbTqhmSLbK2X2Rgrw16Vy2MJ4rU1RCseSiO0p3pZn3hZ2wVbNSJLa6mpTua0dGGkcbp07sbj577p97aKOVJQdadkRtxgWSzO/917Fr84/yHtbESaUCyWx+FuGM+wusp7q3P2EI+Xqs6JdHBhb5Y1NTVGp510901EGJ8zklH7HFh2kqABVaS9qdAolVP92CgQNkblcny/z7Nq26IKJ9CqGyJty93P3MDyWLzCgKRVOEfMOQYoHoo0IF7WfPFG9UiykRqk26AunbvxyMVzuPuZG7h7y4NsryavdNKM52wlq+48TD2lRZpYTjRWdaIZW3L82wcV8EU6rvAkYllewu/NUlkNJ90i7VmNjVJBb+h9VS9E2pV4vJQHNj/kN6pl4hw5DnqnHGf3OYsLT/6h6r10eA2NlzoHlbZEDdJtVCyWx2WnXcc5e79bfW9pM5Kop7RIcxjV50Cimz8gVeliUApYvmle6xRKRLJCeBKRtMwnET1THhf2/qJOuqVDqa1RKgc40Y3gFxfreFWkPbn7mRvYEs3Qw1MN0SIZKV5KR1HDPTPSFoS9pb/Z80z6JR1Rz5XduhFKmvFcZCUX3nkY8XhpK5VUpH0574Rr6Z2qWt8AUi7ZCiUSkWxQdhKR4cQ74hxD48b/znmTy067TicR0qHU1CgV8zxGl+aq84RIOxPGxGTldjXn6Oo5vlF4Jk9fOE8xUSSN4qV0FGqQbgfC3tJPXziPk9zwqt3ezUialfWUVqO0SOPFYnkcEhmV8b15bqXqmUgHVd1JRBQ42RvOIxfPoUvnbq1TOJFWUluj1NcKz1J6OZF2qLqYmOPg0l5nqiFapBLFS+lI1CDdjsRiefzi/IcYXZpLjuepp7RIM9tvn4OJVe4hbcbWqHHf8ze2TqFEpNXUdBLRJ+nUm0U6LDVKiXQ8NcXE3inHBSf/qFXKJZLNFC+lI1GDdDsTi+Vx9yVvcqIbUW1P6eWxON+48xjufOqXapgWaYTzTriWnimqXPxJmPJIi3RENZ1EnNPnTJ1ASIekRimRjkkxUaR+FC+lo1GDdDtUW0/puBlv5u3i75v/o97SIo0Qi+VxUGR4xvc8f5hREekgdBIhktl9z9/INjVKiXQoioki9ad4KR2NGqTbqdp6SmNGcSTCylhcqQVEGiFqVWoYAEbmUZFFpH3SSYRIZss3zSWuRimRDkUxUaT+FC+lo1GDdDuW3lO6IOwpXam3dLEZz617VOk7RBpoVJ8Dya+cRxp4L6mBDUU6khWb5+skQqSSeLyURckPq0zPVaOUSLumhjWR+lG8lI5IDdLtXNhT+mt9zuGw0m7EqrabsTgvofQdIg103gnX0i8RqXixx4z1uR53P3ND6xVMRFrUsMIJVQ6qDDir9+k6iZAO6+5nbmB9rlexl6RzDEyYGqVE2ik1rInU333P38gGxUvpYNQg3QHEYnlc8tmf8rdLXmZUvFJvaaXvEGmUWCyP8bkjq0yPm/HA5od0kUekgzCqXvE1IGrRli+MSBYIc8jGrWoKqwm5o9QoJdJO3ff8jWxUw5pIvSzfNJeSDPHygJzhipfSbqlBugNJ7y09rjS3yvvFZry+7hl+fOcXlMJDpB5G9TmQWOW0HWZsi5ou8oh0EB9ufRev0jQHfLTtvdYojkirqy6HbMw5RvaZ1EqlEpHmtmLzfIp1IUqkXrwqR5E+l6HDg0h7oQbpDibsLX3iwC9QkCHv7dy8XTxpHyiFh0g9nHfCtRSmqJKjPWHw4eYFrVImEWk51d2enOccI/pMbPkCiWSBFZvnk8iQQ7Yw5cdNEWmfMqWwigTTRSSzSDV31EUtp4VLItJy1CDdQZ13wrUMj8co8DzMOXI9/4pcwgynFB4i9RKL5fk58Spd48l1jqGF41unUCLSYqq7PblfIqKGN+mwRvaZRF6lC7XKISvS/mVKYVXTdBGB4YWfIrdSzCzQHUXSzqlBuoNKT99xqhvNQfHuVO7EohQeInV3wck/YmQ8BwsPJJwjacYLGx5X3RFp55Zvmqvbk0UqOeuYq8h1lI9b4hz5znH28d9r7aKJSDNSCiuR+onHS3lhw+Mkw2NJ54g4x7B4rjo2SLumBukOLEzf8atLHuGIgSeTnyGFx7yYUniI1EUslscJ/U7zT74BzPDMWBlL6E4DkXasunQd+erVIh3cQy//iaRRNoA2ZiTNny4i7ZNSWInU333P38jKWAIXNkibkePghH6nqWODtGtqkBagagqPiHNgRjyiFB4idbVy26Iq+TKLzVi+aV7rFEhEmp3SdYhklmlgs2Izja0g0o4pJorUX6Z4GTfdVSDtnxqkBaiawuPTpV2rDNBWopMIkRplypcJsCi5QncXiLRTKzbPp0TpOkSqqG5gM42tINJ+KSaK1J/ipXRUapCWMhVTeJxCQaWGtZhzJF1COaVFqnHeCdfSLxGpeDHHjI25nu4uEGmnMl2IUroOEQ1sJtIRKSaK1J/ipXRUapCWjNJTeIQD0cTNeNE+VE5pkWrEYnmMzx1ZZbruLhBpvzIN3Jbr/OkiHdnKbYuqnEprYDOR9k0xUaT+FC+lo1KDtGSUnsLjNDeaI0p74oCSSEQ5pUVqMKrPgVXuLsh1TrdcibRTGrhNJLNMPSU1sJlI+/bQy3/yx1NRTBSps2GFE8jJcGeB4qW0d2qQlmqlp/DoHetD5Wxg6vUpUtV5J1zLsHguFh5UOEfSjBc2PK47CkTaoUz5MhUfRfwekTnh+bV6Sop0CCs2z6dUMVGkzuLxUl7Y8DjJsN44R8Q5hsVzNRCotHtqkJY6GdlnEvlVen2iq3YilcRieZzQ7zT/dkUAMzwzVsYSuqNApB0a2WcSsUr3WapXi0ja3QOgnpIiHcTIPpPKj4EDioki1bvv+RtZGUvgwgZpM3IcnNDvNA0EKu2eGqSlTtJzSltw1S5usG7bCu586pca6FAkzcpti/zbFdOod4hI+3TWMVfRNeX5L5wj3/MYHo+pV4t0eOopKdLxKCaK1E+mO+0SpvzR0jGoQVrqJD2n9KluNF/rfioTSnN5wM3jz1se0ECHImky3VGg3iEi7U88Xspl905hR04EnCMH6JeI8M/zZ6lXi3R4mXJIKxaKtF9hTNypmChSZzpvlI5MDdJSZ+k5pb96+vVM7fdZokF+XA10KFIu/Y6CMA9Y9xR4qaQu2Ii0I/5tlnE/758ZSTM25npKSSCCHwsHJYJTDeeIeZ5yYoq0Y4qJIvUXjj8UjrWgWCkdiRqkpcFWbVuMV2mabsUUKb+j4PLCs8hzDg/YmGNM3/aw7iIQaUc0oKFIbazC35UHyBaR9kMxUaRhrNIrxUrpKNQgLQ2W6fYSAwb1HN06BRLJIrFYHtFoFC/oJaK7CETaH91mKVK9+56/kbW5Kf+FGfGIBvgVac8UE0XqLxzUMBz8V7FSOhI1SEuDVR7oMNc5PDNmbHyKvz9yrQY6lA5vxeb5JCtNU08RkfbDv80yR7dZimSgQQ1FOhalHhCpP91ZIB2ZGqSlwSoPdHhl77O5ODaFZXkef9/9Pw10KB2eeoqItH8p8Hu1ALrNUqScBjUU6egUE0Vqo/NF6cjUIC2Nkj7Q4SWf/SmFXfsSc+CUokCk7C6CaNBTJMfz6JuIcNYxV7V20USkCdz3/I2siiklgUgmGtRQpGNR6gGR+tOdBdKRqUFamtSKzfNJVLoUrltOpKOKxfL45/mz6JN0FUYbv+zeKbprQKQd8FMSVJymmCdSzjSooUiHoTQ9Ig2jQQ2lo1KDtDSpTLecOKBrrGfrFEiklT308p/YGQ1e6K4BkXZlZJ9J5FYMebrNUiRw3/M3skaDGop0GCP7TCKmmChSL7qzQDoyNUhLk6o80GGe58gBnip9g+feuJ87n/qlBjuUDkUDVYi0X2cdcxVdPM9/4Rz5nsfweEy3WYqg3pIiHc1Zx1xFj5Riokh96FxROjI1SEuTqjzQ4Tf6nM3NB1xP1MH3l/2av21+QIMdSoeigSpE2qd4vJTL7p3CrmjEzxEP9EtE+Of5s4jF8lq7eCKtToMainQcYUzcFvWbFxQTRepG54rSkalBWppc5YEOpxx8Kp/pdBQeUBrRYIfSsYR3DeQHvShznVNvEZF2wL/FMk4quMUyzBH/0Mt/au2iiWSFsoGaAJyjQL0lRdqtMCYmIn5PT8VEkboJzxUtGNRQsVI6EjVIS4vYUbKpyjTdiiIdQXjXwNf7nEPPpEePpMfw2FDue/5G3SEg0obpFkuRmsViefzx848B0D/hONaNUG9JkXZKMVGkYWKxPP55/iy6pjx6pDzFSulQ1CAtLSLTrSi5Dt2KIh1CLJbHeSdcS8zB5pwIT9lypa0RaeN0i6VIzeLxUr73+OkAfJJrvGQfctm9UxT3RNohxUSRhgnT3eyORtgRjShWSoeiBmlpEZUHOzTnSBikUqnWLppIi7jv+RvZEfVv7Q/T1nwYi3Pvc79t7aKJSAOEcQ3dYimSkX8Lf8J/oXRtIu1aGBMjioki9RKmu3FBCjjFSulI1CAtLaLyYIeXdzmRYXHjb9sf5tYnftraxRNpdis2zyde8U5GSiIR/rblIc595LN8f+bV3LLgFp5a+RSLNi9iZ+nO1imoiNRJLJbH7z7/CJgxvjTG1/qcw92XvKlbLEUCmW7hLzbj1c2vUpQoaqVSiUhzCM/19k0YfZNOMVGkjqqLla9vnk0ilWilUom0jJzWLoB0HOFgh6EvbF7NlY+dyt+2P8YH/5xDXrSAkX0m+akNdPAi7czIPpPI37yM4rQDjlzn+HRJCcnSpSzYsZJncqKk3+zYI68Hg7sNZkjXIf5ztyFlr7vEurT8hxCRMvF4Kf9+8TcA9I32VuwSqSRT3AN4J/IJR/3nKA4bcBjHDT6OKftOoVdBr1YqpYg0pRLzyHNW+4wiAlQfK9+MrOeYB4/h+CHHc9Kwkzik7yFEI9FWKqVI8zBXKdeTtI6DDz7YzZkzp7WL0eI+3riSM5/+HHuDEZkLnGN4PKYr6h2Imc11zh3c2uXIpCnrZTxeyoV3HsbKWJwSM/LD3/p5zxNbNxc+mkXpypl8vP0DVuXmsia/C6t7DmBNfidWp4rZVLqtwvoK8wv9BuqufkN1+BjUdRCdcjs1SZml48rWepktsTKszytiCUojRsxzjIrnKnZJs8nWOgnV18tMcW//0hRf37GNl3vvy8tdurGudCuGMWmfSRw7+FiOHXwsg7oOaoVPIVJ/2VovWyNWhvV9cZ7fo1PndNJa2lq9zBwrk1y8cwfP9RvOS9EURalieuX34oShJ3DS0JOYuM9EIqZkB9I21FQn1UNaWtWMd+7DMyC4IlhsVpYzKb03tUhbF97K+MM7f8yWvYuZOupwzjvx+/5B+uiTYPRJ5AEj9mxmxKpXYOUs+GgWbH8XgOIufVkz+GDW9BnO6s49WJPYxepdq3lt/Ws88eETFba1T8E+VXpUD+42mEFdB5Gfk98Kn16kfQnz/ZVG/JOBeESxS6SyWCyPG8+Yyben/4BBvdYxcd9DOG/aNcQ+fI5PP/cTrv14Ph+MmcaLQw/ipU1z+d2c3/G7Ob9jVM9RHDvoWI4bfBxjCsdgpt6WItkujIsEjWQ6pxOpm/Ac8eKbv0f3Tqv49NBDOe/47xFbeB9TX/g5JS7JqwedzTN5ER5d/ij3L72fvp36ctLQkzh52Mns32t/xUlps9QgLa0qU86kEjM+3LygdQok0oxisTxGj/0aj/xvKeP2H8GrH+5g6uh9iEbS6kCXPnDAGf4DYPtq+GgWBStnMfqjVxj9/tP+9J7DYPgU2P809u57MGtSe1m9ezVrdq5i9cdvsmbHal7euoRtyb0VytCvc7+KKUCCHtb7dt2XWDRWpcwpL8XsdbNZsm0JYwvHMnngZN0uJh2eYpdI3ZSmIszb/Vn6DunH4BH7Es3Ng/1Pg1EnYK//ldGz/8DoFa/y9SO+xcdH/JqX3vsXL214i9sW3sr0hdPp37k/xw72G6cn7TOJnEiO4pJIFlqxeX6VlAOKiyJ1E82JsWjv5xjWqTODR4wiGiuAT38FxnyG/P9dw7Q372Ja3/HsPen3zFz/Os+ue4X7ltzLv97/F/t22ZeTh53MScNOYlSPUXjOU4yUNkMN0tKqMuVMyneO3MioViyVSPNIeY5H5q0D4O8zP6QgFmXioB7cc+mhFRul0/UcAj0vhAMvBOdg0xK/5/TKWfDeozD3LjoDY/sewNihR8GqV2HbSkgUQ6wTuwceyJpTrmf17o/9Butda1izaw3Pr36+wsCJEYvQv3N/BncdXNZYPajrIP658J98sOMDSpIlFOQUML73eKZPm64DG+nQRvaZRN7mZRUapfOdY0Sfia1XKJEsk/IcVz/k3+XzzHsbmPXB5vKYl1sAU66BiefCjJ/BKzey72s3cyHGhak42/I7M6v/frzUcz8eWvYQ9y25j+553Tl64NEs3b6Uj3d/rLgkkkVG9plEzpYPSKZNU1wUqV3Kc1xw+1vsLk2y8OOdXHn//PJY2W0AnHMfLHkSnr6azv86lc9EcviMl2JnXmdeGrAfz3YdxB3v3cFti25jeLfhlHqlbC3eSmmqVDFSsp4apKVVnXfCtTx356OsjMX9RmkzRsUTvLpqMPe9tZrzDh3S2kUUaTIzl21i9Va/x7IDiuIpFqzdwcxlmzhubN/aV2AGfff3H4d9DVJJ+GQBrJzpN1K/cxt4aacC8b10/Xgu47atZ9zoU6qsbmfpTlbvWs3qXatZs3uN/7xrDf9b+T92J3ZXmb8oWcTcTXO5ed7NnDriVIZ2G0puNLdhX4ZIG3beCdfy77sfYkPEYc6V5YQ/74RrW7toIllj5rJNLNtQHksyxrzu+8KZt0O/8fDCzwEPgMKSPZy+bhmnH/Z9io6+kdfWv8ZLa17ihTUvUJwsLl9nsoiFWxYye91spgya0pIfT0TSfGnaNfz13w8QweFAcVGkjmYu28SCtTvKXmeMlWM/B6kEPPqVsnO97qXlcXLrUTfwwuoXuH/Z/azbta58XYqRkuXUIC2tKsyZdN/zN7J48zs8Zx/RzzP2H3A7j7ywkDHLehAdOJFX3UT2H9izanoDkTZk8fpdlCa8CtOK4yneX7+rbg3SlUVzYN+D/cfRV8NLv4ZXbsJv7g4kiuDFn/t/jzwO0hqQu+d1Z0KfCUzoM6HCap1zbC/dzp/n/ZlHlj9S4b2kl+SuxXdx1+K7yLEchnYfysgeI/1Hz5GM6jGKgV0G6iq8tFspL8UbG14nmZdHr/gejthZQLe+J3LVuT/TwE0iaRav30Vpso4xLxWnQuwCiBfBhkV0Gn0S04ZMY9qQadyy4Bb+/u7fK64zWcxTK5/iyIFHkhPRqY1IS0t5KR5f+TjxiHHY3lJ6ef3Yb/BxnH/SDxQXRWqxeP0uiuOpCtMyxsqtK8CrOF8YJ3uNPomzx5zN9tLt3LLgluCyULCuZDGPr3hcMVKykn6R0upisTwu+exP/ZP8B45mBrvAlZLf5VVu2Rvnj6/cwV5vJFfYT5gwqLDm9AYiWWzcgG4UxKIUpR10FMSi7D+gW9NsYOBBEOsE8bS80ZEc2LEG7j8bOvX2c1NPOBsGHlg2mGhlZkZhfiHHDDqGZz56hqJkUXl5cwq46sCr6JHXgxU7VrBi+woWbVnEs6ueLZsnP5rP8B7DGdnDb6Ae2dNvsO7bqa8G3ZA2LeWluGLG5by74R1KcORGo3xSsIfPfDCLy+6ey92XHaH4JBIYN6AbsZxIhUbpamNevwlV45cZFA6ruM5e4+iU06lCXDKMZ1c9y7ub3+WcMedwxqgz6J7Xvck/j4hUlfJSXP785czb8DYYLCjI5YCSDXzpvReJnvLj1i6eSNar8/lhpjgJFeLk2MKxFOQUVImRL6x5gc899jkuHX8pp444NeO4QSKtQQ3SkjVmr5tNSbLEv55nRrEZi/JjzO9kHFy0gk8n5vLm2kPqnt5AJMtMHb0PEwf14M2VW/EcdApySE8dvU/TbGDUNBh4MKyb418xj3XyX5/7AHw0E979D8y9C96eDr1GwoRzYMJZ0HNoxtVNHjiZ8b3Hs3DLQkqSJeTn5DOh9wTOGX1OlR7QRYkiPtzxod9IHTzeXP8m//3wv2XzdM3tysieIxnRY0SFxurC/MKm+fwizWz2utks2rSAIFKRMGNxfi57Oq2h28czmblspOKTSGDq6H0Y3qczSz7ZjUHZuAkZY17l+JUTg2QcZt8Mw4+Bzr2AzHFpfO/xnDPmHO5fej9/nPtH/r7g73xuxOc4b+x5jOgxokU/s0hHM3vdbN7dNJ9kcC22JBJhcX4un0RX4s16mInHndO6BRTJclNH78OEfbvz5sptQA3nh1XiZB4kS+Gt6TD6FIh1qjZGnjvmXG5fdDs/f+Pn/P3dv3PJuEs4Y78zKMgpaIVPLFJODdKSNZZsW0LCS1SYVmLG0rwYk4t2s7+t5uX4gQ1PbyDSyqIR455LD+WC29/i3Y938OdzJjVtGppIFC54DJbPgA2L/Jyco6b500ef7D9KdsL7T8C7D8DLv/Ifgw/3e02P+zwU9Ewrb5Tp06Yze91slm5bypjCMdWO1NwptxPj+4xnfJ/xFabvLN1Z1pN6+Y7lrNixgudXPc/D8YfL5inML6zQkzp8dIl1aZrvRaSJLNm2hGIvXmFaiRkfxSKM3PWR4pNImmjEuOrYUXz1vnmcd9hgjhm9T/UxL1P8wuDBC+Bfn4MLn4AufWqMS9OGTGPZtmXct+Q+nljxBA998BBHDDiC88aex+SBk4lYpMW/A5H2bsm2JZR6CUir1mFc7LZmPqAGaZGaRCPGrRcczISfP8/R+/XmosOHZo6VmeJkogQeuQQevBDOvZ9oNLfaGHnc4ON445M3uHXhrfz2nd9y26LbuGD/Czhn9Dk655JWowZpyRpjC8eSG8klnnayn+8cY0rjlBDjfTeE3Kg1XXoDkVYQjRiHDS/k9Q+3lg1g0eSN0qNP8h+Z5HeHAy/0HzvWwqIH/cbpp74Nz1wL+53o95wedQLkxIgCU4qKmbJjJ+QXZ15nDbrndeegvgdxUN+DyqY559hSvMVvoN5e3qP60eWPVhisqn/n/hVyU4/sMZJh3YeRn5NfNk/KSzF73WyWbFvC2MKx1TaYizSFsYVjybEoCVd+W2W+cwyLezweHcaZik8iZVKe492PdwIwap8utce6TPHrvAfh3+fAnafAUd+FnWuJ9pvAlFHTMg7QNLpwNL848hd8+6Bv8/AHD/PA0gf4xovfYGi3oZw75lxOG3ka+dF8xQ2RJjK2cCxRi5CiPDVPGBcLBk9qxZKJtB3JlH/nnVHL+WCmOFm6A568Ch77KhxwBtGN7zGl3wSmjL/Mnz9gZhwx4AiOGHAE8zbO49ZFt/KneX/ijkV38KWxX+Lc0efy3tb3FBulRalBWrLG5IGT6VXQi0/2foIB+Z7HhNJSDi5KscDbj1fdRBKeY822olrXJZKtUp7jqYWfAPDXl1aU3cLcKrnRewyCo74Hk78LnyyAhQ/CoodgyZN+T+n9T4P1C2Dr8oopQC54rMIBTn2ZGX069aFPpz4cMeCIsume8/hk7ycVelOv2L6CNz95s+zuiYhFGNR1ECN7jGR49+G8vPZlPt79MaWpUgpyChjfezzTp03XAZQ0iwP3ORCHEXH+cDH5zjGuJEGXosHs2ndq06XfEWnjUp7jgtvfYs7q7QD85pmlPLd4Y/1j3fCp8KUH4J7Pw+Nf86fVIRYV5hdy+YTLuWTcJcxYPYP7ltzHDW/fwJ/n/Zmusa7sKN2huCHSBI4YcATRaA4uWVohLvZPDWfclDNbu3giWS/lOa64dw4Asz7YzDurttXv3PCgi2HvZnjpV/D+4/7Ah7XEyQP7Hsg/+v6DxVsXc9vC25i+cDq3LbyNiEVIuZRio7QYNUhL1ohGogzuOpioRfn8iNMYU7SbI1/+A7t7j2f+2L/z1349eGjuWn7+5PtEI8aFhw9t7SKL1NvMZZvKLqo4oCieYsHaHa2bG90MBkzyH9N+CStfhoUPwPx/Q3p6gvheP2/Z8hnV98BuhIhFGNhlIAO7DKzQ8y3pJVmze02F3tTLty/npTUvVRhFuihZxMItC5m9bnbGnnMijfXoikdJuiTfKYkSj8ZYsnkwA7scSckXz+Husf01oKFIYOayTSxYu4N4MKBhccJreKxLFEM0BskS/3U9YlFuNJdThp/CKcNPYeHmhfxh7h+Yu3Fu2fuKGyKN887Gd4in4ly0ay97ogPYuasfFxxyBuOmfpFojpoaRGozc9km3lu3q+x1g84N+x4AkVwI05/WMU6O6zWOm4+5mfuX3M9v3/ktSZf0y6DYKC1EydQkK6S8FDPXzmTB5gUM7jqYyyZ8hSlHXEPOgRfSc8divnlkP048oB+3nHcQx4/ty/89sZh73ljV2sUWqbfF63dRmvAqTCuOp3h//a5qlmhh0Rw/7/QZ/4Qjv1X1/XiRn7esBeVEchjefTgnDD2Br0/8On+Y+geePP1Jzh59dpV5S5IlLN22tEXLJ+1fykvx/Krn+duCvzG62zAu2rCKC0ZfzBO7vky/Q77AceMGqDFaJM3i9bsojqcqTGtwrNuw0B+4KV0DYtGYwjGUhI3aaRQ3ROov5aWYtXYWN759I52j+Xx9+zZGdT6XWcmvcuDxX1JjtEgdLV6/i5JEI+PlhkXgJStOq0ec3FG6g5SrWAbFRmkJapCWVpfyUlwx4wqumXUNpalS3tn4DlfMuIKUl4IDzoRUqX+b5rJniUUct5x3IMeP3YefPrGYu99YxYtLNvLnF5fz4pKNpDxX+wZFWtG4Ad0oiFW89akgFs3O3Ohequq0WKdgsKnW9dyq53hsxWNVpufn5DOmcEwrlEjaqzBG/eDVH1CcLGbVrtVc0a8P724oJoLH2m1Fij0ilTRprOs3ASKVGrfqGYs+2fMJFz1zEYu3LibHKq5LcUOkfsrO3V65hg93fkhpqpRv9e3Dlh3b8FJJnZOJ1EOTxMveo6tOq2OcLEoU8cq6V6pMV2yUlqAGaWl1s9fNZtGWRZSk/F4rCS/h3yLy8Svw0i8Bg2X/g0e+DPecTizi+Nt5B3Ls6D783xOL+dq9c/njjA+48v75XHD7WzoAkqw2dfQ+TBzUg/xcf/ebGzUmDuqRfblni7bB/Hsg1gVyOwMGsc5+PrJR01qtWPFUnOvfup6rZ13Nfj33Y2KfiRTkFGAYBTkFTOg9gckDJ7da+aT9mb1uNgu3LCzLY16Kx8K8PHZ/9Cfuzr2Be9/4SLFHpJIw1hXk+ifZscbEulhn/zbkSA4NiUWvr3udLz71RVbtWsUfpv6Bg/oepLgh0gjhuVs4EHUSx8K8PMaU3spfU7/kqvvnKi6K1FEYL8P77DoF4wvVK15ueBdwkJNPfeLkluItXPrcpSzespgh3YYoNkqL07000uqWbFtSdkATKkmWsHT500xZNwfCHLFpuZDyRp/EFw8ZxKwPNhMPRqXNily8IrWIRox7Lj2Umcs2cd1/F7O3NMmdFx+Sfbf7P/sDKNkBl70Euz/xb/nqN94/sGmhwS1SXorZ62aXjfY8tPtQvv/K91m8dTEX7n8h3z7w20Qswux1s1m6bSljCsdoRGhpchljlBmr8uD8ohUcnpjHm2sPUewRSRPGupeXbuSr987j6P32YfoFB9U/1sX3wn+/CT2GwPE/h60raoxF6XFjdOFolmxdwj/e/Qcjeozg5mNuZki3IRw76FjFDZFGqD4uGucXreDTibmKiyJ1FMbLz/z5VXYWJ/jV5w9g6uh96h4vt34Ir/8Fxn8RDjijxnO29BjZM68nd7x3B9tLt/PnY//MUQOPUmyUFqcGaWl1YwvHUpBTQFGyqGxafk4+Y+JxP/dRujAX0uiT+GDjHipfeA/zLengR7JZNGIcN7YvKc9x+T1zeWnpJk4e37+1i+Wn6Fg+A957BBY9CEdfCwM+BXyqWQYxrEl4O2jYAyc3kuuP+hwt4OZjbua4wceVzTtl0BQNuCHNZmzhWCIWwXPlud/znWNMaZx84uxvq3k5fqBij0gl0Yhx/P79GN6nM2bU/eQ6jEUbFsLHc2D7Krj4fzD0yBoXqxw3zAzPeZwy7BR+dvjP6JTbKShXVHFDpBHGFo4lPye/QqO04qJIw0UjxgEDuzN7+Za61ZkwTn7yLix9CqJ5cMKvoGvfas/ZKsdIhyPHcrj75LsZ38dP7aHYKC1NDdLS6iYPnMz43uOZs3GO3+AU3iIy5CSY/7DfOyaUW1CWCynMt1SUNmhOLCeSnbl4RTI4bmxfBvbI5w8zPmD5pj2MG9CtflfEm5KXgntOh4/fgUQRYLDmDX96K1wdD28HDS9Uxb04hnH1IVdXaIwWaW7799ofz3nkWISUlyLfOSaUljK5uIQS8njfDcnePPAirSzlOQpyo8xfs50Xl2ysPcaFsWjdnKBTgoNuA2HwYbVuq3LccM6RG8nl5GEnlzVGi0jjTR44mf6d+7Ny50rMOcVFkSbQr3s+G3aV8McZHzBh3+7Vx8tMcbJwBHTuXeP6K8dI8AeO31ayrYk/iUjdKYe0tLpoJMr0adMZ12scvfJ7cdPRNzF92nSi+53o5z6KBflrAbr2L8uFFOZb6hSLYkDEIJ70iEX1s5a2IzcaYfmmPa2fB335DP/AJhEepDhYP8+f3goy3Q4Kfq4zkZY0Y7VfB645+Fq+UZTixk1b+PuGLZS4POZ7I3k756DszAMv0spSnuOC299i8fpdbNkTr1uMC2NRfC9lKduKt9cpFi3ZtqTCiTZA0kuybNuyRnwKEaksGokyovsIusW68Y3SKDcpLoo0SspzPLPoEwD+/OLymuNlpji5e0OtcTJTjCxNlbJ029Km+AgiDaIe0pI19ib2kp+TXz4hEoULHgtu21zkpxBIxsveTs/F+/76XQzp1Ym/vbyCK+6dyz2XHspBQ3q2wqcQqbuZyzaxaXcp4B9OtGoe9A0La0yR09JSLoWj4kGYRnuWlhTm2bv9vdsZ0HkAZ485h+hLf4Ke/fAOPZm7lhZw85ph/OOCg1rvzgaRLDZz2SYWrN1B0qvHWB+ZYlGiuE6xaG9ib5VpihsiTSvlpZj58UxmfTyLA/seyGWdC4hueQhv6o/47otxtvU7mj8dO1pxUaQeZi7bxMfb/Y44tZ4TZoyTtZ+zbS3ZWmWaYqS0NnUllVYX5jNauXMl6/as49pXruWKGVeQClMFjD4JplwDU38IO1bBzBtg1o2w7FmieBw3ti9XHjeKUycO5J7LDmWfrnlccufbvL9+V2t/NJEaLV6/i+K0lDNQnge9xfU9AKzSiUOsU1mKnJaS9JLcPPdm/vHuP+iU04n8aL5Ge5YWF8alq2ddzaaiTWwu3swVj3+B1JZlUDiCyNHfY03vKfTsnM9xY/vqpFskgwbFuH4T/PRs6eoQi/695N/ctfguuuZ2pSCnQHFDpBmEsfH7r3yfuBdn3sZ5XLF5FqmCQly/8cxIfIojR/dTXBSpp8XrdxFPehWmVRsvGxAnH1z2IP9Z+h965PVQjJSsoh7S0urCfEZhb8iiZBELtyxk9rrZFZPqjz4FojF49ffgnL/jHXiw34s6yHG7T9d87r3sUM76xxtceMdbPHjF4Qzv06U1PpZIrTLlQW+1nHt7NoLz/EExUvHy+hWkyGkJm4o2cc2sa5i3aR5n7ncmVx90NXM2ztFoz9LiwrhUkioBIOElWLhzBbML8pmy9Em4ZxO77Cd0L8ht5ZKKZK8GxbhR0yC/R/lYBrXEIucct7x7C/949x8cM+gYbph8g+KGSDMJY2Npyr+7L+7FWRjxmJ3YwtGPXMrduUNZFvtXK5dSpO0ZN6Ab+bkRihPljdLVxstR06BLX9j+EXWJkw8ue5BfvvlLpuw7hZuOvom3N7ytGClZQw3S0uoy5YotSZawdNvSig3SK2f6zy7YUcf3+vmTls+ocHvKvj07ce9lh/LFf7zBebe9yXdOGM2GnSWtO2CcSAZhHvT5a3ZQnEiRG7XWyblXvANe+iUMOgwmfxs2vOdfZR81rVkHNAxTIizZtgTwe7iVpEq44agb+OzwzwIa7VlaR8a4ZMbSvBhTinfhPp5Dn9xXWOhNqttAbSIdUBjj5q3eTknSIy8nUnuM277Kv0A6choMOjRjLApjx/tb32fh5oXMXj+b00eezv8d/n/kRHIUN0SaSW2xcVJkBfMXP8uLfXTOJVIfU0fvwwEDu/POqu0AdIpFq4+XiSJ/bIX+k2DMZ6rEyfTzqy1FW3jggweYuu9Ufj/198SiMcVIySpqkJZWN7ZwLAU5BRWS7GfMZ7RhIaQSFadVk+N2RJ8u3HnJIZz+t9f4/sMLAf8q48RBPbjn0kN1gCRZIT0P+g8eWUTvrrHW+X3O/I1/YHPKTdB/Aow+udk3Gd72mT7ac0G0gPs+ex+jeoxq9u2L1GRs4Vjyc/IrnHjnO8eYUn8cA5coonvxUtYlx3Ll/fMVW0QyCGPcv15fxS+eep/LjhrGd6eNrrmevPxryMmD0/4GXavmmQ5jx8ItC8vqZ//O/fm/w/zGaBFpPhnP2dJiYz5xSj9+lyvvH6W4KFIP0Ygx/YKDOfCXM5g6ug8XHDak+os6b98KJTvgs7+HgQdVeCvT+VWPvB7cePSNxKKxFvgkIvWjHNLS6iYPnMz43uMx/B1utfmM+k3wb0lJV0O+pM27S8mNRnBUHRxAJFtEI8ZxY/vymQn9+WjL3syjKTcHLwXLnoX/XQNvTYcDL/Qbo1vI7HWzWbhlYcXRng3W717fYmUQqc7kgZMZ3HVw2esCzzGhtJTJxX4Kj2IXY7E3BFBsEalJNGJMGd0HgP36ds18ch3Go6e+A+89Aod+NWNjNJTHjvSLRTtKd/Da+teapfwiUm7ywMmM6DGi7HWB51WIjSXEeN8NUVwUaYBOMb+H86eHFWbOw+6l4L3H/LG0+k+C/hOrrCNMq5N+flWaKuXtDW83Z9FFGkwN0tLqopEotxx3C30K+tAt1o0L97+QW467pWo+o1HT/PxIuUGjdCSnxnxJi9fvorSugwOItLLDhhdSkvBYtG5H82/MS8E9p8MjX/avsuPB5g/86S3kvS3vVZuqR6Q1hbc65kXziBDh8gMu46ZIP6Zv2EwUiEcKWOCNZKY3sWwZxRaR6uXn+sdzJYkMMSY9Hs25w5+29q1q41FNad5EpPmN7+13BJqy7xR+WxRl+obNGMZel8f8tNiouChSP7Go3zRXeXBDoDxWPvYVSJbA5qX+60qxUjFS2ho1SEurS3kpvv7i19lSsoVd8V3c8/49fP3Fr5OqfDISifoDGJ55p5/r1kvByTdVm+M2HEynwioMxvTv2lwfRaTBPj2sFwBvrtzW/BtbPsPPvx7fWz5tw7v+9BaQ8BLMXj+7yvSMqXpEWlB4q+O1r1zLwi1+uqd3tyxi8hfuJQow8njeP/JmrrCf4KUdQrXaYKQibUBB0CBdHM/QyJwpHn2yoNp4tDu+u8o0xQ6R5hfGxweXPQjAOxve4b4ePSDWmY8OuIrvet/iwsQPy2Kj4qJI/UQiRiwaqdKhDvBj4sdzytOXJovLx9JKM7z78CqLKkZKNlODtLS68NYSLxissChZxMItC5m9rmqDFZGony/67HshtwBm/6Ha9YaD6XSKRTEgFjVSDl5YsgnnWigtgkgddS/IZUCPfB6cs5YXl2xs3tQdGxb6+dfThfnYm5nnPH762k95b8t7DO02lIKcAgyrPlWPSAuqfKujh+fHoxVP+jN8+nLGH3M2+w/sWbZMjQPPiAi5Uf+24xeXbqoa3+oRj5ZtW8YDSx+ga25XxQ6RFhbGx6RLAsH5WnIHs3sPZugXruPDHpPxiGAoLoo0RMpzRAzeWrk1c6xM1B4r3/zkTRyOvGieYqS0CRr9Q1pdTbeWVDsCbJc+cMil8Ppf/VHYi7b4OabTRphNHzDu/fW72H9AN+as3sbfZ66kb9c8vnvC6Ob+aCJ1kvIcF9z+Fpt2lZL0XPMPkhbmY0/vkVZDPvam4pzj+reu5+mVT3PVgVdxybhLmL1uNku3LWVM4RgmD5xcNVWPSAuqNh59+BxTAHauI4rHjWdMYOrvZnLiuL588eBB1Q88I9LBpTzHFffMBeDV5VuYu3p7xfhWx3i0K76L7878Lt3yunH/Z+5n6balih0iLShjfHQeS10pU5Y/x/mHjuS6p5bx1SnDOXhooeKiSD2E54IlSY95a3ZUPRfsN8FPV+olyheqFCtnrp3JQx88xAVjL+DQ/ocqRkqboAZpaXUZR2yuy60lh30DXv8bPHONn74j1snPKX3BYxUapY8b25fjxvqD4xw7Zh+27onz55dW0LtrHhcePrS5PpZInc1ctokFa3eQDK6Epw8GE/52m9SoadB3PKx9038d61xjPvbGCPPxLtm2hOXbl/P86ue55IBLuPSASzEzpgyaUv2FJ5EWljEeAWM+esN/8fxP4P3H2XPsXQB84cB9m6eOirQTYXwLVYlvo6ZBnzGwzm+0rhyPUl6KV9e9yh/m/IGPd3/MHSfdQd/Ofenbua9ih0gLGls4lrxoHiWpkrJp+c4xZsd6eOTLHNdpf37BVVx1/H5leeNFpG7qFCtz8iGRAufK2j1SI45l9tpZzN04lweXPcjonqP59kHfJhaNKUZKm6AGaWl1kwdOZnzv8czfNJ+4Fyc/ml+3W0s+eddveA6vFMb3ludSGn1SxkXMjOtPH8+2vQl+9t/F9Oqcx2cm9G/iTyRSP4vX76qSWzMcDKZZGrsiUTj0Cr9B+qBLYL+TKtxd0FTCfIPpKRD6FPThWxO/hZl6zUj2CePROxvfwXMeBZEYE4r2MHnvHn+GhB9noitfADrTLT+3Vcsrku1qjW+RKIw+2W+QPvIqGHxEWTwKY8i8TfNIeAlyI7n8fcHfmT5tunp7ibSwyQMnM7jbYD7Y/gEG5HuOCaWlTC72G6j7Jt/juOi75OV8tnULKtIG1RorE8V+yo6xp0LfA6DfeFIjjuWKF79e4TwrL5pH1BQfpe1QDmlpddFIlOnTpnP5py4H4PIJl9ftZGPDQvCSFafVIQ9uTjTCX780iYOH9OQ7Dyxg9gebeXHJRv784vLmz90rkkGmATibfTCYj+f4V9pPvtG/gNMMJ/eV8/EC7Ens4bX1rzX5tkSaQhiPuuR2YUzhGG7qfSTTP9lIeu1w8SK2LJ8DwNINuxQzRGpQp/i24kXo/ymY9osK8Wj2utks2LyARNDxIOElqh9jRESaVTQS5ZRhpwBwWbcDuGnTFqZv2FwWH3O8EsZFVvPS0k2KiyL1VGus/PgdcCk48AKYcg2MPonZn7xR5Txr+Y7lipHSpqhBWrJCNBLlxKEnAvDelveYvW42KS/DaOzpwryD6eqYBzc/N8o/LzyEIb0KuOjOt/nGv+fxxxkfcOX987ng9rd0ICUtqvIAnAADexY0z2AwXgqWPQuLH4OeQ5ulITpUU354kWyU8lL876P/sSu+i3G9xjF52ElEK8WZUsvjnlX+CcKNzy5VzBCpQRjfosEZR4XBzrwULHoY1rwJhSP812kWb11Maaq0wjTFEJHWkfJSvPnJmxTkFPCp/ocwOeEqXKwtdjEWpgbrXEqkAcJYmRPkXa8SK+fdDRiU7C6LlTrPkvZADdKSFVJeil++8UsAXlr7Ete+ci1XzLii5kbpUdP8PIO5QWOBReuVB7d7p1yuOHoknoOShIejYr4mkZYSDsD5l3Mn8Z3j96Owc4y+XfOafjAYLwX3nA4Pfxl2r4etH/qva7v400ADOg/AUfGEpE754UVaQZge4Odv/ByAp1Y+xRWrHyE1YFLZPMmcTsz3RvJC8lMAFCc8xQyRGoTx7ZjR+xCLRvjLuZP8QZrw/Pjz+NcBB8v+VyUerduzrsr6FENEWl4YH9/+5G2Kk8Vc++EDXNG/HynAYex1ecz3RjLTm6hzKZEGCGPlqZ8aAMDvv/ipirHy/ccBB//9RlmsHFs4tkp6DsVIaWvUIC1ZYfa62by35b2y10XJotpvy4xE/QEMz7wThk31b2OZ+sN69fhcv7O4yrQwX5NISwoH4PzW8aM4/7AhvPbhVj7J8PtslOUz/Dzrib3+ay9Rnne9icVTcR5Y9gARIuRH8zGMgpyCuuWHF2kFYYqZsEdmaaqUhVsWMfuQ8/0ZxnyW/+33a84v/QFe2uGTYoZIzaIR4+ChhcRTHocO7+VfbA3jUdgDOllSIR59vPtjnvvoOXrm9aQgp0AxRKQVhfHRwwOC87TcCLML8nln34v5VuJKLkz8sCw2Ki6K1F80Yhw+ohcA+/fvVh4rP54Dzq976WNmDegygKRLErWoYqS0WRrUULJCTbec1DhCbCTq5xscdhT86VPw8q/hoiehjgOmhfmaitIGEWj23L0itTjjwIH8+cXlPDpvHd84ZmTTrXjDQj/Perow73o1A4E2hHOO69+6noVbFnLj0TfSKacTS7ctZUzhGCYPnKzBqCQrVRuHNi9iCsAhl9E5vj95781XzBCpp77d8gDYuKuELn261BiP3H4n8qu3fkU0EuX+z97Piu0rFENEWlHG+OiSLM0vYOQRP+CNNQvwFBdFGq1f93wANu4qZUivzn6sTGSOlX9c+18653Tmx4f9mPV71itGSpukBmnJCmMLx1KQU1AhKX+9bjmJdYajr4FnroVXbgTMzzEdjNRenTBf04K1O8oaGDrn5TBlvz6N+TgijTKkV2c+PbSQR+Z+zNenjsDqeIGlVmHe9fje8ml1zLteFykvxex1s3nog4eY9fEsLj3gUk4edjJAzReWRLJAtXFo50b/xbaPmDrpKCYO6sFbH20j5bmKOf5EpFp9u4Un2SWM6NPFj0e5BRVOtFOxTszOi/LfV67mtXWvce0h1zKwy0AGdhmoGCLSisYWjiUvmkdJqqRsWj7GmJQxOTKfSft24/WVO3CguCjSCP2CWLlhV1DX+k2AaC6k4gCkgNnduvPcnvd4dcs8vnPgd/jciM+1UmlFGk8pOyQrTB44mfG9xxOLxADIi+bV/5aTSRdANA9m/gZevh4e+XKt+XHTc/d+b9p+nPapAWzeXcr0V1Y29iOJNMoXDhzIyi17+eFji3hxycamGRwmzLtuwa4/1rleeddrEuYX/N6s7zHr41lELMKiLYtqH5xUJEuEcShUkFPAhKRj8sIn/AnP/4TofV/gnksO5oAB3dina155Ptymzvcu0s707uL3kL7njdV+TBtxPBQOD941UrHOXDFwINd8+B+eX/U8hjFz7UzFEJEsMHngZIZ0GwLgpwbAmFBczORd24g+ein35v2WXgUR9u/fTXFRpBF6BbHy4Tlry2NlQU8AUhhX9O/HNb268+SWeRjGa+tfU5yUNk0N0pIVopEo06dN56eH/RSAzw3/HNOnTa/fLScfveI/Ow9wFXIs1bxtP3fvlceN4uZzJvL5iQO46bllPLVwfQM/jUjjpDzHY/P9wZz+8/baphuxPMy7nt/D7xV9xh3+6ya4tWv2utks3LKwLP+u5zwWbVlUcx54kSwSjUS5fvL1ABw18ChuGnEO09etI5pK+DMk/JgS/fAFcqMRRu7ThePG9tVJt0gtUp7jp4/744Q8894GP6bdOQdv1AlABI6+htnHXs2inEhZWgCHUwwRyRLRSJQzRp0BwMX9j+amrTuZvmETUYD4XmzdHA5z8zlkaE/FRZEGSnmOb/57HgCvLN9SFitdfg8YcBCzD72IRZ26UBwMGK84Ke2BGqQla0QjUT47/LN0ye1StnOt1xW/DQvLbmcpE+bHrSMz4zdnTODgIT357oPvMm/N9rpvX6SJzFy2iUXrdpa9btIRyxNFULwNxp3u541uojxjNeWBF2kLUl6Kpz56CoBxvccxuSROtJoct7tKEnTLz22FUoq0PdXFtO0r3oa+4+DYH7OkoJNiiEiWSnkp3tnwDhGLMClpTN61k/SjRxcvYnhyJV3ylQ1UpKFmLtvEgrU7yl4XxVN8sHYDbPkA9juRJQPGUuwlKiyjOCltnRqkJWukvBRffeGrFCWLWLZ9Gde+ci1XzLii7o3SYX7cdA3Ij5ufG2X6BQfRr1s+l989h7XbimpfSKQJLV6/i+J4xd99k41YvnWF/9xrVOPXlWZY92FVptUrD7xIKwpTzvxt/t8AuOu9u7hi+1ukqokpO4sTdC9Qg7RIXWSOaUk6b3kXBh4I+DlqcyMV65RiiEjrC+PjS2tfwnMeP9j6Olf070uFGp3bife8IXTOU4O0SENlipXDEx9iOBgwqSyXezrFSWnr1CAtWWP2utks2rIIz3kAFCWLWLhlYd1vQwnz48Y6l0/rP6lB+XF7dcnjjosPoTTpcem/3mFXSaL2hUSayLgB3SiIVey53CQjlnspWPSI//eejTXmV6+vlTv8vOt50Tw/v2BOQf3zwIu0kjD+xD3/LpuSVAkLi9Yxe+D+QHDrcVrO9V3FSboV6MRbpC4qx7QIHhfGZpKf3A05eeClOHLAkeREcrDgn2KISHYI42PK+ceMRV6chXl5zC7wB18j1plE/wOZ6U2kixqkRRosU6z8Yu6r/ovibUzufzi9CnoBKE5Ku6GoIVmjplv+6zS6epgfd/kMWPY/mPcvGHZ0g1MSjNynC/84/yAuuuNtvn7vXC48fChLN+xm3IBuTB29j/KjSbOZOnofJg7qwYK1OyiKpzBo/IjlXsof5HP16/7rGT+DJU82Kod0yksxe91sFmxawH1L7mPKwCmcNfoslm5bypjCMUweOLl+eeBFWkm18edTlzBl9bswcBJM/i6MmkZxEooT/h0LLy7ZqHggUoswpr25cis4j/vyfsNBtgyA1Lx7mL15Pi+NPIKiZBFn7XcWfTv1VQwRyRIZ46PB0rwYUwYfQ2rSRTyyYzTeB0tYvbWIlOcUE0UaIFOs/LS9jwO8p7/LKwtuY1duMQM7D+S0kaexf6/9FSelzVODtGSNsYVjKcgpoChZniKj3rehRKJ+XtzRJ0HRVnj9L3DIpdC5d4PKdOTI3vzitHH86LH3eHPlNlKeoyAWZeKgHhpBWppNNGLcc+mhzFy2ibteX8Wry7dw05mfatzvbfkMf5BPr+IAbSyf4deXegpv4Vy0ZVFZnd1Wuo3JAyfX7QKSSBapNv50GwZeHEafAqNPIuU5LrzjDQBe+3Ar89fuUDwQqUUY0z7/t9mM2vEah9hKcpIJUsAVvbuwyNtA0YrHAPho50f8+NAf6wRbJEtkjI/RGGNK46TGn80Fr/Zk3hr/AtO9b65mySe7FBNFGiCMlV/8x+sM2vIKh0RWEk16fqws7MQCbyOlCaM0VcrcjXO5fMLlipXS5illh2SNyQMnM773eApyCgCIEGncbSjH/cwfwG3WjY0qV99u+eREjKTncDTxAHMi1YhGjOPG9uXHnxkLwKvLNzduhRsW+gOypavnoJ/pwls4009QVuxYoZGepU0K448F6TnKboPsPsKfoYt/d8LMZZt4r7kGHBVpx6IRY1jvLoyLrCIn6G05uyCfRXl5FKU1XC3eulhxRCSLTB44mXG9xpW9LsgpYELXoUwuLuHdLbBg7Q5KEn66xdKkp5go0gjRiDGkd2fGRVZXiZWlQayMe/H6pTUVyWJqkJasEY1EmT5tOjcdfRMH9z0Yh+N3U37X8Ct/ffaDAy+Ed/4Jc+70G6aXPVvvvLmL1+8i5bkK05psgDmRWozu25V+3fKZuayRDdJNNOhnqKYUOyJtTTQS5e/H/52IRZi0zyRuOvomph93C9Glz/gzbF8NXorF63eVnXiHFA9E6qZrfg4LU0PKYtGSvBjFVrEXpeKISHaJRqJcd+R1ABw76FhuOuq3TO88niiwe80iSuMVx9lRTBRpnE6xKItSQyBXsVLaPzVIS1aJRqJMGTSFyydcjsPxm7d/w6y1s0g1dPC1o68BHDz9PXj5enjky34e3XqsL9MAc/m5kcYPMCdSB2bGMWP68NqKLSRSXu0LVCcc9DO8wJM2QFtDhLdwptNIz9JWpbwUz656lpRLMaL7CCb3P5zofWfCy7/yZ3jtT3DP6Yzr15lYTsVDpyYZcFSkA+ian8uzpeNxAw8GjLGlcQoqXu9XHBHJMikvxUurXwJgvx4jmfzyH4i+8TcAJq++hXvzfkOE8uNTxUSRxukUy2FGYgL0OwCAsaVxYoqV0k6pQVqyTspLcdvC2wB4+qOnufaVa7lixhUNa5TesAgsCi4FOIin5c2to3CAgU6xKOG1STPj0GG96l8ekQaYst8+7C5NMnf19oavJBz0c8hkyOsGZ9zRqAENJw+czIgeI8pea6RnaavCfOi/eOMXAPz3w/9yxZNnk1o3B5Kl/kzJYlg3h6nRdxnSy++xYvi9WBo94KhIB9E1P4fSlFF69oNgxuQ+kxjbfXjZ+4ojItkljI9/mf8XAO56706uKPmAVMqPjdFUMZMiKzg+510ACnIVE0UaqyA3SnESUtOuB2DyiM9SmF8IgGGKldKuqEFass7sdbNZvHVx2euiZFHD8yRtWAhesuK0eubNDQcY+Mu5k/jutP246vhRFMVT/PCxRTjnal+BSCMdNryQiMHvn1/Gi0s2VkkhU2eRKBQOg9wCfyDDRgyEEY1EOXzA4RjGlw/4sp/iYNp0Da4hbU6YD70kVQIEufl2r2J2tNIdCfEiohvf44LDhwBw+dHD+cu5kzR4k0gdpDzHJzv8NE8z5n8AziO6/+c541NfAeDM/c5UHBHJMmF8jHtxAEpcgoWxHGYX5JfNk+dKOWPANgBuPHOCYqJII6Q8x7ogVs5ZthKA6Ke/QvfOfRnRYwTfmPgNxUppV3JauwAildWUm3bKoCn1W1mYNze+t3xaA/LmhgPMHTe2LwB5ORFufHYZBwzoxhVTRtSytEjDpTzH1++bB8A7q7azeP18Jg7q0fAD/kgupBK1z1cL5xwvrH6Bg/sdzHcO+k6j1yfSWjLGHJdkaafOTClOmx7Ejj2f+HfrfPv4/aqkcxKRqlKe44Lb32JOcJfPP//3Op+LQqpLX2avm01hfiE/PeynREz9ZESyScb4aMbSvBhTiv2LuBbrREnvcbAGThnfX43RIg1UFitX+Rd4Hn71XQ6NwKZIlKXbl/KtSd/iKxO+0sqlFGlaOvKTrNOkuWnDvLm5nYMJBgMPanDe3NDXpozgM+P789tnlzLrg0YONidSg5nLNrFg7Q7CTtFF8VTDRzD3UrBrPcT3NGiAz1DKS/Gfpf9h5c6VDOs2rOE53kWyQOaYU8CYbsMgEly3T8u5vqskQW7UyM/VIZRIXYRxLJ70iOAxxXubFPCfxc/y4poXGdljpO44E8lCGeOjRRiTCI77gti4uNOnyc+NqDFapBHKYmXKEcFjkreYFPD71/2UOXk5eTrnknZHZ1OSdSYPnMz43uPLDoCiFm14nqQwb+6Zd8C40wEHE85pVKoC8HNI33TWBPbr25Ur/z2P1Vv31r6QSAMsXr+L4njFg48GjWDupfwBPZc/D6l4gwb4hPJ8gjfOuRGAJ1c+2fAc7yJZIIw5OeY3Ppfl5jvvf9B3PHTpVyHn+q7iBN3yczHTibdIXYRxLILH3bk38NWcJ7iiXx/+WPQapalSFmxaoDgikoXC+Bg1/7ypIKeACf0OYXK3UdClb1ls3JOALnm68VqkMSrHytOjr3BF3z48V+TfKfu3+X9VrJR2Rw3SknWikSjTp03npqNvYmzhWGLRGH877m8Nz5MUifr5cs+4AwZMgpk3QKKk0eXsFMvh1gsOxsy4/O657C1N1r6QSD2NG9CtSlqABo1gvnyGP6CnF6TraMAAn1CeTzAZ5GYvThY3PMe7SBYIY8643uMozCssz82XE/Pjxz5jK+Rc312SpFtBbiuXWqTtCOPY1MgCJkVW8E6nHBbl5VEa9KaMe3HFEZEsVBYfe42jV36vID7eSjS3AHrvVxYb95Ym6awGaZFGqRwr3+6Uy6L8PFJBB4ginXNJO9QmGqTN7Ewze8TMVptZsZktM7MbzKxrpfl6mtk/zWyLme01sxfMrEqyYDPLN7ObzOyTYH1vmNnRGeaLmNkPzWyVmZWY2btmdkY1ZfyKmS01s9KgfF9tum+g44lGokwZNIUvH/BlipPFXP/W9cxaO6txVwQjEZj2C9i5Ft65rUnKObhXJ/76pUks37Sbqx96V7ecSpObOnofJg7qQae0RukDBnSr/wjmGxb6A3qmq+cAn1BzjneRtmxPfA8FuRVvTaZ4G3QqrDBpV0mCbvk68RapqzCOTcxZQz5xluTFKK50h4HiiEj22pvYS35O+UCGlOyCvPKOEXtLk3SOKS6KNEYYKz+Vs1qxUjqMNtEgDVwNpIAfAScBfwe+Bsww80dAMf/e2f8G718JnAHkAi+b2b6V1nc78BXg/4DPAp8Az5nZxErz/RK4DvgrcDLwJvCQmZ2SPpOZfQWYDjwSbP8h4BYz+1ojP3eHlvJS/GfZfwB4dMWjXPvKtY2/TWXY0TDyeHjld1C8o0nKedSoPvzw5LE8894Gvvfgu/z5xeW8uGQjKU+N09J40Yhxz6WH8pdzJ3HeoYMBOOvgQfXP0xcO8JmuAQN8NmmOd5EsEKahWblzJev2rKsYa4q2QUFh2ryOtduK2FGU0H5epI7COHbU0cdSQoyxpXEKKl3AVxwRyT7VxsfSXZDfPZjH8fG2YnYWxxUXRRohjJWfOuTosliZp1gp7VxbaZD+nHPui865+5xzs5xzNwPfAg4FpgbznApMBi5wzt3vnHs2mBYBrg1XZGafAr4EfMc5d5tz7kXgi8Aa4Bdp8+2D3xD+G+fc75xzLzvnrgBeBn6TNl8O8GvgHufcj4P5fgLcBfzSzHRfbwPNXjebJVuXlL0uShY1zW0qx18HJTvgv1fCrBsbNbhb6JIjh9K7S4xH56/jjzM+4Mr753PB7W/poEyaRDRiHDe2L7/6/AH065bPjPc31n8l4QCfYQ+XnPyyQdrqY/LAyRzQ+4Cy12X5dhuS410kC4RpaBz+/ros1qx52Y8Vm5fAsmdJJZNccPtbrNy8l9XbirSfF6mHaMSYdOwXec9GcXhxgvGlpRCcaCuOiGSnauNjahdsXU5q6TNc+M/X+WDTbtbtKFFcFGmkaMQ4YMqZzPdGckRxnGEJP9WioVgp7VObaJB2zm3OMPmd4Hlg8HwqsN4593LacjuBJ4HT0pY7FUgAD6TNlwT+A5xoZnnB5BOBGHBvpe3eC4w3s2HB68OBPhnmuwfohd9ILg3QbKkB9tkfOveFJf+Fl69v8OBu6WZ9sJmiYOA5BxTFUyxYu4OZyzY1rqwiacyME8b15ZXlm6sMdFircIDPE2/wXx98WdkgbfURjUT5zVH+NbmjBh5Vnm+3kQOFirSWamPNyz/zX6yaDY98mZ23fpaFa7cRnmZrPy9ST5EoP+r8C9bkj+X63Q7MOGrAZMURkSyVOT4WszTHwcfv4B7+Mt9cdy04D1BcFGkKXQryuDDxQ4ry+nKO59/dev7Y8xUrpV1qEw3S1ZgSPIddaMcB72WYbzEw2My6pM33kXOuKMN8MWBk2nylwIoM8wHsnzYfGbZdeT6pp2ZLDbB8BsR3By9cgwd3SxeOipuuOJ7i/fW7GlFQkapOHNePkoTHrA8yXaerRSQKE77o/92lT70bo8G/fXPm2pkADOs+jMkDJ+vASNq0sYVjyY/mV5iWH8llzLa15RPie+myZQGHJudWmE/7eZH66dY5n13k83TPXgAc0Ge84ohIlhpbOLZi7mgg33OMKY0DkJMsYgLLmRpZUPa+4qJI4+TnRsmJ5pDEeKtrDwAO7HuQYqW0S22yQdrMBuKn13jBOTcnmFwIbM8w+7bguWcd5ytMe97hqo5Sl2k+Mqyz8nxVmNnlZjbHzOZs3tyAxqV2bvLAyYzvPb6sUTpikaa5TWXDQkhUvNrfkMHd0oWj4qaLRoz9B3SrZgnJVtleLz89rJDuBbk8//6Ghq0gr4s/EM3u+i8f5hL87Tu/BeCBZQ80Pq+7SC2au05OHjiZkT1Hlr0uyClgQqyQybsrnlDneiVMyFlTYVpBLKr9vHRIDa2XPTvlcGPPrfw1xz8Ou/O9OxVHRJpAc8TKyQMnM7ZwbNnrAsthQmkpk4tLyqblE2d/W10+j+KiSJmG1ssu+RGu7ul4Luk3Kf149o8VK6VdanMN0kFP5yeAJHBJ+ltApoRVlUf+ao75qGbeGjnnbnXOHeycO7hPnz71Xbzdi0aiTJ82nZuOvonxvceTYzn86Zg/Nf7KYBMN7pYuHBW3UyyKATkRI+k5EkmvcWWVFpft9TI3GuG4sfvw4pJNJFIN/H117Qe719d7sTCXYGmqFIDSVGnT5HUXqUFz18loJMpVB14FwOdHft6/JfJT3yGak1dxxtxOFBWW3/TUKRZl4qAeTB29T5OXSSTbNbReJvOW8GEsRTw4ei5JlSiOiDSB5oiV0UiU/zv8/wCYNmQaN+13AdO37ib9TCwRyeN9NwRQXBSprKH1Mq/bByzOi5KqnL9dsVLamTbVIG1m+cB/geHAic65j9Pe3kbm3shhz+jtdZxvW9pzTzOr3ACdaT4yrLOw0vvSANFIlCmDpvD1iV8n7sWZt2le41caDu4W61w+rffoeg/uVrGc/qi4fzl3Et+dth9//dIkDhjQjWsfWcjH2ytnhxFpnGlj+7KzOMEPH11U/xHNvRREc+HjufUe0LPZ8rqLtLKdpTsBP0fflEFTiO53IvQMh4owiHXG9j2Ys875MgAnH9CPv5w7iXsuPZRopPJhgohkkvIcW+IrKLWKMUtxRCR7FSX885jPj/w8Uz59FdE+YepEPzbmDP40M72JHDWqt+KiSBNIeQ6iqyip1AylWCntUZtpkDazXOAR4NPAKc65yvkVFlOezznd/sAa59yetPmGmVmnDPPFKc8ZvRjIA0ZkmA/g/bT5yLDtyvNJIxy4z4HEIjFuWXALs9bOatztKuHgbmfcAUddDbEukN+jQfl000UjxnFj+3LlcaM46YD+/O28A3EOvvnv+cTVU1qaSMpz/OuNVQA8PPfj+o1o7qX8ATw3/z97dx4fRX0/fvw1M3vmIgQIISEICIRwhKAoHpGgSItXW2svvy39ttrKr1Xbby97aO9TaWtbLUpb7bel1vbbWlurrRbRoFFEUSAYQgh3SAghhNx7zszvj9ndZEOAHJtsdvN+fh88wszO7oz9ks97P+/5zPtdDW1HB9zQc9jqugsRR7qh83rD6wDsad5jxRdVg4us5DOXf9aKF6ufpDNg/Z6978KprCicLJNuIfpJN0w++ptXedex/+DuVQ1P4ogQo5Nu6LxS/woA+07tQwe48h7rxcWr4aZHabnpzxiorJw3WeKiEEMUjpUfby/DJbFSjAEJkZBWFEUFHgNWAO82TfO1Pg57CshTFKW0x/sygBtCr/U8zg68v8dxNuCDwH9M0/SFdj+LlaD+cK/zfAR42zTNg6HtLUDTGY5rBl7p53+mOAPd0PnMC58haAZ5++Tb3PXSXUOvoaRqULAKVnwdln8FDrwAh2L7CMx5E1L50U1F7KhtYe1zcjdTxEZZdSMVR1sj2wPqaF6z0WrgaQSt7QE29AzXdXeoDgBcmis2dd2FiJNwXfS/1fwNgO9v/X53fPGFmt8u/6oVL1SNNm8AgAy3PV6XLERCKqtuJONoGf/lOcRCnw/FNME0cRsmRSl5EkeEGGXC8fHXFb8G4KGdD1nx0R9a43XxJ6FgFV1WWCTFYYvTlQqRPMKx8mbvEWb7Q79cEitFEkuIhDTwS6wE8o+BTkVRLunxZ2romKewksN/UBTlQ4qivDO0TwHuC3+QaZo7gD8DP1MU5ROKoqwA/gTMAL7Z47hG4H7gq4qifF5RlOWKojwEXAV8rcdxAeDrwH8rivK90HHfAW4BvmGapn9Y/hcZQ8J1aw3TWmUc8xpKF30C0nPh+W/DaT0sh+a6oimsvuQ8fv3yQTZVHY/pZ4uxqbK+DY8/+mZMvzuaN1RYDTx7GkBDz3Bd9/fPse7nfXXpV1m/cr10fBYJKxxfAob1pd8T9HTHF08L2Fxgd0WOb/NYN3MyXJKQFmIgKuvbmK0fIBU/6xtO4DBNinx+7m1sYv34SySOCDHKhOOj37CmspF67yd3Wgc40wDo9FtxMc0pv8NCDFXPWPmJFmsB0k3tHRIrRdJKlIT0NaGfd2MlnXv++QSAaZoGcD2wEVgHPAnowJWmadb2+ryPA78Fvgc8A+QDq0zT7F2g+O7QMZ8FngMuBz5gmuY/ex5kmubDwKeAD4SOuxm4wzTNXw7pv1oAI1C31u6G0rvg6Ouw99nYfGYPd19XyLwpGXzhLzupa/Gc+w1CnMX83AzcjugvI/3uaB6Dhp6aqjEzcyYAV+RdIV+MREI7a3zxtoJrXNRr4RXS6S5ZCSbEQMzPzaBGm4kXB15FwaeqrOjq4oqAgjZlUbwvTwjRyxnjY3uohZMjHYBOn5WQlhXSQgzd/NwMatQZBNGotVuLH/7nVKvESpG0EiIhbZrmdNM0lTP8+VaP45pN07zFNM0s0zRTTNNcYZrmzj4+z2Oa5udN08wxTdNlmuZS0zTL+jhON03ze6ZpnmeaptM0zSLTNP96hmtcb5rmnNBxs03TXBfL/w3GshGpW7v4I1YDq3/dBWX3DrjZ29m47Bq//PAFBIIGd/7xLQK61JMWg7e8IJvi/ExSQklpVaH/Hc17N/RUNGt7AA09dUOn6mQVAK83vD600jlCxNkZ48v4OXBij1Xepkc8aJeSHUIMyvKCbNqmLmc7s/hnqnVjtFFzQP7AYpAQYmScMT52tlgbR14FQ6cz9NReqqyQFmLIlhdkcyDzMjpw8qrbhdMweMOVJrFSJK2ESEiLsS1ct7bnl6J5WfNiW0NJUa1Hs1uPQNkPB9zs7VxmTEzlhzcV8daRFu57bg+bqo7zi001bKo63r9mdEKEaKrChluX8sDNi7ls5gQME372weL+NZHp2dAzez64MuAjf+t3Q89wPcF/7P8HAN/e8u2h13MXIo7C8UUNfR1y29wUTVxIyYs/haNvQNfJSDzQg0F21raiAK/tb5KxW4gB0FSF396ylHsXzGDthCwA/po5jv+Xk41EECFGn3B8tCnWyme3zU1R0KRkz4vWAX//FOaGG9m6z+ph8nZdq8RFIYZIUxWK89P5Yk46W9xufKrKPVOyJVaKpCUJaTHqhevWrl22NlK79sbZN8a2VEDNRmg5EtowB9zsrT/etSiXD12cz69fOsinH3uL+zfu5c7Ht7P6ka3yBU4MiKYqrCiczFevLQTg5Zqm/r853NBzycfBcwra6vr91rPW2xUiAYXjS05qDjMyZrB22VrWn3cTWt2bEOpbgL8T8+g2frruQZ6rbMAEPvOnHTJ2CzFAW469wnFfDf7QDVSfGaSiaZfEECFGoXB8vHjKxbhtbtae/yHW19Whhb4D4u/Ed2gr+159EoAf/XuPxEUhYuBA/T+odNkxQmuNugy/xEqRtCQhLRKCpmqU5pdyzyX3kOXM4m81f+PhnQ+zuXZzbFZnNlRAYPDN3vqrdM4kFMAXNDCBLr/OjtoWyqobY3oeMTbMz80gO93JC4P59zPtEuvnkdf6/ZZhr+cuRJx0BbtwaA5ro6/mn4EuHE2VBEMTbRm7hRi4quYqvLo3ap/EECFGN5/uw6E64NSh02Kj3fAxxzwEgCdgSFwUYohOtPsw9V14lOgnXyVWimQlCWmRUEzTRFM13mp8i3U71nHXS3fFpmRAX83e7ANr9tYfNcc7Ttvn8evsrm+L6XnE2KCqClfNzeal6hMDr02ePQ+cGXBkS7/fMiL13IUYQeEyNC2+FqpPVVsx5dRW9F7xIKC6qAhOi9onY7cQAyMxRIjEEY6P2xu30+pv5a6mV1gzZXJU2QAvDnab50W2JS4KMTTbDjVzgb+D3i1CJVaKZCUJaZFQyuvKafW1AmBi0hXsik3JgKhmb6E7kpn5MW8eMD83A7cjutSI26ExLzcjpucRY8eVc7Np9wXZdujUwN6oajD1Iqsszeb7+tXIs3c9dwWFoolFsa3nLsQIKq8rp6KpIrLdFeyioquO8rx53Qc5UumYWMxW24VR75WxW4iBsWLIAhyh+6dOxWbVbJcYIsSoEy7TZoTKV3UZfipcTspTrMbYQVsKFcymzCiOvEfiohBDYOic2vFPPumtJhUVJfR/Vn8TmW+J5CQJaZFQqpqrIvVrw2LyCEvPZm/Lvwbj8mPW0LCn5QXZFOdnktIjKV2Qk87yguyYn0uMDSWzJuLQVF7Yc3xgbzR0aN4PbUfhxR/0q5Fnz3rul+dejonJdy7/TmzruQsxgqqaq/AG+yghsOBd1sbMK+GmRxl329MU5WeFb1eS4tAozs+UsVuIAdCA9Q2N3HHKuoH68ZY21jc0IhFEiNGnzzJtwJ6sPEjPRXnfozyYd1/kO6DERSGGwNBhw43cuP/rZCrt+Eydy3Fx+6JPW/1NVq6X+ZZISpKQFgllWB/3DDd7W34XrPwOnKyB3X8f+uf2oKkKG25dygM3L2bNspmkOjV0w8Q0pQGIGJxUp42lM7N4Yc8Aa/bVbIT2htBG/xt5huu5f+aCzwBw3xv3xa6WuxAjrDCrEKfmjNrnsrmYm5Zvbcx7FxSsQrPZ2HDrUsan2Jk3JYMHbl7MhluXoqlKH58qhOhTzUa0uje51GPdBDqomZSfrEDf+1ycL0wI0dsZ51xaGmTNRJt7Db//xGVcOTcbm6pIXBRiKGo2Yh7dhgMvv89Ix6OqzG07ySdc0yjNL5VktEhakpAWCSVcMsCu2gGG7xGWee+GiQXw0o/BGGBt3nPQVIUVhZP56rWF3HfTIiqOtvLLF/fH9BxibLmyYBL7T3TynX9WsqnqeP86nDdUQNAXva+fjTx1Q+cn234CwKYjm2JXy12IEVaSV8KszFmR7UhMGV9g7XB2P3qsqQoB3eTiGVmsKJwsk24hBqqhgqC/i+9NHA/Ac6kp3DU+jTU775f4IcQoE55zKaFngyLxMWCC3UpUa6pCbqabFIcmcVGIITCO7SQY6GJNziQezMoE0+SxNJfER5H0JCEtEkq4ZMBnF38WgA8WfHB4HmFRNVj2JWjcDXueju1n93Bd0RTeXZzLL16ooeJoy7CdRyQv3TB5psJa6fzoK4e48/HtrH5k67mT0n018nT0r5FneV05bze9HdmOWS13IUaYpmrcsfgOAN47+73dj0X6Qg1oXZmRYw3DpMMfJMNtj8OVCpH49MkLeSElnb0Oh7VDUehSVSr8zRI/hBhlwnOuVHsq8yfM746PQR/YXZHjfEEDh01WbwoxWLph8pMKJy+409jldBJUFFAUPBIfxRggCWmRcDRV4yPzPkK6I51WX+vwPcKy4L2QdT785x4ou7dfTd8G4zvvWsCkNCef+/MOvAG5AyoGpqy6kaqG7o7mXX6dHbUtlFWfo4RHuJGnGurjbE+1tvvRyLPPuoKxqOUuRBx0BjoB+EjhR6zHIgH2bbJebKyKjPvtviCmCRmu3r3PhRD9UaYvYrN9Ml4lehWlxwhI/BBiFNJUDROTxdmLu+Nj50k4eSAyL/IHDZw2SSkIMVhl1Y38rmkOm+2T8fSKj16JjyLJSfQQCUlTNS6efDEv1r7IwzsfHr4atqoNWg5D2Q/71fRtMMal2Pnx+xex/0Qn9z4rAUcMTGV9Gx5/9L9Jj19nd33bGd4REm7kueRWa/sd37O2+3GDZ1hruQsxgnRDZ9vxbQBUNlWiB/3WOF9+v3VA2fcj436712qom+GSFdJCDEZlQyf/1/lB7Gb0hNumOCV+CDEK6YaOJ+Ch6mQVm4+8iL7hPdDZCI2VkXlRIBjAIQlpIQatsr6NTr/JX7o+hLPXA64yvxLJTqKHSEi6obO/dT8tvhbW7Vg3PDVsazZC69HQRv+bvg1GyeyJfOyy6fz2lUO8sq8p5p8vktf83AzcjugkstuhMS834wzv6EHV4MKPWX93pPQrGQ3ddQXDSWlN0YanlrsQw0g3dNZsXMNf9/4VgB+8/gPW/POD6HXbQA/VVw94IuN+mycIQLqskBZiUObnZmD3z2eSJw1ME9ME03AwI61Q4ocQo4xu6Ny28TYMDN5sfJO7Nn+RNd696IQyZqF50Zy2LTg0SSkIMVjhuZyzYxrzfNb3T9MEh+qS+ZVIehI9REIqryunodOqm2tiDk8N24YKCHRF7+tn07fB+PKqucyclMoX/7KTVk9gWM4hks/ygmyK8zNJCSWlVQWK8zNZXpDdvw+YVACONKh7s9/nDNcVXLtsLeePO59xjnHDU8tdiGFUXlfOrqZdBAxrvPUEPVS0H6Jc69XINjTuR1ZISw1pIQbFildZXNMwF5tpYnqnM12/jT+961GJH0KMMuEYGdZl+Klw2Ch3d9ePxt9FrmefrJAWYgjCc7mZSiPfaToJwDhjMT8uXSvzK5H0JHqIhFTVXIUvvIItJOY1bIfQ9G0w3A6N+z9QTGO7j289VTks5xDJR1MVNty6lAduXsxF07MAeODmxf3vdK5qkLt4QAlp67wapfmlvL/g/TT7mmnsOkfNaiFGmT5roZtB9qSkRh8YGvfbvbJCWoihCMerS8+fgtuEhRPm8o9bbsNhk98pIUabquYqvEFv1D6vorDH6eje4UjhgG2GJKSFGIJwbCx0NOJXrN+le678MFdOWy7JaJH0JHqIhDQiNWzDTd8cPZITEwv61fRtsBblZ3LHlbN4cnsd9/57D7/YVMOmquPohnnuN4sxS1MVVhRO5uvXF2KYsGnPAJPDeRdYK/+DvnMf20vxpGIA7tt23/DVchdiGPQdR9zMzZjR3ezTYTX71M+/mi0HrFUrb9e1ypgsxCBpqsL0nEwUTE4ZNZTXvSRxQ4hRqDCrEKfmjNrnUlTm+vzWhiMVM28JG/0LaWzzynxFiCHQVIVp1FHutr6XHmjdJ7FRjAmSkBYJKVzD1qFad+ld2jDUWAo3fbvpUbjii2Bzw/jp/a6zO1ifWn4+qU6Nhzbv5/6Ne7nz8e2sfmSrfMkT57QwbxxTx7v5165jA3vjlAtA98O/vxzpmt4fuqHz0zd/CsDzh58fnlruQgyTcBxRQ6tR3Da3FUc+/C+Ydim4xsFNj6J/+G+s/u02Nmw5BMB3n66SMVmIQdKDfr5y4p+0qyr13v0SN4QYpUrySpgzfk5k221zU5R9ASUeL8y8Cv29j/AR35epafJSe8oj8xUhhkAP+tmc8ya/HD8OgN++/VuJjWJMkIS0SEjhGrZfufgrALxn9nuGp8aSqkHBKljxdbj4E7D7H3DqUGzP0csr+5owQl/mTKDLr7OjtoWyaimJIM5OURSuWziFV/Y10drVzzrkhg5bH7L+/uZvI13T+5OULq8r5+2mtyPbw1LLXYhhEo4j0zOmMzVtKmuXhWr12RxWXfXMaVCwirKak+yobcGvW+OyJyBjshCDYuiUP3YtlYFmTMUqKyVxQ4jRSVM1vrb0awBcO+NaK0Yu+wkawOyVlJkXsP1oO+H8s8xXhBgkQ+flx67lsCuIL1Ry0af7JDaKMUES0iJhaarG++a8j4nuibT724e/xtLST4GiwpZ1w3qayvo2vIHoploev87u+rZhPa9IDtcsnEJAN9lYdbx/b6jZCMd7NOoMdU2nZuM539pnDd5Y13IXYhhpqoaqqBRkFVCaX9odR3xt4LRWqVTWt+HxR9+gkTFZiEGo2UhV20E8SnSPA2/QI3FDiFEo3PT3Xee/y4qRZmh+otklNgoRKzUb2dMqsVGMTZKQFglNURQuyL6AN48PrCHboIzLg4Xvh+0boKt52E4zPzcDtyM6ue52aMzLzRi2c4rksWjqOPIyB1C2o6EC/F3R+/xdVk3pcxiRWu5CDLN2fzvpjvTond42cFljrozJQsRIQwWFXZ24zehH+l2KTeKGEKNQuIG8Qws1Mgw3lLc5JTYKESsNFcz1SGwUY5MkpEXCW5y9mIbOBta+sXb4m6pddicEuuCN3wzbKZYXZFOcn0mKQyN8n3Sc287yguxhO6dIHoqicO3CHF6uOUGrpx9lO3KKwJESvc+RAjkLz/nWcA3ecFJaQYl9LXchhpFu6LR4WzjQciA6fvjawGklqcNjshZ6jDLFoVGcnyljshADlVNEia6y0OdDM00wTdyGSVH6dIkbQowyuqGz7fg2AHY37bbiox5qaKg5IrExPFeR2CjEIOUUcXnQio0uw3oKwWFKbBRjgySkRULTDZ1/HfwXAL/f/fvhb44zeR7MfgdsXQ8Bz7mPHwRNVdhw61IeuHkxn185h9I5k2ho9VJ1TB6BE/0TLtuxqT9lO2avhLwlYE+1thXN2p698pxvDdfgXbtsLVdPuxoTk/+36P8Nf/kcIWJAN3Ru23gbPsOq0xcVP3xt4LRWeYXH5ILJ6eRkuHjg5sVsuHVpJEEthOin2SvR8paw/mQHV3V2oQL3qpNZf8OfJW4IMYrohs6ajWt4dNejADy440ErPobnPpo9EhvTXTYW5o2T2CjEYM1eiZ6zmHXHmvjuiZMAXKOkSWwUY4IkpEVCK68rZ3/L/sj2iDTHuewz0NUEz90Nm++D6mf71QBuIDRVYUXhZO5cMZtf3LyYCWlOvvbkLulcLfplcX4mUzKc/O7VQ/xiUw2bqo6f+d+OqsHqJ+F9j8LUi0FRrL/38wuQpmqU5pfy/ZLvk2JL4an9T8Xwv0SI4VNeV86upu7SNJH4UbsZPK3QWBkZ3zVVwW5TmZOTzorCyTLhFmIwwvHm3Q9zoc+HoSi0LXoQVHu8r0wI0UM4PvoNa0W0V/da8fHYVuuAPf+C6mfRMFBVhQumZUpsFGKwVI0j1z7Gm8ZcrvBquBQHaXPfYzXZFiLJSUJaJLS4NFWbdik40mHbo/DiD+CJW2DDjTFPSoeNc9v5+vWFVBxt5Q+vHR6Wc4jkYpiAorDzaCv3b9zLnY9vZ/UjW8+elC5YBdf8CIwg7HlmwOdMsafwjunv4LlDz9EV6Dr3G4SIs6rmKrxBb9Q+b9DLnhe+ARhw+NWo8b3dGyDdZYvPxQqRJHRUVm/JITVo/S599emtZ49PQogRd8b51ZsPWxtvPxGJj3owiF2TlIIQg6UbJnf97W12mrOw6V48vgyerqyWuCjGBIkeIqHFpanavudDNdRM64+/E+q2Qc3GYTvluxblcsXsiax9rpqGVu+53yDGtLLqRk51WqtaTKDLr7OjtoWy6sazvzH3ApgwC3b9ZVDnfdf576Ir2MXd5XcPfz13IYaoMKsQp+aM2udS7cxtPtK9o8f43uYJkiEJaSGGpKy6kR21LRC0ehfo6S+y4+SrvLCnn414hRDDrs/5lWpn7qnw72n3/OdS4y1skpAWYtDKqhvZ09BOgzkemxJEMaDF2McvX3tK5lIi6Un0EAkt3FTNoVqPtDg15/A3VWuo6G7qEebvgoZdfR8fA4qi8N13L8CvG3zn6cphO49IDpX1bfiCRtQ+j19nd/056pArCiz8ABx6GVqPDuicuqGzfud6FBSeP/L88NdzF2KISvJKmDFuBmA15HTb3BQ5sihp7/V7Ehrf270BMlxSWkCIoaisb8PjD/DbLOt3yT7uLdTsx/hxxRclXggxSoTnV/ZQOZ1IfOxojzrO9HcxxzyEQ5NSHUIMVmV9G76AQYOZyZqcSeA8CbYWfrvvezKXEklPEtIioYWbqn314q8C8N7Z72X9yvXD2wAgpwgcKdH7HCmQs3D4zglMn5jKZ66axb92NfDinnOsdBVj2vzcDNyO6N8Bt0NjXm7Gud+88H3Wz11/HdA5w/UGTazHy0aknrsQQ6CpGp9c+EkAPlDwAdYuW8v6RZ9Ds7miD3SkEMiejy9oSMkOIYZofm4G7swajjqtWKEooGh+mgI1Ei+EGCXC86urz7sagHuX3RuKj9FPFWFPYbd5npTsEGII5udm4LKrHEjpYJfTCYqJokDQ9MpcSiQ9iR4i4Wmqxk1zbiLdno5hGsPfjXb2SshbAvbQo2yq3dqevXJ4zwvctux8ZmWncc/f36bLHxz284nEtLwgm+L8TByhCYLLrlKcn8nyguxzv3nC+ZB7IWx7ZEBNO+NSz12IIeoMdgLwsfkfozS/FG3OO2HirNCrCjhSIW8JrXnLAchwywppIYZieUE2uZOa8PdaUBkwfBIvhBhFNFUjJzUHu2rnyvwrrfiYNTP0qhUfjdwLKTOKsdskpSDEYC0vyGbh1HGccnXiUaKDo8ylRLKT6CGSgqIoFGQV8Nqx13h458PDW7823CX+ff8LWeeDMw3+6y/W/mHmsKl8/z0LqGvx8PNNNcN+PpGYNFVhw61L+eF7rVX71xflsuHWpf3rfm7o4GuFliMDatrZV71Bp+Yc3nruQgyBbuhsb9wOQMWJCitmqBqUfM464OJPwk2PwuonafNZJXBkhbQQQ6NhcI/tdVLM6LJSw97/QwgxILqhc6DlAAqKNa8CuPx/rBeXroGbHqXjA3/BQMXWn++XQog+aarCho8t4dbAdtxmdCNDiY0i2UlCWiQF3dA52n6Uw22HWbdj3fDXr1U1KFgF7/gueE7B/k3Dc54+LJ05gfdfOJXfvHSA3716kF9sqmFT1XHpxCuiaKrCTRdOpWByOg2t3v4lo8FqztlWH9rof9POcL1Bt82NgnUul801vPXchRgk3dBZs3ENT+1/CoBvb/l2d8zwdVgHXf5ZKFiFjsoLoTJJB090ylgrxFDUbOSKut0s9PmwmSaYJm7DpCglT+KFEKNEOEaW15XjN/zd8yrdZx1wyaehYBXe0DTr1f1NMhcRYgich17gv7xHWOjz4TKsG7Z2U2KjSH6SkBZJobyunGZvMwAm5sjVr539TkifAm/+dnjP08tdq+aiKArf/udu7t+4lzsf387qR7bKF0FxmitmT+T1Q814/P28OdNQAYHo0hv9adoZrje4dtlabi++nRvOv4EWXwu7moav2acQgxWueR40rNJHUTHDF2pq6MxAN0xWP7KVtc9VA/Crlw7IWCvEUDRUoPm7WN9wgve0dYCicHdTM+vHXzL8JdeEEP0SjpG6aX13jMTIFisWYnOiGya3P/YWAC/sOSFzESGGoqGCNMXH+oYTrG1swmYYXNblkdgokp4kpEVSqGquImAEovaNSM0lzQaLV1urR1tqh/dcPVQcbUFVFAwTTKDLr7OjtoWyaml2KKJdMWcS/qDB64ea+/eGITTt1FSN0vxS1ixawz1L72GCawI/f+vnmKZMTsToctaa5942rPqYaZRVN7KjtgVf0AgdY8hYK8RQhGKMBqzq6gIgW7WjTVkU3+sSQkScMUZ2NVgbNidl1Y1U1rdGXpe5iBBDkFOEFycasNzjZU4gQECzSWwUSU8S0iIpFGYV4rK5ovaNWM2lC1ZbP9/6/fCfK6Syvo2AHl1/0ePX2V3fNmLXIBLDxdOzcNhUXt57on9viDTtDCWltcE17Uyxp7Bm0Rq2Hd/G+p3rh7+2uxAD0FfN80jM8LWBMwNUlcr6ttOeLpCxVogh6NEYenrAWkiwYeJkNrudEh+EGCXOGCPtGdaG5qSyvg1vQOYiQsTE7JXssxegh9Jz03Wocrl42HNQ5k8iqUlCWiSFkrwSiiYWRbbdNjdFE4tGpuZS5jSYdTW88Wt48UdQ/ew5G8AN1fzcDNyO6Md33A6NebkZw3pekXjcDo2Lp2fxck1T/94Qadr5W6sczbjzrO1BPC524/k34tAcrNu5bmRquwvRT+Ga52roa1AkZky5FBqrABOqn2V+TqqMtULEUijG6Nf/jLsnTQATXsbDXS9/ReKDEKNE3zFyISVtoWTzgTLm56TitEenEiQ+CjFIqsZPc+5lp20RuiONivFTOIXBup0PyfxJJDVJSIukEK5fOyNjBnlpeaxdtpb1K9ePTM0lQ4f2equ54eYfwRO3wIYbhzUpvbwgm+L8TFJ6JErm5qSzvCB72M4pEtcVsydSfbyd423e/r0h3LTzoluheR909nN1dS9bG7aCadV1H9Ha7kKcQzhm5KTmMCNjhhUzVqxDe+x9cChUR/qJW7hq2/9j8dR07JrVqDPFoVGcnyljrRBDoWqUZ2azy+kk1ANX4oMQo0g4Rual53Fe+nmsveJe1jc0olX9wzrgb5/gqm3/j7nZ1tN0ChIfhRiqNLeTvcp5lDtUGgNWg22ZP4lkJwlpkTQ0VWPexHkYpkFpfunINQCo2QjNh0IbJvg7oW6btX+YaKrChluX8sDNi1mzbCYOTWVyhhNNVYbtnCJxXTF7EkD/V0mHFVxr/dz77KDOG7fa7kL0g6ZqGBgsnLTQihn7X7DG7lATJ/ydKHXb+P2yNkrnTMKhqTxw82I23LpUxlohhqiqZS8eJfr3SOKDEKOHpmrYVTtzsuZQ6vGh1b0J4e90ofh436LjALz3gjyJj0IMUbrLzkndTZUNmT+JMUMS0iKp5Kfn09DZgF/3j9xJGyog0BW9z98FDbuG9bSaqrCicDJfvbaQ26+cxb/fPs4b/W1cJ8aUuTnpTExz8nLNAFc6Z8+zStJU/3tQ5z1rnV4hRoE2XxsZjtDjxQ0V1tjdk78L7fjbZKY4mJDmYEXhZJlsCxEDhVmFuHr1u5X4IMTo4g16re9xZ4iPrpO7AXjfhfkSH4UYogy3jcaAm0KfH5fmjHpN4qNIVpKQFkklLy0PE5OfbvvpyDUACHWMj+JIgZyFw3/ukE8um0FOhovvPb0bwzDP/QYxpqiqQsmsCbxQ1cjPn9/Lpqrj6P35d6IoUHAdHCizVv4PULgGYTgprSrqyNV2F+IcfEEfXcEu9p7aa8WLyQvOOJa3ewOku2zxuVAhktClUy5ntl/FFuqJ5tJcEh+EGEV0Q6fV18qBlgNsdtrQ+4iPrZmF1l9tkogWYih0w+REm49mPYUSj5eF42ahhGpajWhvLCFGmCSkRdLQDZ3H9zwOwGN7Hhu5BgDhjvGOVGtbUa3t2SuH97w9pDhsfOmdBew82spTO+tH7LwiMeiGSWV9G+2+ID97voY7H9/O6ke29i8pXXANBL2w/8UBnzdcg3DtsrVcNPkiDNPga5d8beTK6QhxBrqhs2bjGgBeb3jdiheHn0DPu7D7IEdqZCxv9wZJd9njdLVCJBfdMPnYb7expi6Nd5+y4sE43yrWrXhY4oMQo0A4RnYGO3n75Nvctf/PrMnLQ1dDN2ZD8fH4pCusTU1+b4UYLN0wWf3IVp6uqKeVVDRg6uGrmJtVyETXxJHtjSXECJOEtEga5XXlHGw5GNkesQYAoY7x3PQozLwSTAOuv9/aP4JuXJzHgrwM7nt2D96AdOEV3cqqGzl6ygOACXT5dXbUtlBW3XjuN593GTgz4PVfw+b7oPrZATXs1FSN0vxS7iu9D7tq5/Gqxwf5XyFE7JTXlVN5sjKybcWLXZRf+XlQbTDtUmtMX/0kqFooIS0rpIWIhbLqRipqm3GZQW7qsEqNNTTbeLnmZJyvTAgBVozc1dRderAr2EWFTaF86nxImRiJj37TWsFplxXSQgxaWXUjO2pb8Osmbab1JMKSxr9znj+NjkAHV0y9QpLRImlJQlokjarmKry6N2rfiDUAUDUoWAXv+oW1vfvvw3/O3pegKtxz3TzqW708Un7w3G8QY0ZlfdtpNyk8fp3d9W3nfrOigs0FB8vgxR/AE7fAhhsHlJQGmOieyLUzruUf+/9Bq691QO8VItaqmqvw6b6ofd6glz0nd4MRtJ5wKVgVubFoleyQFdJCxMLuulOsN7/HYnUfBXorimlyve0pqupOxfvShBBYMdIT9ETt8wa97LHbYFxeJD4GdKvmjl2TlIIQg1VZ34bHr6NicI/tDwBcp5Rz4eFNeHUvDe11cb5CIYaPRA+RNEZFA7XMaZC/FHY9MXLn7OGSmRN4x7zJrHtxH43t3nO/QYwJ83MzcDui76y7HRrzcjPO/eaajeANJ5BNq5Z03TZr/wCtnrcaT9DDfW/cx8M7Hx65Ou9C9FKYVYhDc0Ttc9lczE2bam04o383ZIW0ELFzhbKDYnU/dkVHUyDDMNib2kmq9y8SE4QYBQqzCnHZXFH7XDYXcw0VejRb8wethLRDEtJCDFp4nrZc3UGhegQAVYGZoUaiD778dZkziaQl0UMkjXADtbg3AFjwPmishOO7R/a8IV+9thBf0OD+jXvjcn4x+iwvyKY4PxO33Rry7ZpCcX4mywuyz/3mhgrQ/dH7/F3QsKvv489iVuYsMhwZPLX/KdbtWDdydd6F6KUkr4T89HwAFJTueJEZuoEpCWkhhk2Rdhi34kMH1uRMol1VqXHYeLj5bxIThBgFSvJKKBhfENmOxEjdBrYeCenQCmmHTVIKQgxWeJ5WbDuCC2vOpQO/zBwHwD+b3pQ5k0haEj1E0gg3UJs5biZ5aXnxawAw/z2gaPD2X0f2vCEzJqby0Uun8+c3aqk61o+SDCLpaarChluX8uB/XcCUcS5yMlxsuHUpmtqPmn85RdBHZ3VyFg74OsrryiNlEkzMkavzLkQvmqrxwYIPAvCx+R/rjhf+TusAV3dC2hvQ8esGGVKyQ4iYUKcsQrGnUO52scvpxFAUUBS6zKDEBCFGAU3VuPuSuwFYNX1Vd4wM+qwybiGBoJTsEGKowvO0Zcuuwov19F6528UeZ/eTfDJnEslKoodIKpqqMX3cdNw2N6X5pfFpAJCWDTNL4e0nwDRH/vzAZ1bMIt1l5wf/qsKM0zWI0UVTFVYUTuaTV8yk9pSHQyc7+/fG2Sshb0n3ihib09qevXLA11DVXIW/12rrEavzLkQvHYEOAD5d/OnueOEL3cTrsUK63RsEkBXSQsTK7JUoU5ew25WCR4m+MSoxQYjRIfx97Ybzb+iOkUFf1ArpgG7NMWSFtBBDo6kKxVd9gCqtAAOFKqdD4qMYEyR6iKSiGzqeoIe6jrr41lqa/144dQie/h+ofnbADeCGKjPFwWdXzOblmiZ+tqmGX2yqYVPVcXRDktNj3XVFU1AUeHrnsf69QdVg9ZNWR3WbG3IvtLYHcbNnVNR5FwIrVlQ2VaIpGluPbbVihaHDgc3WAcd3gaGjGyYbdzcAcKS5S8ZQIWIhFFdmFX4Qd6+b5hIThIg/3dDZcmwLANXN1d0xsuskNB+A6mfRg8HIk5jlNSckPgoxVKrG2kk/ZL9tNoVKKu4e9dpB4qNITpKQFklDN3TWbFzD6w2v4wl64ldrydBh5+PW39/8X3jiFthw44gnpW++eBoum8ovnq/h/o17ufPx7ax+ZKt8YRzjJme4uGh6Fk9X1Pf/TaoGhdfD4g9D/VtWY8NBCNd575mUnjlu5sjXeRdjWjhWvFj7Irqph2LFbegb3gNbfmkd9Py3MTfcyEd/8yrfedrqB7Bhy2EZQ4WIFVXjysu/yEKfD4dp3eC0q/b49P4QQkSEY+Svdv4KgF9V/Ko7RnYch8bdmH+9har7VvBMxVEAPv9/OyU+ChEDk8alUMUMSnwBFmYvxqZaT+fFrTeWEMNMEtIiaZTXlbOraRdBw3q8Om61lmo2wrEd3dv+TqjbZu0fQa/ub8KEyJ8uv86O2hbKqhtH9DrE6HND0RRqGjuobmgf2BuLPgRBL1Q9Najzhuu8r122ltsW3kaGIwPDNAb1WUIMVjhW6KZ1k7Ar2EVF4w7KT1ZAqMY5gS702jfIOFqGN2D9G/UFDRlDhYghW8oEHmg4xX975pBiS2Fx9uL49P4QQkSEY6TfsEp2eHVvd4zESjgrgU5m+Kq43NwOyBxDiFjJyXBx2J+B1tXE+isf4L/m/hcAn7/w8xIfRVKShLRIGlXNVXiCnqh9cam11FAB/q7off4uaNg1opdRWd+GPxid7PP4dXbXS6PDsW7VgimoCgNbJQ0wdQlknQ87/zToc2uqRml+KXdecCdfv+TrVDVX8efqPw/684QYqD5jheFnjxq9sksNepilH4zaJ2OoEDGkKLSr47mgw2BJzhKavc0y2RYizvobI134maccjmxLfBRi6CZnuKjVMwHQuppYNX0VANkp2RIfRVKShLRIGqOmPm1OEThSovc5UiBn4YhexvzcDNyO6MDldmjMy804wzvEWDEp3cll50/k6YpjA2t6qShQ9EE4VA6tR4d8He+c/k4unXIpD2x/gBNdJ4b8eUL0R5+xQnUw14huHmPY3OzTZkTtkzFUiNhqt00gxddEYVYhB1oPnJYIE0KMrP7GSC8OdpvnRbYlPgoxdJPHuWg0x1sb7Q1My5gGQG17bRyvSojhIwlpkTTC9WkdqgMAl+aKT62l2Sshbwk4UkM7VGt79soRvYzlBdkU52eSEkpKK0BxfibLC7JH9DrE6HR90RQONnVSOdDVLEUfAEyo+L8hX4OiKNx9yd34gj6+tPlLPLzz4fg2IxVjQjhWKFiTa7fNTVF2MSUTiiBUqw9HKlr+RbRNXY5dCx1n12QMFSLGPM6JZOgnKcgqwDAN7nv9PokDQsRROEbaVTvQM0Z2L6wx7akcdBZSzmIAUhwSH4WIhcnpTo5HEtLHSLOnkWJL4d8H/y2xUSQlSUiLpBGuT/tfhVatpS9e9MX41FoKdY/npkdh5pWAAe95yNo/gjRVYcOtS3ng5sXcUDQFE/jAknw0VTnne0XyW7UgB5uq8M+Blu3ImgH5l0DFn2Egq6vPYGraVLJTs3mz8U1+ueOX8WtGKsaMcKxwaA4WTVrE2mVrWb/yV2ir/w65F0DKRLjpUZTVT/L7T1zGqgU5APzi5mI23LpUxlAhYijgzmaccYrfV/4egL/W/FXigBBxFI6RpVNL0RStO0Z+8I/WAedfhfK+Rym8axOLz5vAOLedB25eLPFRiBjIGeeKJKT1tnrWbFyDN+il8mSlxEaRlCQhLZKKpmrMnzgfgAuzL4xfrSVVg4JV8I7vWtsHXozLZWiqworCyfz8Q4uZlZ3GQ2X7MaQDtgAyUxyUzJ7IMwMt2wFQ9H44sQee+TxUPwtD+GJUXldOs7c5sh23ZqRiTDEw8Ok+SvJKKM0vtWKFqlnllbJmWOO3qqGpCpPSXKQ5bayclyOTbSFiydBJVzzsTglQfXJ3ZLfEASHiS1M1JrgnkO5I746ResB6cc41ULAKzWYjK9XB5AwnKwonS3wUIgYmZ7hoJQUdlfLdf2JX43YMrJ5QEhtFMpKEtEg6mmIlocODd1xNXgBpObDv+bhehqoq3H7l+VQfb+f5quNxvRYxely7cApHT3n42pO72FR1HL0/NysMHd5+wvr7tkfhiVtgw42DTkpXNVfhDXqj9sWlGakYU9p8Vqmacc5x0S9428AVva/dGyDdZRupSxNibDB02HAjM05sosrpwKv7ol6WOCBEfHmCHlJsPXrihL+r2ZyRXb6ggcMm6QQhYsWumPzBeR8KBlVt+/FIbBRJTiKISCq6oVPVVAXAGw1vxP+RFkWBWVfD/hdAD8b1Um4oymVaVgq/fHHfwFfEiqSjGyZPvGk1Jnz89VrufHw7qx/Zeu6kdM1GOLaze9vfCXXbrP2D0FfzHKfmHPlmpGLM0A2d549YNwnr2+uj44SvDZzRTZnavUFJSAsRazUbMY9uQzP8FPr8uHt9L4lLU2ohBGDFycNth/Hq3u66teGEtL37O5svqOO0xelpVCGSjG6Y/HTdgxRRgwoSG8WYIAlpkTR0Q2fNxjX8bvfvAPjZmz8bHXWWZl8N3lYraRdHNk3lU8vPZ+fRVl6uaYrrtYj4K6tuZFdda2S7y6+zo7aFsurGs7+xoQL8XdH7/F3QsGtQ1xFunuO2uaOazI14M1IxJoTjxNo31gLwePXj0XHC2wauXglpX4B0l32kL1WI5NZQAQErlpR4vCz0+XCEbojaVWd8mlILISJxclfTLpq9zd11a/2d1gE2V+RYf9DAKSukhYiJsupGnE2VuPAD3bHRbVhPfdsUm8RGkXQkgoikUV5Xzq6mXfgNaxD36t7RUWdp5pWgaINeQRpL770gj5wMFw++uC/elyLirLK+DY8/+maNx6+zu77t7G/MKbLq7PbkSIGchX0ffw7h5jlrl63l9uLbueH8GzjlO8WWY1sG9XlCnE04TvhCj0D6dF90nJAV0kKMjJwiAqqV2NKA9Q0nuKO5HYDClGvi05RaCBGJk4bZq27t8TesA3okpKVkhxCxU1nfxs7gNLw4gO7Y+IOmdvKdE5iUMklio0g6EkFE0qhqrsIT9ETtGxV1ltyZkH8x7It/Qtpp01hTOpPXDzaz9cDJeF+OiKP5uRm4HdFfaNwOjXm5GWd4R8jslZC3BByp3fsmzLb2D5KmapTml7Jm0Rq+dem3mJ4xnR9u/SF+3T/ozxSiL2eNE0G/9Uhy7xXS3qCskBYi1mavpGNiMZ2mE9MEw9SY0ZKLaWpMSnfJhFuIODljnGzdb23YeySkA7JCWohYmZ+bwVbbhWw3ZuEzrYUQPtPJBanzuGHuB2jobKAz2BnnqxQitiSCiKTRVy3aUVNn6fyrrLq7//kGVD876AZwsfChi6YxMc0hq6THuOUF2RTnZ5ISSkqrChTnZ7K8IPvsb1Q1WP0k3PQoLPsS2FJg/Axrfww4NAdfvfirHGk/wjdf/SYP73y4u36hEEN01jjhOWXtqH09apyWpoZCDANVY9xtT7NuwtdoNMdRaZzHHcrdOMxMajpelXFfiDg5Y5zsDD1BV78jEh/9uiE1pIWIkeUF2RTlZ3GL/jXWBd8FwJPjVjPutqcpzl6MickPt/5Q4qNIKpKQFkkjXIvWrlor2dw29+ios2TosPdZ6++v/hyeuAU23Bi3pLTboXFryUxermliZ21LXK5BxJ+mKmy4dSkP3LyYS2ZkYZrw4M0XoKnKud+salCwCq66By66Baqegta6mF3b0ilLGe8cz9MHnmbdjnXd9Qvly5cYonCcsKlWgjkSJ6ZcCn/+iHVQzX+ixuk2KdkhxLDQbDY+f8dn2aXMIcMRZE7x/2FoLRxpPyLjvhBxEo6TYW6bm6KgSclb/2ftePEHkfjoC+hSskOIGAnPza5fNJWnjUsBuPnqS0BV+FXFrwB4+sDTEh9FUpEIIpJGuBbtlflXoqBw37L7RkedpZqNcKJH2RB/p9XgMI41pT9yyTTGue2ySnqM01SFFYWT+dKqAkxgy2DKuFz8ScCEbY/E7LrK68ojj4uamN31C+NdD14kvHCcuCTnElyai7XL1lpxYv8L0Y05Q+O0f89z+IMGGVKyQ4hhoakKzfYcDjhbqPNUo5vWBFvGfSHiQ1M1Hr76YVRULpx8IWvP/xDr6+rQglbvBYKeyDzGWiEt6QQhYkVTFYqnZVJvTgBAbT1CeV05u0/ujhwj8VEkE4kgIqloqsZ413jGOcexPH95/JPRYHWS93dF7/N3RSc/Rli6y87HLpvOxt3H+d2rB/nFpho2VR1HD3W4F2PLoqmZZLhsbN7bOPA3j58OBdfCtt9CwHPOw/ujqrkq0nQubFTUgxdJQVM1Uh2p5KTmUJpfasWJhgqrfnQPpr+LmopXAahv8cj4KMQwaXHksM/B6OwDIsQYFDSDGBiU5JVQ6gui9TGPMY5V0OkNsvtYm8whhIihNKcNDy509wRoOTJ6+2QJEQOSkBZJRTd09rXswzCN0VNfKacIHCnR+xwpkLOw7+NHyEcvPQ9Vge88XcX9G/dy5+PbWf3IVvlCOQbZNJUr5kxi894TmOYg/v+/dA14mmHXX2NyPaO6HrxIeLqhc7D1IN6gtztO5BSBzRF1nE9x8mCl1bzpL28elfFRiGHS5syl0OfHrUX/Dsq4L0R8tPpaAdjeuJ3NTht6r3mMaU/hJxUOPEGD7UdaZA4hRAylOUMNDdOmQssRmReJpCYJaZE0dENnzcY1bG/cTpu/bfTUV5q9EvKWgC3UldrmtLZnr4zrZe2obUFVFHTDxAS6/Do7alsoqx7EKlmR8ErnTOJ4m489De0Df/P0KyB7Pmx9GAaT0O4lXL+w55evie6J8a8HLxJeOE7UnKqhoauhO06cfxVknhc6SiFoS2G7MYvnAosA8AcNGR+FGCZdKXmUeLwsTMmLjPuaoo2OPiBCjDG6ofOFzV8A4KWjL3HX/j+zJi8PPXzDyJ7CqfFF/K5pTuQ9MocQInbSQn1LulLyoKU2Mi9yak4AnJpT4qNIGpKQFkmjvK6cXU27MEwDGEX1lVQNVj8JN64HFCi4ztqOczmRyvq201YyePw6u+vb4nRFIp6Wz5kEQFn1iYG/WVGsVdLH34by+2HzfVD97KAbd4br/K5dtpY7iu9gwcQFnOg6QZOnaVCfJ0RYOE5Yt+F6xIljW2DxauugKz7Pv+Z8n4/4voLR42uSjI9CDI9AWg4asL5DYe35HyIvNZf89PzR0QdEiDGmvK6c6ubqyHZXsIsKm0L57CusHTc9wmNzfkanX+YQQgyHdKfVt6TDmQOnDqG99GPWn/de7rrwiwB8sOCDEh9F0pCEtEgao7q+kqrB/PdA9jzwtcU9GQ0wPzcDtyP6OtwOjXm5GXG6IhFP2RkuCqdkDH51y4KbQLXBC9+zOrA/cUukC/tgaKpGaX4paxat4b5l92GYBj9986eDuzYhQs4aJ/wdgAJX3kPqwutwOqIbGcr4KMQwMHQ+Xv9tTBO0Ay9S+sKPKe3soLGrEUVR4n11Qow5Z+zj4bBZT3vOvZZ5eeNlDiHEMElz2VAxmFD3AhgBKPsh2t8+wXtefwxVUUm1p0oyWiQNSUiLpJEQ9ZXyFkPdWzEpazBUywuyKc7PxGW3hgGHplCcn8nyguw4X5mIl+UFk3jz8CnavYGBv/lQOaCAqQMm+DsjXdiHKj89n48v+Dj/OvgvtjVsG/LnibGrMKsQV7h8UkgkTnhbwZkBqhoZHx2aNT667aqMj0IMh5qNTO3cTST37O9k1ql6uoJdHOs8FtdLE2IsKswqxK5G35B12VzMVdxgt+ZZywuymd8j+Zzi0CRGChEjaU4by9UduD3hGGjNqxx1bzLFMY4j7Ufien1CxJIkpEXSKMkriUo+u23u0VdfKfcCq/lby+F4XwmaqrDh1qU8ePNiJqc7mZju5Pe3XIymyoqksWr5nEkEDZNX9p0c+JsbKsAIRu/zd0HDrphc260LbyUnJYe7y+9m3Y51o6dpqUgoJXklzB1/hjjhbQWXNcEOj483XpAHwL03LWLDrUtlfBQi1hoqsBveqF3nezoBeOCtB2SsF2KEleSVkJ+eD4CC0h0nlTSwW80NNVVh7fusHgvvnD+ZB25eLDFSiBhJd9mYrxxCM/xR+3V/F2kGbGvYJrFRJA1JSIukoakan73gswBcP/N61i5bO/rqK+VdYP2seyu+1xGiqQpXz8vhC+8ooL7Fy5uHT8X7kkQcXXDeeNKdNjbvHUQd6Zwi6NWFHUcK5CyMybU5VAfpjnTqO+t5aOdDo6dpqUgomqrxlaVfAeCa6ddExwlvG7jG9ThWYco4azX1dUVTZKItxHDIKSKodT/dpgMPTMgC4JmDz8hYL8QI01SNDxR8AICPL/h4d5wMersbtAPBUB+aaxdOYUXhZImRQsSI06ayhxkEVGdknw6smTKZ/YFWjncdl9gokoYkpEVSqe+sB+CTRZ+kNL90dCWjAbLng+aA+tGRkA67YVEuGS4bG16L/8ptET92TeXyWRPZXN2IOdCyMrNXQt4SCHWAxuaytmevjMm1ldeVU9dRF9keNU1LRcJp97cD8P6C90fHCW9rVEIaoN0bJNWhyURbiOEyeyWtWUX4TQ0TKE/PZLfTEXlZxnohRl5XsAuATy36VHecDHgiK6QBfEErEea0jbK5lhAJTlEU3nRcSG3K/Mi+8oxMdrmcBDEAiY0ieUhCWiSVo+1HAchLy4vzlZyBzWGtGK3bHu8rieJ2aLx/ST7Pvt1AY7v33G8QSeuKOROpb/Xyracq2VR1HN3oZ2Ja1WD1k3DTr62bLvmXWNsxuik0qpuWioTS4msBINOZGf1CuIZ0D+3eAOmu6FqaQogYUjV2X/U7/qxfiQJsnnY1nl6HyFgvxMjq8HdgU204te4VmgS6IjWkAXxBKzHmtEs6QYhY0g0TRbXxGdvX8TonYmTPp2rR+yQ2iqQkEUQkDd3QefP4m6TYUnit/rXR+wjLlGKr2VvZj6D6WRgl1/nhpdMIGiZ/fr023pci4kQ3TP72lrUK+XdbDnPn49tZ/cjWgSWl570bij5g/RsP+s79nn7qq2mpTbWNrqalYtTTDZ03Gt4AoOpkVXecMHToaIDW2qhxucMXJM1li9flCpH0dMPkx5v2UW5Y5Z1e2T8RxXREHTPqGlQLkcR0Q2fvqb3YFBsvHX3JipOGDu3HoON4JEb6AqGEtE3SCULEim6YrH5kK82dfiobuqj0TqSqRaNg9g2nzYMkNopkIBFEJAXd0FmzcQ2vH3udrmDX6K2rZOhwqByCXish/cQtsOHGUZGUnjkpjStmT+SPrx8hqBvxvhwRB2XVjVQda4tsd/l1dtS2UFbdOLAPWnQz+DtgzzMxu7aSvBIWTlyI2+ZGQUFVVHRDJz8jP2bnEMktHCf+VvM3AL639XtWnAj6rXG48wQcfztqXG73BkmXhLQQw6asupGa4+2cMK1yOTltaeiefOyKlZR2as7R16BaiCQVjpOv1r+KV/eG5lO3oW94DzTttZqyh2Kkz281XJOSHULETll1IztqWwgvBTpmZJLiO0GwY05kHgSgKqrERpEUJCEtkkJ5XTm7mnZhjPa6SjUbofVIaMMEf6e1krRmY1wvK+wjl5zHsVYvm/YMMAEpkkJlfRsef/TNEY9fZ3d92xnecQbTLoNx02Dn4zG7Nk3VWL9yPWuXreX24tv5zmXfIdWeytfLv07QCMbsPCJ5heNEwAgA4Al6rDix7UE4uq37wB7jcps3KCU7hBhGlfVteAMGTVgJ6UlKO52Hb6F0/J0oKFyZf+Xoa1AtRJIKx0ndtL4LdgW7qGjcQfnJCjBDi1VCMTLjaBkgK6SFiKXec7Hj5ngmcYo9xzoj86B5E+bh1Jw8dPVDEhtFwpMIIpJCwtSXbaiAQK8azf4uaNgVn+vpZcXcbKaMc/EHaW44Js3PzcDtiP5i43ZozMvNOMM7zkBVYdEH4cCL0N4Qs+vTVI3S/FLWLFrDu2e9m29c9g0qmir4za7fxOwcInmdMU4cf8uqjdlTaFy2akjLCmkhhks47jSFVkhPpBW3w871s65hzvg5tPnbZMItxAjpM04afvaovUq3+btwN+8GwCU1pIWImd5zseNmJmmKl4WT1Mg86EMFH8IT9FDbLmU2ReKTCCKSQmFWIQ4tAWoO5hSBIyV6nyPFanQ4Ctg0lf+6eBov1zRx4ERHvC9HjLDlBdkU52eSEvoipKkKxfmZLC/IHviHFX3IWk2z6y8xvspuq6av4rqZ1/HQjof4feXveXjnw2yu3Tz6SvWIUaGvOuQum4u5ky+IatQERMbldm+QdKckpIUYLuG404WLTtPJFFtbJO4smLiA7ce389DOh2RsF2IE9BknVQdzDSX6QEcKJ9PmAFKyQ4hYCsdEm2r9zrVoEwC4Iqc7/i2YtACAn7/1c4mNIuFJQlokhZK8ErJTrKSZgoLb5h6ddZVmr4S8JaCEvrw5Uq3t2Svje109fPDifGyqwmNbj5z7YJFUNFVhw61LeeDmxczPzcChKTz6sYvQVOXcb+5t4izr3/bOP8X+Qnv48kVfRlM1frztx6zbsW701o8XcReuQ65g/XuOxIkld0B2YegoJWpc7pAa0kIMq3DcmZjmoFXL4p3nqWy4dSlgsL1xOx7dw0M7HpKxXYgR0GeczC6mZEJR90GhGHk463JASnYIEUvhmPjexXkAvGfZEmt/p/XEqW7o/GjrjwB4ofYFiY0i4UkEEUlBUzVmjZvFJPckbi++nbXL1o7OmoOqBqufhNnvANUONz1ibY+i68xOd7FqQQ5/2VZ7Wj1hkfw0VWFF4WQ+s2I2noDBW0dODf7DFn3IahI3jCVpKk5UoCoqZuj/Rm39eBF34Trk453jmZs1tztO2Bxw9betgxbdDDc9CqufJGAqeAK61JAWYphpqsKUcW467ePJ0drQVIXyunLqO+oBZGwXYoSE46TL5qJoYlEoTv4K7cNWM2CmXxGJkV7dSlrLCmkhYktTFZbOtFZGTztvprUzVAKxvK6ct5vejhwrsVEkOklIi6RRebKSi6dczJpFayjNLx19yegwVYPzrwIjALkXjKpkdNjqS86jzRvknzvr430pIk6umD0Rh03l+d1DaHC54CZQbFD2Q9h8H1Q/CzG+g1/VXIVf90ftG5X148WooKkaHt3DxTkXR8cJf6hE0cWfhIJVoGp0eK1mmbJCWojhN96tousGHN8N1c9SdXI3Pt0XdYyM7UIMP0VR8Ok+Lsm9pDtOGqHvWbNXRmKkL2h9n3NKDWkhYi4rzSpFeiLUX4Gdj0diY0L0zRKinySCiISnGzr/qPkHjZ5G3Jo7MR5ZyQrd7Ww+EN/rOIOLZ2QxOzuVB1+s4efP72VT1XF0wzz3G0XSSHHYKJk1kY1VDZjmIP9/7xoH7nGw5xl48QfwxC2w4caYJqXPWBd4tNWPF3GnGzobD23EE/RwyncqOlZ4W62frnGhY02eq7RWo9Q2e2T8E2I4GTpfO3k3s4I10NUET9xC4c4nZGwXIg7afe0YpkFlU2V3fdpAKAFmt/rg6IZJ1bE2AF6uOSExUogYy0pxoGIw7fn/Z+3Y/4LERpGUJCEtEppu6KzZuIbvvPYdAP554J+JUUcpa4b1c5QmpA0TdAOONHv42fM13Pn4dlY/slW+cI4xVxdOprbZQ03jIBtc1mzsXnmKCf5OqNtm7Y+RcL1Dt83dXfNQc3N57uUxO4dIfOFY8bXyrwHw3MHnomOF15pY4xqHbpisfmQr3/pnJQCPbT0s458Qw6lmIzN8VdgI/T76Oymp283ClFxsqvWEwqjtDSJEEtENnTtfuBOAV+pf6a5P6wvFSHtKJEb+e5d10/azf9ohMVKIGMtKdbBc3UHGyZ3dO3vExnBS2q7aJTaKhCYJaZHQyuvK2dW0C3/oUTKf7kuMOkqZ06zGhqM0IV1W3UhDmxcAE+jy6+yobaGsegjlG0TCWVFoNQrduPv44D6goQKC0eU08HfFtKZ0uN7h2mVrub34dm44/waafc38+9C/Y3YOkfjCscKrW+Oa3/BHx4rwCmlnBmXVjeyobcEbMADwBQ0Z/4QYTg0V2A1v1C7N38X68Zfw8fkfB+BTiz41OnuDCJFEyuvKqWquimxH6tPWb7F22N2RGBkMJaBljiBE7E1IczBfOYSmR5fnCMfGtcvWkmZPo2hikcRGkdAkIS0SWlVzVWLWUdLsVlJ6lCakK+vbTmto6PHr7K5vi9MViXiYnOFi0dRxg09I5xSBIyV6nyMFchYO/eJ60FSN0vxS1ixaw3cv+y6Lsxfzg60/4FjHsZieRySuc8YKb4v1KLLNIeOfECMtpwhdc0Xvc6SgTVnEzXNvBqxVYDLhFmJ4VTVX9V27/dRea8ORKjFSiBGQ4rBRo84goPYdG0vzS7lkyiWc8JyQ2CgSmiSkRUIrzCrEZYseqBOmjlLWzFGbkJ6fm4HbER3c3A6NebkZcboiES9XF05mR20Lje3ecx/c2+yVkLckUnMQRbO2Z6+M7UX2oKka3y/5PoZpcPcrd2OYxrCdSySOc9Ya97ZG6kfL+CfECJu9kubMIrpMp7WtOSKxYlLKJCanTGZXU+yerBFC9K0wqxCH5oja57K5mJuSY23Y3RIjhRghlSlLOewqtGIiWPOpHvOo+RPnc6T9CK2+1jhepRBDIwlpkdBK8kqYmjYVAAUlsWoMjp8OJ/ZC2b1Q/WxMG70N1fKCbIrzM0kJfeHUVIXi/EyWF2TH+crESLt63mQAXqgaxKOYqgarn4T3/RamXQqmAdffb+0fRvnp+Xzl4q/wRsMbfOvVb/Hwzoe7G/OIMSlca9yu2oFe9WgNHZr2gu6H6mdZPnsCxfmZOLRQTXK7JuOfEMNJ1dh15f/ymcAdGIoGc95pxY5QrFgwYQGvN7wuY7kQw6zvedVCSlqbrQOOVURipKZaMTLFITFSiOGQmebmhxN/AEs/Ze24+ptRsTG8qGLtG2slNoqEJQlpkdA0VWPBxAW4NTefWvQp1i5bmxh1lAwdDpRBsAvKfghP3AIbbhw1SWlNVdhw61IeuHkx83MzcGgKv/nvJZEvn2LsmJuTTl6mm+erBlm2Q9WgYBW871FQbfD6r2J7gWdww8wbGO8cz5P7nmTdjnXdjXlGye+YGFnhWuNX5l+JgsK9y+61YgVYY+/RN6DrJDxxC9pj72XDx5dwfVEuAPd/cBEbbl0q458QwygzzcXzxoV40/Ktp2lC3+N0Q2dvy16aPE0ylgsxzDRV46Y5NwFwy4JbWHvFvaxvaER75efWAS98LxIjF+RmkJ3u5IGbF0uMFGIYZKU6ONmlw/x3WzsypkbFxt/s+g0A/9j/D4mNImFJQlokNNM0eaXuFUqmlvCp4k9Rml86+pPRADUboa0utGGCvxPqtln7RwlNVVhROJkvvrMAT8Dg1X0n431JIg4URWHlvMm8XNN0Ws3AAcnIhYXvh7c2QFdz7C7wDF6pfyXSwM7E7G7MM9obnopho6ka6Y50slxZXJl/pRUrajZaY2+4tEtoLNb2P092hguHprJqwRSZaAsxzDJTrKcXOtx50HI4sr+8rpzGLusJHRnLhRh+HYEOAO5YfAelHh9a3ZsQrisd9ERiZLrLztTxblYUTpYYKcQwmJDq4GSHH8bPsHb0io1VJ/toQCqxUSQYSUiLhLb31F4aPY1ckXdFvC9lYBoqIBjdNAR/FzSMvhqJl58/kXFuO8/skgZxY9XKeZPxBQ3K9zUN7YMuuwMCnfDmb2NzYWdR1VyFNxhd9zohGp6KYXXKe4rxrvHdOxoqrLG3p9BY3O4NkO6yjewFCjFGjXNbNTJbHFPgVPeku6q5Cr/ujzpWxnIhhk+br40UWwo21XbWGOkN6LjsCbAISIgElZXqoLnTD+7x4Eg/LTaetVm3EAlCEtIiYemGzu92/w4ATdES6xGVnCKwRzfYwpECOQvjcz1n4bCprJqfw8bdx/EGEuh/YxEzF543Hrdd5WfP72VT1XF0wxzcB02eD+evgK3rT78hE2N9NbFzas7EaHgqhoVu6BxqO4Qn6OmutZdTZI29PYXG4nZvkDRJSAsxItKc1u/atrZx4GlG91hNms7ZkFQIETO6obP31F5URbXi5OQFZ4yR3qAkpIUYLrph0tzlxxPQ+dfbDZjjp0WtkJbYKJKFJKRFQtINnTUb1/DM/mcA+P7W7ydW3aTZK2FKcfe2IzWqa+5oc13RFDp8QTbvPRHvSxEjTDdMbvnfN/DrJpX1bdz5+HZWP7J18Enpy+6EjuOw6y+xvdBewk3s3DY3CtajpKqisnTK0mE9rxidwjHjYOtB6jrqumvtnX+VNfaG9RiLO3xBWSEtxAjQDZNbf/cGAOVNqQDc/dun0Q0zMpZripX4Sqjm1UIkkHCc3HZ8Gx2BDitOHn4CPe9CCDUExt4dI30BA5ddUglCxJpumKx+ZCtP77SeTv7C/+3gzdYMzB4rpMOx0ak5AXCoDomNIiFJFBEJqbyunIqmCgysup8JVzdJ1WD1362/T18GNz0a1TV3tLn0/AmMT7HzTIWU7Rhryqob2VHbEklAd/l1dtS2UFbdOLgPnLkcJi+EVx8Ac5BJ7X4IN7Fbu2wttxffzicXfJKuYBe/q/zdsJ1TjF7ldeXsatqFSejfcThmHNsCH9hgHXT+VVFjcbs3QLrTHserFmJsCMcZgFozG4DOhgOUVTdGxvJV01cB8N3Lv5sYzauFSDDhOGmYPedWuyi/8vMw5x1WUvp93THSG9Rx2uT3UIhYC8dEv279LnoCBpWe8RjNhyJzp3BsvHfZvdhUG5fmXiqxUSQkSUiLhJQUdZPsTrCnwJQiKFg1apPRAPZQY6/nq6Rsx1hTWd92WjNDj19nd33b4D5QUaxV0if2QNmPYPN9UP0sDMPTDZqqUZpfyppFa/jMhZ/hmunX8HDFw+w9tTfm5xKj21ljht9q4MS8d0eNxVKyQ4iR0TPO1JkTALjJ/A9du54BQ0dTNa6ZcQ0Ak9yTZMItxDA4Y5w8tRfSJoM7MypGemWFtBDDoq+51+FgFprugee/GZk3aarGimkrKJ5UzEnPSYmNIiFJFBEJqTCrELXXP9+ErJvkzABva7yvol+uL5pCl1/nxT2DXBkrEtL83AzcjugvOG6HxrzcjMF/6Lx3g+aAl+6DF38AT9wCG24clqR0T19d+lXS7en8z4v/w7od67rrCIukV5hViEtzRe2LxIzwGOwaF/V6u1dKdggxEsJxRsXgF/YHMU0oVSu4Zu/dkdgwe/xsAH6z6zcydgsxDM5ak9bfZS2i6cEXkBXSQgyH3nMvFYMP2F6yNl75xWnzpqJJRew+uZsHtz8o8VEkHElIi4Q0fdx0DAzsqh0FJXFrCroywNce76vol6UzspiQ6uDpXVK2YyxZXpBNcX4mKT2+GM2clMryguzBf+iBMuunaQAm+DuhbhvUbBzStZ5LhiODie6J1LbX8tDOh7rrCMsXt6RXklfCrPGzIttRMcPbYu08LSEdIN0pCWkhhls4zlyl7WSxug9FsR6msQW7oG4b+t7n+MYr3wDg5bqXZewWYhiEa9KGRcVJfwc40qKO9wYNaWooxDDoPfe62raTGcrx0KvR8ybd0CmvK8fA4FcVv5L4KBKOJKRFQnru0HMA3HPJPdxefDtrl61NzLpJznTwDbL0wQizaSqrFuTwQlUjXf5gvC9HjBBNVdhw61IeuHkxd141C5uqsDg/E01VBv+hDRWgB6L3+bugYdfQLvYcyuvKqeuoi2wnXO15MWiaqnF78e0A3DjrxuiYEVkhnRk53jTNUFNDqSEtxHALx5l3ZZ/AhT/6RX8X5QefY1dTd3yQsVuI2NNUjQeuegCAS6ZcEh0nA13g6F4hbRgm/qCB0yapBCFirefcy6GpXDvxBI4+YiMNuyivK6e2vRYAE1Pio0g4Z40iiqIsi8GfacNx4YqiPKsoiqkoyvd67R+vKMpvFEVpUhSlU1GU5xVFWdjH+12KoqxVFOWYoigeRVG2KIqyrI/jVEVRvqooyiFFUbyKouxUFOWmM1zTJxVF2aMoik9RlGpFUf5f7P6LRZhpmjx94GkuyL6A985+L2sWraE0vzTxktFglexIkBXSANcX5eIJ6LwgZTvGFE1VWFE4mS+8o4CV8ybzbOXxSJPDQckpiprYANZ2zmlDdUwlRe15MWgtvhYAPrbgY9Exo4+SHV1+HcNESnYIMUI0VcE+tRgvjugXHClUOWwydgsxAjqDnQCsmLYiOk76O6NKdviCVrM1WSEtxPAIz71yM100pM5BOcO8qaq5Cm/QG/WSxEeRSM51W7MMeHGIfz4W64tWFOVmYFEf+xXgKWAVcCdwE2AHXlQUZWqvwx8BPgl8A7geOAY8pyhKca/jvgt8C3gQuAZ4DfiLoijX9jr3J4H1wBOh8/8FWKcoyqcG+98pTqcbOn+o+gMHWw8ye/zsxH8cxZUB3sRYIQ1w8YwsJqY5eaZCynaMVdcVTeFEu4/XDzYP/kNmr4S8JWAP1SpU7db27JWxucgz6Ks+oqZoiVd7XgyYbui80fAGAFUnq6Jjh6fF+tljhXS713oKRJoaCjFyOs+7iu3GLEw19GSCPQXyllA4+/oz17YVQsSEbug8f/h5AOo66qLjpL8rqmSHL2i9Jk0NhRheE9OcvGQUW/MkJfT75kiNzJvOWvtdiATQn5nW5tCfgVKwkr0xpShKJnA/8Dngj71efhdQAlxlmuaLoeO3AAeBu4DPhPYtAv4LuMU0zd+G9m0GKoHvhD4HRVGygS8CPzJN88ehc7yoKMos4EfAv0LH2YDvAxtM07y7x3G5wHcVRfmNaZq9nk8XA6UbOms2ruHN428C8NT+pzjUeigxS3WA1YjA2wptdVa33NkrI52rRytNVVi1YDJ/er2WHz9XzeJpmSwvyB5a+QaRUK6am43brvHMrnouPX/C4D5E1WD1k1bN6P/cAx3H4eY/Dfu//3B9xIqmCrxBL5qiETSDmAxhtbcY9SKxo9GKHd/Z8h2erHnSih0AR7dZBx7ZAgXXoKPyfFUDAIdPdqEbpoxxQoyACeluPhr4Kq8uepmct9fD1d+Gi26lBFg4cSE7T+zEq3uxq/bE7BsixCgVjpM7TuwA4PE9j1N1sqo7TnY2Wn0/QvOVTp+VkH5lXxPTslJkLiDEMJmY5mTfiQ745JPw6Cpo3g/vXhfJG4TnNm8ef5OgGUzcvlpizOpPQrrMNM3vDObDFUWJeUIauA+oNE3zcUVR+kpI14eT0QCmabYqivJP4N2EEtKh4wLAn3scF1QU5U/AVxRFcZqm6QPeCTiAP/Q6zx+ARxVFmWGa5kHgUmBSH8dtAD6OlSR/ETEk5XXlVDRVEDStlWueoCdSI6k0vzTOVzdAhm51xz38KhgBq1tu3hIrSTeKk9K6YbKjtoWgYfLgi/tIcWgU52ey4dal8kV0jEhx2LiqMJt/72rgWzfMx6YNcnWMqkHBKrA5YcN7YPffofi/Ynmpp9FUjfUr11NeV86e5j2cn3k+63as45uvfpMn3vUEE90Th/X8Ij7K68rZ1bSLoGHFjkh9vaMvUfri/dY4DPDkbZh5S/io78u8WWs9ufK7Vw/xdl2rjHFCjICJqU4MVA5nX0UO62H8eaBqaBAZu7/88pcpzCpM3MUIQoxC4Tjp030A+HRfdJzsOG79eeIWzLwlfLbjiwA8X9XIq/tPylxAiGEyKd3JawdPWvOm/Iutfjtz3ml1/qV7bvPDrT/kz3v/zNcu/ho3nH+DxEeRMM6VSagEhlIsdqjvj6IoSgnwUeDTZzhkPvD2Ga5jmqIoaT2OO2iaZlcfxzmAWT2O8wH7+jgOYF6P4+jj3L2PE0OQVPVfazZa3XGN0ML5Ht1yR7Oy6kYOnOiMbHf5dXbUtlBWLTWlx5LrF07hZKefrUMp2xE2czlMKoTX1oE5/CuVNVWjNL+UNYvWcPV5V3PfsvvoDHTy9fKvU1ZbxsM7H2Zz7ebELwckIs4YO2qeOW0c1mvfIONoGd6AVR/TFzRkjBNihExIs+pHH2OStaO1NvJaeOy+ePLFHG47zK93/VrGaiFi5JxxMiwUJyc2vBTZJXMBIYbPxDQnLV0BAroBmdMg6IHOpqhjNFVj5XSr7OEbDW9QXlcusVEkjLMmpE3TXGia5sOD/fChvr8nRVHsWDWaf2yaZvUZDssCTvWxP5w1Gd/P47J6/GwxzdOyJH0dRx+f2fs4MQSFWYWovf7JJmyNpIYKqx5bT6FuuaNZZX0bHn90gPP4dXbXJ04dbDF0ywuySXFoPB2LWuKKApf8P+vf/uFXhv55AzRr/Cz+54L/oby+nM+XfZ51O9Zx10t3sWbjGvkylyTOWF/P7z9tHFaDHmbpB6P2yRgnxMjISrUS0nXBdKu3QOvRqNd1Q2df6z5OeE7IWC1EDA00Ts42DkXtkzgpxPCYmG7FxZMdfhiXb+1sPRJ1jG7orNuxDoCnDjwlsVEklETqRPBlwI1Vq/lMFOizGGjv54eG4zjOcOwZKYpym6Io2xRF2XbixImBvHVMGucch4GBXbWjoCR2jaScIqs7bk+hbrmj2fzcDNyO6EeA3A6NebkZcbqi2JPfy3NzOzSuLpzMs28fs+7YD1XRB8GdBa89NPTPGoSp6VNRFZWAEcDE7C7pUFcel+sR0Yb6Oxmur6eEQnUkdsxYddo4bNjc7NNmRO1LtjFOiFgYjljpsmukOW00dQZgXB601Ea9Xl5XTmOXtQpTxmohog3ldzIcJ22qVc0zKk7aT4+TNer0qH0SJ4Xo21Bj5cQ0JwBNHT7IDCWkW6IT0uFShGESG0UiSYiEtKIo04C7ga8DTkVRMkPNDemxrWGtSO5rNXJ4ZXR4BfO5jmvu8XO8oii9E9B9HUcfn5nV6/Uopmn+yjTNJaZpLpk0aVJfh4ge/lT9J1JsKfyg5AfcXnw7a5etTdwagrNXWjWjI53ku7vljmbLC7Ipzs/EHeqq7dAUivOtxobJQn4v++e6oimc6gqwZf/JoX+Y3Q0Xfgz2PAOnDg398wZoT/Meej8Ik7DlgJLQUH8nw/X1HKqDRZMWdceOOe+0xt3wPWVHKlr+RbRNXY5dCyWvQ3Xyk2mMEyIWhitWTkhzdK8E67VCuqq5Cr/uj9onY7UQlqH8Tobj5KVTLsWluaLj5JSi7gNDcbJ2wuWAFT1TJE4KcUZDjZXhhPSJDl/3CuleN2uTqqypGHMGlZBWFMWpKEqJoigfVBTlo339ifF1zgRcWE0DT/X4A/DF0N8XYtVsnt/H++cBR0zT7AhtVwIzFEVJ6eM4P901oysBJ3B+H8cB7O5xHH2cu/dxYhB0Q+ef+//Jvw/+m4tyLmLleStZs2gNpfmliZmMBqsxweonofAGa/t9j4z6hoYAmqqw4dalPPhfF5DhsrEgb5w0MRmjSudMIs1p4+mK+th84EWfsP79v/7r2HzeAJzxUdVELAckTqMbOpuObMJn+JiWMY2SvBIrdoTH4ZQJ1tMpNz2KsvpJfv+Jy1g1PweAX3yoWMY4IUbQhFQHJzt9fSakZawWYnh1Bbpw2pzdO1QN3vWg9ffCd0Xi5O1XFQCw+tLzeODmxRInhRgmk8IJ6XYfuDPBOe60FdISG0UiG3BCWlGUW4A6YDPwR+C3vf78b+hnLO0AruzjD1hJ6iuxkshPAXmKopT2uN4M4IbQa2FPAXbg/T2OswEfBP5jmqYvtPtZrAT1h3tdz0eAt03TDBea3AI0neG4ZmDkC6MmCd3QWbNxDd989ZsYpsHWY1uTpyaSqlnNCTQnFFwz6pPRYZqqsKJwMu+Yn8PBps7T6teIscFl11g5bzLPVR7HH4xB2Y5xedZk541HYNN3ofpZGKHf8/Cjqj2/zE10T0zMckAiSjiG3F1+NwDPHXwuOoaoGgR9cF4JFKwCVUNTFSamO0l32lg5L0cm2UKMoAlpTmuFdEYutNXBiz+KxINIWQGlV1kBGauFGJJwrNx+YjutvtboGrThlZcL3x+Jk75QubZbLp/BisLJEieFGCbhGtJNHT5rXuTOhAMvRs2TwrHRqVnJa4fqkNgoEsaAEtKKoqwCfgMcw1qZrAD/wCqnsTG0/RfgllhepGmaLaZplvX+E3r5cGi7AyvRvAX4g6IoH1IU5Z2hfQpwX4/P2wH8GfiZoiifUBRlBfAnYAbwzR7HNQL3A19VFOXziqIsVxTlIeAq4Gs9jgtglRP5b0VRvhc67juh/x2+YZpm9POFot/K68qpaKogYAQA8Ore5KqJpAdAs8f7KgblkpkTONUVYG9je7wvRcTJdQun0OoJ8Mr+pnMffC6GDqcOWhOfl38MT9wCG24ckaR0+FHVtcvWckfxHVyYfSFH24+y9djWYT+3GF7ldeXsatqFV/cC4Df80TFED4K/HVzjot7X7g2S5rKN9OUKMeZNTHNwqsMDVU8BJmz+USQeaMD6letZPW81AHcU35G4pduEGEXCsdIwrURzVA1af6d1kCM1crzHbx3nssvvnhDDKcVhI9WhcbLNY82LWo/CyX1R86TwPObHpT8m1ZbKvAnzJDaKhDHQFdJfAE4Cl5mmeX9o3w7TNH9kmuYq4JPAe4H9MbzGfjNN0wCux0qOrwOeBHTgStM0a3sd/nGsldzfA54B8oFVpmm+1eu4u0PHfBZ4Drgc+IBpmv/sde6HgU8BHwgddzNwh2mav4zZf+AYlPQ1kYzETUgvnWGVSH8tFjWERUK6Ys5E0pwav37pAL/YVMOmquPoxoB6u3ar2QhNe7u3/Z1Qt83aPwI0VaM0v5Q1i9aw7up1nJ95Pne9fBdH24+e+81i1DpnDPG1WT/dmVHHtHsDpEtCWogRpRsmbZ4gCzyvozcfDu01o+KBpmp8ZN5HQq+YMuEWIgbOGiv9oYqXzvTu1wLWYgG3JKSFGFa6YZLitBGofo5g7Rtghhbq9JonaarG8vzlrJqxin0t+yI3l4QY7QaakL4A+Kdpmj2XREY+wzTNR7DKU9wdg2s7J9M0FdM07+m1r9k0zVtM08wyTTPFNM0Vpmnu7OO9HtM0P2+aZo5pmi7TNJf2WHXd8zjdNM3vmaZ5nmmaTtM0i0zT/OsZrme9aZpzQsfNNk1zXcz+Y8eoWZmzTtuXVDWRdD9ojnhfxaDkZ6Uwdbyb1w702bNTjAE2VcXtsPHq/pPcv3Evdz6+ndWPbB1cUrqhAvxd0fv8XdCwKzYXOwAp9hR+fuXPMUyD/3nxf/jPof/w8M6H2Vy7OTnKBY0h56yr5wm1o3BlRh3T4QuS7krMm4VCJCLdMFn9yFb+s7uBeRxC0X3RB/SIBxNcE5jonsgTe5+QcVmIGDhrrOxrhXQoIe20D6odlRCiH8Jx8WSHj3EtVSiB6JtGfc2TSvJK6Ah08O0t35b4KBLCQKNIKla5jjAvkNHrmG3A0qFclBBhx7uOA+DUnCgoyVcvUA8kbEIarLIdWw+exBjsqliR0MqqG2nzWOV0TKDLr7OjtoWy6saBf1hOETh69Zl1pFjN5uJgWsY0flDyA6pPVXPXS3exbse66JqKIiGE6+rZVSu5fFoM8bZaP09bIR2UFdJCjKCy6kZ21LYQ0E0qzel4cEYfEIoH4Vq3p7ynONh2UMZlIWKgJK+EBRMXRLajYqUvtEK6R0LaF9BRFHDaJCEtxHAJx0XDhEpzOl565Qx6zZN0Q+exqscA+Mf+f0h8FAlhoFGkAZjUY/sYUNDrmHGAPL8jhsyn+3h016MsnrSYH5f+mNuLb2ftsrXJVRNJ94OauEkPqSM9tlXWt53W0NDj19ld3zbwD5u9EvKWRE14yJ5v7Y8TBQW7akc3dUzM6JqKIiGE6+pdlnsZDtVxegzxtlg/+6oh7UzcsVmIRFNZ34bHb02ay4xithuzME3rZieOVCs+zF4ZqXWrhx5blnFZiKHTVI0flPwAgNKppdGxMrJCOi1yvCeg47JpKIo0MxRiuPQVFz1mKCltc0XiYlh5XTm7T+6ObEt8FIlgoAnpSqIT0C8DKxRFuQJAUZQFWDWUK2NzeWIs0g2dzbWb+dyLn6PR08iniz/N8vzlrFm0htL80uRJRkNCl+yA7jrSW6Vsx5g0PzcDtyP699Ht0JiX2/vBmX5QNVj9JNz0KFz+WVBUmLrE2h8nVc1VBI1g1L6kqmE/hrT72097HBnoXiHdq2SHVUNaSnYIMVJ6xhMDlY8GvsoxJtCZMcuKC6ufBFVL/t4iQsSBbui8cOQFAGaOm0lJXkn3fMt/+gppb8A47fufECK2+oqL3zNvsV684KORuBgm8VEkooEmpP8NXK4oSm5o+z6spoFliqKcAHYC6VhNAIUYsPCjmF966Uu8XPcyKiq/2fWb5HzUxNChtc6qYVr9rLWdYPKzUsjLdPPaAWlsOBYtL8imOD8Th2aFEpddpTg/k+UF2YP7QFWDglWw8jsw/0bY8Vj3ypw4OGf9YTHqhWPKjsYdtPpbox9fNHQ49Ip14LHtUWNwuzdIhpTsEGLEhOOJK1ST1maz0eSaTmraOCsuhCbdMi4LEVvhOPmTN38CwB/3/DE6Th7bCShwoCwSJ60V0lKuQ4jhFI6Lds16EsHlsHNk6g2YKODOOm3RjsRHkYgGGknWA3lAE4BpmruBFViJ6ibgP8A1pmn+K5YXKcaO8KOY4bt7BkZyPmpi6LDhRqjfDp2N8MQt1nYCJqWtOtLNUkd6DNJUhQ23LuX7N1p1B68vymXDrUvR1Bg8wnnxbdbq1V1/GfpnDVK4/nDPL3fp9vTkqWE/BoRjioFVWiby+OLRl6wx963fWQc+86XIGOwPGviChtSQFmIEdccTqx7mB5ZMZUFhIUp7fdRxvcdlFTW5eosIMcLCcdIXaiTq033RcXLP04AJT9waiZPegI5LVkgLMazCcfGDF+UD8N33LOB/P3E5Slo2tNWddnw4Pro0FwAO1SHxUYx6A01IZwAB0zT94R2mab5mmub1pmkWmqZ5jWmaz8X2EsVYMmYeNanZCHXbIFQDEX+ntV2zMb7XNQiXzMyiudNPTWNHvC9FxIGmKrx/ST4Fk9OpO+WJTTIaIH+p1ahj66/AjM/NjnD94bXL1nJH8R2smLaCRk8jZbVlcbkeMXBnjCk1z1hjrh76OhPoHoPbvVajTqkhLcTI0lSF6xZOASA30406Lg/aG6wG0JFjusflxdmLURSFB696MLnKuQkxgs4ZJ8Oly3rMVbyhGtJCiOGlqQoXTbdKZC6ammnNszJyoa2+j2Ot+PijK36EgsLy/OXJ1XtLJKV+JaQVRXm3oij7gEbghKIoexVFedfwXpoYiwqzCtGU6EEzKR81aagAf1f0Pn8XNOyKz/UMwSUzJwBI2Y4xbvncSWw73EyHL3jug/tDUaxV0o2VcPjV2HzmIGiqRml+KWsWrWHtsrXMmzCPb7z6Df5e83ce3vkwm2s3J2dJoSRRmFWIy+aK2ueyuZjr959xDA7/G5Ya0kKMPKdNxa4ptHmC1qQbEzqORx0THpc/VPAhdFNn7ba1MhYLMUhnfMz/LHHSE9ClhrQQIyTDbX0fbQstmCAjr8+ENFjxcXn+cia5J7GvZR/ldeUSG8Wods6EtKIolwBPADMBJfRnFvBE6DUhYiY/I5+gGURTNBQU3DZ3cj5qklMEjpTofY4Ua0VogsnPSiF3nIundtTxi001bKo6ji7lO8ac5XOyCegmr+xrit2HLnif1Wzu9V/F7jOHwK7Z+eEVP6TD38E3X/0m63asi65JLEadkrwS5o7vvqEZiSkzVvU5BuuTF7CpqhGAg00dMpYJMcIURSHdZbeeVMjIs3b2MfHWDZ0/7vkjAP+39/9kLBZikMKP+dsU66mg/sTJhlYvJ9q98p1fiBGQEVog0eYJJ6T7XiEN3TXhT3pPcqD1gMRGMer1Z4X050PHfQeYDORgNS3UQq8JETM/e/NnuDU33738u9xefDtrl61NzkdNZq+E3Au6tx2pkLfE2p9gdMMkYJi8eaSF+zfu5c7Ht7P6ka3yBXWMWTJ9PGlOG2XVJ2L3oY4UuGA1VP3zjF+8RlptWy021YaBgYnZXZM42ercJwlN1bjr4rsAuHbGtd0xZc47rTFXCX0NcqRi5i3hoy9lcO+zVomoX798UMYyIeIgw2Wj3RteIU2ftTLL68qpOVUT2ZaxWIjBCT/mf8HkC0izp/UrTh5o6uRIs0e+8wsxAsa5rZtFbd7QU6gZueBrBV/7aceGa8LrobKgEhvFaNefhPSlwMumaX7LNM0Tpmk2mqb5DeBl4LLhvTwxFuiGzubazdxTfg8v1r7IJ4o+wQ3n38CaRWsozS9NvmQ0WF1x373O+nvBNXDTo7D6ydO65SaCsupGWrusO7Ym0OXX2VHbQll1Y3wvTIwou6Zy+awJbK5uxIxlzeclt4JpwLbfxu4zh6CquYqAEYjal5R17pOEbui8dPQlAOZmzaUkr8SKKapmjbnjZ0DWTLjpUV5Y8jDbj7bjC1oNEH1BQ8YyIeKge4V0OCF9+g3JMdNzRIgR0hnojC5xFY6T4/Jh4pyoOBn+miff+YUYfqevkA4/PXTstGMlNopE05+EdDbwWh/7twKTYns5YqwJP1Zy10t38Y/9/0BB4bVjr42Nx0q6QitJL/hvKFiVkMlogMr6NgK6EbXP49fZXd8WpysS8bK8IJv6Vm9sG1xmzYDZ74CtD8OLP4DqZyGO48MZay0mW537JBCOL4/segSAdTvWRT+2qGqAaT2tUrCKyoZOPP7of1sylgkx8tJdNmslmCMdNCfs/sdpY7+MxULERjhWVp2sosnTFP2Iv6pZPT2mFEucFCJOTqshnTbZ+vnK/RIbRcLrT0LaDnT2sb8TkBb0YkjCj5V0Ba2mGSYmbze9PTYeK2kPNekJB5UENT8347TGJm6HxrzcjDhdkYiX5QXWPcqYrpQxdGivB18bbL4PnrgFNtwYt6R0uNai2+ZGQQEg1Z6afHXuk0A4vvgNPwBe3Xv6Y4ueFnBnAjKWCTFapLtsdHq88If3gu6H2q2njf3hsdihOgBwas7k7DkixDALx0oDa3HJaY/4+zrAmQZInBQiHlx2DYdNpdUTsGLgC9+zXtjxxzPGxnBSWlM0iY1iVOtPQlqIYTOmHytpDz1mk54T3+sYouUF2RTnZ6JauTlSHBrF+ZksL8iO74WJETdlnJuCyem8uCeGdaRrNsLJA6ENE/ydULfN2h8H4VqLa5et5fbi23nn9HfS5GniucPPsbl2Mw/vfJjNtZvHxlMeo9w544tpgrcVXOOA7rHMrlmDmYxlQsRHhsvOgq43rLGeUG2AXmN/eCz+8kVfBmDO+Dl8uPDDcbpiIRLXOWOlvwMcVkI6HCfDJE4KMTIyXHbaPEErBh6v7H7hDLFx7bK15Kflk+HI4MLJF1JeVy5zEzEq9XeF88cURVnea990AEVRXujjeNM0zRWDvywxVhRmFaIqaqTwPoyhx0o6jgMKpCb2lzhNVdhw61I+9ujrbDt8il98qJgr505GC2eoxZiyvGASj75ykA5fkDRnDB6iaaiAQFf0Pn8XNOyySt3EgaZqlOaXUppfSsAIUN9ez9de/hp21Y5P9+G2uVk4cWFyNmRNIOHHFsNP4ECv+OJrB1MHVybQPZbd/sc32bi7kQduXszygmwZy4QYYekuO+MD+0A599j/n8P/AWBX0y6+8vJXZOwVYoAKswpx2VxRSelIrNSDEPRGEtKaqvD7Wy5m1t3/5pKZE/jkFTMkTgoxAjLcNqtkRz/mRZqqUZJXwg/MH3DKd4qHdj4kcxMxavV3hfR0YHmvP9MBpY/94T9CnFM4GW1TbSgouG3usfNYSXsDpE4CLfEr32iqwpVzs/EEdBblj5cvpmPY8oJsArrJK/uaYvOBOUXgSIne50iBnIWx+fwhsqt23jv7veimjlf3YmJKR+tRIvzYohr6qnNafPG2Wj9DJTvAGsuyUp2MT7GzolBurAkRD+kuG9sD0zDtZx/7w6UGwmTsFWLgSvJKKMwqjGxHxUp/u7UzVLIDIGhYTy0smzNR4qQQI8RaIR3o97yovK6cJo81F5O5iRjN+pMJu3LYr0KMKbqhRyYRf9n7F6alTeNzSz7H/pb9zM2aS0leydi4c9feAOmJXT+6p7k56QBUN7QzKd0Z56sR8bJk+njSnDbKqk/wzvkxKEczeyXkLbEeR/OH2hlMmGPtHyWavKcn38OPu5bml8bhigRYK0TWrVjHir+uQEHhAwUf4LaFt3XHF2+L9TO0Qjqswxuj1f1CiEFJd9koM4oJTrkAe93roPvA7rZiQY+x/2ylBmTsFaL/3jH9HbzV+BYXZF/Ax+Z/jGVTl1mxMvy9y9GdkA43NXTbx8BcTYhRIsNtt2pIh+dFh18BIwiO1NNiI1jxMWAEovZJfBSj0TlnXKZpbh6JCxFjQ7iTc89GhpOzJnNl/pVcfd7Vcb66EWTo0LQXFNXqjjt7pdXJOoHNCSWk9zS0UTJ7YpyvRsSLXVO5fNYENlc3YpomijLElTOqBquftGqj1W2D19ZZdddH0e9LYVYhKbaUM5eGEHGhGzqf3vRpWnwtAGzYvYEdjTusxxUB9lqP+tO01xqTQ/+m2r0B0l32uFyzEMKaeBuoNLzrcfKr/xc23gOXfQZKvxw19p+zLI8Q4qzC87IdJ3YAUHmykseqHmPZ1GVWXKx+1jrw5L5InPQEJCEtxEjLcNk42tzVPS964hNQ+STc+CsouOa0eZHER5EopKmhGFHhldE9B8dDbYfG1uMjhm51wz11EJr3n9YdN1FNTHMyMc3B3uPt8b4UEWfL5kyivtXLN5+qZFPVcfTQ452DpmpWXbSrQkmJvf+G47tjc7Ex0LujNcDszNljo/TQKFZeV05FU0VkO/K44tGXrDH3pXutF176cdQYHLP650KIQUlzWBPr9eWHeTnlKmtnyoTTJtzhsdeluQCrhNKYKfsmRAyE52U+3QeAT/dFx8n/3GMd+PqvInEykpB2SEJaiJGgGybt3iANbV5rXoUKs64GTMgu7HORTjg+2hTr++yYKosqEookpMWIOmcn57GgZiMc3da93as7biIryEmnukES0mOZbpg8+VYdAL/fcpg7H9/O6ke2Dj0pHXbxbWBPhfL7Y/N5MdCzo/XH5n+MNHsarb7W08Y6MbKqmqvwBr1R+7xBL3tqnrHG3KA1ASfoiRqD271B0l2SkBYiHnTD5Jdl+wF47LXDrHnyCF7FidF88LRjw2Pvj0t/TLojnXkT5knDJiEG4IzzskicDL0W9EbiZLhkh0tWSAsx7HTDZPUjW3llXxNdfr17XpV5nnXAqUN9vi8cHz9R9AkAbl1wq8RHMSqdNSGtKMpuRVE+PdgPH+r7RfIpzCo8bSAcc4+PnK07boKbMzmdvcc7MGKVfBQJp6y6kd3H2iLbXX6dHbUtlFU3xuYEKVlw0S3w9l+hjwRFvGiqRml+KV9Y8gUeuOoBjrYf5baNt/HQzofYXLsZPcGfgEhEhVmFODRH1D6XzcVcv98ac3vqMQa3e4OkSUJaiLgoq25k/4kOAEygy29wxMjm5NG9fR4fHnuX5S3jQMsBfr3r1zLmCtFP4cf6ezpXnPQFpWSHECOlrLqRHbUtkWai4XnVlmarVCYth8/4Xk3V+GjhR1EVlVfqXqG8rlxioxh1zrVCei4wlGKwQ32/SDLpjnSCRhBN0VBQxubjIzlFYItOkvTVHTcRzc1JxxPQqT3Vde6DRVKqrG+LrJ4J8/h1dte3neEdg3DJ7aDa4JWfx+4zY2hx9mKmpk9lV9Mu1u1Yx10v3cWajWvkS+AIK8kr4bwMawVJVLyZseqsHcrbvQEypIa0EHFRWd+GL2BE7TtiTEI5deZJt27oVJ6spD3QLmOuEANwxsf6zxInPX7r91NKdggx/M40r9p+ygWa44wrpMGKjZ8r+xyYsP3EdomNYlTqzxKg5UNoSiXLJAW6oVu1PE9U8OS+J5mSMoXPL/k8h9sOMzdrLiV5JWPr8ZHZKyFtMrQcARTrC14f3XET0ZzJ4caG7Zw3ITXOVyPiYX5uBm6HRlePL09uh8a83IzYnSRjChR/GHY8Bsu/YjU5HEXK68o54TkR2Y7ULq4rl87WI2xx9mL2ntrLVdOu4t3nv5tlU5dZDQ3P0KHcNE2pIS1EHPUVQ+rVySz37wHThD7mJOV15TR0NgBgYsqYK0Q/aarGuhXreP/T76e+o56Pzvsoty28zZqX5S2BI1tA94O9e67i2dMEgMs2huZuQsTJGedVeZmQOe2sCelwjXgD6yaSxEYxGvUrIR36I8SAhbs392xkWJhVyMrzVo6tJHRPqgbZ860GWhd+3FqVN3tlnw0JEk04Ib23oZ13zh9dSUIxMpYXZFOcn8mO2ha6/DqqAsX5mSwvyI7tiS7/LLz1O9jyILzje7H97CE6W618+QI4MsKx563GtwB4tf5VOvwdLJu6rLtD+f9eDyeq4D0PR8bgLl8Qw0RKdggRJ+EY8ur+kwCkODTMzOnYWv8NXSch9fQHL6uaqyJN2cJkz3cj/QAA0x5JREFUzBXi3HRD59ObPs2h1kMYGGzYvYEdjTusWrOrn4S/fwoq/gzv/RUUXAuq1qOpobSiEmK4hWPiW0dO4Q0YOG1q97zqzelwlqeHZD4iEsG5ZlxXxuAch2LwGSJBhe/MhZPRAIfaDsmducZKmHYJlH4p3lcSU6lOG9OyUthzXBobjlWaqrDh1qWUVTfy65cOsPVgM/d/sBhNHfSTNn3LmgHz3wtbf2WV78i/ZNTc2AnXZOw57gFMHzc9Phc0BoVjT8AIAOAJeqJXhaia9XTK+BlQsCryvg5fEECaGgoRJ+EYctH3nycnw8kX3lHAciMIf3kIXvguzLnmtLG+rzF3zPUnEWIQzrmCMiMXVDsU3hB5j1eaGgoxYsIx8cm36vjiX3fygSVT+da7FqBhgKLCiT1Q/WyfcyCJjSIRnPXWpmmam2Pw58y3bUTSO9uduTHL22qV65g8P95XMizmTE6nukES0mOZpiqsKJzMt949HxPYuPt47E9i6NZjaroPyu+HJ26BDTda++MsXJPRbXOjoODUnJiYPLP/GV6sfZGHdz4sTbeGWb9ij+cUuDOjjmn3WglsKdkhRPxoqkJeppvsDBcrCiaivXq/9cKbv+tzrO9dB9em2shPy+fSKZfG4/KFSBjnjJW+dnCmR70eWSEtCWkhRoSmKrx7cS4AE9KcVjJ6w41woAyCXvjrx/ucA4Vjo0tzAVY/FYmNYrSRZ23EsCoYX4BC9MrIMX9n7nil9XNy4jcx7MvcnHQONnVGunCLsatgcjozJ6Xyr13HYv/hNRutcgth/k6o22btjzNN1Vi/cj1rl63l9uLb+UnpT/jcBZ/jxaMv8oWyL0jTrREQXhXS02mxx9MCrsyoY9q91gppaWooRHxlpTpo7vRbY3pjeKw3+xzrw3Vwc1KtUmFBI8jRjqN8etOnZYwV4izOGSt9HeBMi3q9u2SHJKSFGCl2TSUr1cGJdp8V/+q2WfXdAQJdfc6BwrFxWsY0FBRMTImNYtSRhLQYVpUnKzEwcKgOFJTu7s15JfG+tPhpeNv6mbMgvtcxTGZnp6EbJt99uopNVcfRDeltOlYpisL1C6fw2oGT1heoWGqoAH90SQz8XdCwK7bnGSRN1SjNL2XNojWU5pcyM3MmmqIRMAKnNd0SsRdeFRK+Idpn7PG2gHt8ZFM3TF7aazWjrD7eLmOXEHE0Ic3ByQ6/NdYHzj3Wbzm2hZPek5FtGWOFOLeSvBIKswoj26fFSl87OLubUuuGye76VgBe2dckcVKIETQpzWnNpwYwB9pybAtH249iYv2uSmwUo40kpEXM6YbO5trN3FN+D+sr1nPDjBv46fKfcnvx7axdttZqlDEK6rzGzfFd4M6C9CnxvpKY0w2T3756CIA/vHaYOx/fzupHtsoX1jHsuqJcDBOerWyI7QfnFFk1gHuyp1hNQkehPc17MEwjat+YL180jDRV45dX/RJFUchJyeGj8z7KuhXrumOPaVorpEMlO3TDZPUjW1lXth+Anz2/V8YuIeJoQqqDk52+vsd6x+ljfVVzFd6gN2qfjLFCnNs7p78TgMWTFnPvFfdGz9N8beCwVkiH4+S/dlnf5z77px0SJ4UYQZPSnZzo6H9cBCmfKkY/SUiLmNINnTUb1/Cll77EP/b/AwWFY13HKMkriawUHNPJaLBWSOcsACXGTd5GgbLqRvb2aGjY5dfZUdtCWXVjHK9KxNOcyWnMyk7jmYr62H7w7JWQtwQcqRAuCzQuz9o/CvWrhISIGd3QWbNpDYZp0NDVwIbdG6IfUfS1g6lHSnaUVTeyo7YFX9C6aeANGDJ2CRFHWalOvAGDrvOutMZ6JfTd0ZFqbfca62WMFWJgwnO2n7z5EwB2N+/msarHog/yd0RqSIfjZDCUgJbv+EKMrEnpoRXSUXMgrObufcRFkNgoRj9JSIuYKq8rp6KpInInzsSk8mSlPBYCVqOBPf+yHrNxpI+K5muxVlnfhscf/d/l8evsrm+L0xWJeFMUhWsXTmHrwWYa273nfkN/qRqsfhJuehSu/BpkTh/Vv1M9Gx2GjXOMwzANaXI4DMrryqlsqoxsRz2iaOiw+x/WC61HwdBl7BJilJmQ6gDgZJdujfVzrwNFhff+xtrutbjhtMaGijQ2FOJsyuvK2dW0C59ulVTz6b7oR/kNHdobrDhZ/Sy7605JnBQijrJDCWlTUbvnQOOnQ+Z5fcZFOH3+oaIywTUBwzRk3iFGBUlIi5iSx0LOwNCt7rdP3AJGEPY932c33EQ3PzfjtCYnbofGvNyMM7xDjAXXF03BNOG5t2NctkPVoGAVlN4FK78Fzfuh6p+xPUeM9Gx0eEfxHZTkltDQ1cCXXvqSNDkcBlXNVZFJdpg36GXPySpr7P3Xl6ydb/0vbLiR+TmpMnYJMYpMSLMS0s2dfmusn7kcTAOmLOpz0h1u3pSblgtA0JTGhkKczVnnbOF5S/sxq4H0E7fw4b3/Q6oj+ulOiZNCjJxJ6U58QYN2X7B7DjTrauhqsm7Y9iE8/7j3intxa24MDOo66vjKy1+ReYcYFSQhLWKq3d9+2j55LITubriB0Bc/3ddnN9xEt7wgm+L8TDTV+sKa4tAozs9keUF2nK9MxNOcyenMzk7j6Ypjw3eSwnfBhFlQ/lOrPvAo1LPR4U1zbkJBwaf7pMnhMCjMKsSu2qP2uWwu5npDncjDk/CgNRYv13ZSnJ+JTcYuIUaFrNQeCWmA8edZP1uOnPE9W45t4YTnRGRbxlUhzuysj/KH5y1h/k7Gn6rgvyfuRQvlpCVOCjGyJqU7AaIbxU+YBd5W6Gw64/s0VUNVVIJmEEDmHWJUGVRCWlEUu6IoqxRF+ZyiKF/vsd+lKEq2opzhFo1ISuEmht/d8l3+WPVH0mxpuG1uFJTTuzWPVQPohpvINFVhw61LWT5nEg5N5YGbF7Ph1qWRBLUYu64rmsLrh5ppbIth2Y6eVA0u/ywc2wn7Xxiec8TQvpZ9p+2Tp0li59IplzLOOS6y7dJcVizy+vsci7Xjb7Ph1qVcMjOLVKcmY5cQcTYh1Zp4N3WEJt6Z505IS2NDIfqvJK+EBRMWoIbSAQ7VwcIJC605Wx/zFiXQxReK/MyenE7uOJfESSFG2KS0vhLSs62fJ0+fV/RU1VxF0AhG7ZP4KEaDASeOFUVZBRwCngF+Anyrx8vFwDHgg0O/NJEIejYx/L+9/0fQDDJ7/GzuveJebi++nbXL1kZ3ax6rBtANN9FpqsLiaZn4dYOS2RPli6oA4LqFVtmOf8e6bEdPRR+C9Fwov3/4zhEj0mRk+OiGzqc3fZpT3lMA2FU70zKmsW7FOrQpxWccizVVIcNtJyfDxYrCyTJ2CRFHWWm9VkiPy7d+thw+43tkXBVigHqEOUVRurdzisAe/buEIwV1ShEuu8b52WkSJ4UYYX2vkD7f+nmOhHRhViEumytqn8RHMRoMKCGtKMoS4O+ACXwO+GPP103TfA04CNwYo+sTo1zvJoYAe07tQVVU1ixaQ2l+qSSjwep6m1PUvX2GLvHJYkLoDm5kIinGvNmT05kzOY1ndg1j2Q6bAy67Aw69DEe3nfv4OOqryWFOSo40OYyBcKOm8KOJASNAbXstW45t6e5MrlnJLuwpUWNxuzdIust+po8WQoyQVIeG06Z2f4+wuyAt56wJ6fC4ales32FpbCjEmZXXlfN209sYGIDV1HBX0y7rEf7ZK6MXzfSYt3gDOm67zO2EGGl9JqQzp4FqP2dCuiSvhIUTun+no56IECKOBrpC+utAF7DENM1fADV9HPMGsGioFyYSgzQx7CdVgws/Zv19ya1WV9wzdMNNBuHajyc7JCEtul23MJc3DjVzfLjKdgBc8N/gHg8v/3T4zhEDPZscfnrRp5k9bjaH2g5x10t3SZPDITprXFI1a+wtuMZqAPO+6LHYSkjb4nHZQogeFEVhQqqDkz1vbGdOO2vJjnBjw7z0PEAaGwpxNueMldf+2No5/71R85Yuv06KIznnL0KMZuPcduyawomOHglpVYOsmedMSAOgECnRE/VEhBBxNNCE9OXA303TPNsz17XAlMFfkhjtwjWjH975MG8ef/O01+XxjzM4+JKVKLv2x1ZX3CRNRgNMDD1q29QzYIox77qiHEwTfvb8Xn6xqYZNVcfRjRg3IHSmwUWfhOpn4F9fgupnrW7xo1C4yeGnij/FLUW3YGLi1b3SbGSICrMKcWnRjyU6NWd3XFI1cGdBygQrMd1jLO7wSUJaiNFAN0xsmsKbh5qtWBEMgmqz+gScZVzfcmwLjV2NkW0ZS4Xo2zljZSBUQ3rxR6LmLZ6AjlsS0kKMOMOEdKeNzXtPdM+hDB2c6XDktbPGxrM+ESFEHA101pUGnLmFpyWFQTZLFKNfuGb0rqZddAWtLyo2xYZNteHTfbhsLmli2BfThANlMGMZqMn/6xFuRiQlO0RPMyamkeLQ+PMbtZgmuEMd2mPaFMfQ4VDoy9Xrv4Idj1mPmY7yJxKOth9FQcGkO0EfXqlUml8axytLPJdOuRS7Zsejd6/8cmiO6Mf2PafAlXnae9u9AdKdUrJDiHjSDZPVj2zl6CkPhgmfffxN/uS6l/nBShQjAH+9Bab2Pa6fbdWnjKVCdLt0yqXYNBv0yF9FxUpvm/XTNS7qfR6/jtsuN26FGEnhuNjiCdDcFeDOx7ezeGo6f3Dei3JsJ0hsFAlqoJmxOmD+OY4pBg4M6mrEqBeuzRlORgPYNTv/Pf+/pYnh2ZzcB211MHN5vK9kRExIk5Id4nRl1Y0EdAPDtBoRdPl1dtS2UFbdeM739lvNRmjY2b3t74S6bdb+UUyaccXOlmNbCBiBqH0BI2DVkA7ztlhPrPTS4Q2SJiukhYirsupGdtS2EH6A5uLgm8zw7bGS0QCBM4/rMpYK0T9bjm0hoJ8lVvpCCWlneuR10zTxBKRkhxAjrXdc7PLrZBwtQ699w0pGg8RGkZAGmpD+N/BORVH6XP6qKMo1wGXA00O9MDE6nenuml21SxPDszlQZv0cIwnpNKcNh6bS1CklO0S3yvo2gnp0iQ6PX2d3fVvsTtJQAf6u6H3+LmjYFbtzDIO+mhw6NSe7T+6WBocDVNVchTcYXaf8tN4GnlPgzow6RjdMOv26lOwQIs4q69vw+LvHvPnKIVz0+j5xhnE9PJY6VOvGuKZo0thQiD5UNVfh06N/r6Jipa/d+tkjIe3XDXTDlJIdQoyw3nERYLZ+ALVXXuZcsbHnPGOCawKGacgcQ8TVQBPSPwRagP8oinIvMA9AUZTrQtt/AY4Bo7ublBi0aenTTtsnd9f64UAZjJsG42fE+0pGhKIoTEhzyAppEWV+bsZpkxi3Q2NebkbsTpJTBI6U6H12d3S3+FGod5PDTGcmLb4W1u2UBocDVZhViENzRO07LU55Wk5bId3hCwLWDTUhRPz0jhWV5nS8OKMPcqT0Oa6HGxueN+48AHRTl8aGQvThnLEyskK6+zua12/Vn3XbJSEtxEjqaw5Vo83E6LXq+Wyxcf3K9dx7xb1kOjMBqOuo4ysvf0XmGCKuBpSQNk2zDngHUA98CXg/Vn/Op0Lbx4BVpmmeq860SCDhJoYPbn+Q9TvXY2Li1JwoKLhtbqkZfS6GDgdfhpmloIyddrYT0hxSQ1pEWV6QTXF+JvZQvWi33aohvbwgO3Ynmb3SqhntSCXSPjo9x9o/yoWbHM6bMA+/3v27I025BubSKZeS5cqKbLu0PnobeFpOqyHd7rUeecxwSQ1pIeIpHCscmjWGb9Uu5KBzLqY9dLNRc1jj/BnG9S3HtlDXXhfZljFUiNNdOuXSSGIK+oiVvnZQ1ND3KUtXwLpxKyukhRhZkTlUKC6mODTapi5Hy78I+hkbNVVDVdTIU4TSRF2MBgNeBmSa5luKohQA1wGXAhOAVuA14B+maQZje4kinvpqYnh+5vl8dvFn2XtqL3Oz5lKSVyJlOs7E0OG1h8DXaq3GM/RR3VgtliakOjnZISU7RDdNVfj/7N15fFTV/f/x15lJJhsJSYAEwiKgGBMWgxtqbY0iivvW2rrQbyva1rZ28Vv92a9dbGuXr7XVVttqv2pt0WpbrUvdEYk7IErYDcgigQABQsieyczc3x93bshkJhskmSXv5+ORJvfOnZkTac5nzrnnfD4L5s/ikXe28rMX1vGFE8fzgwuK+6+gIdh/X/OeDuaSXg1r/w3NB8AKAPHxt6fCI4fOH/Dz9UVfZ2+zfV88ySQxIWsCf5z9x4Nxyue1++TqdXZF8ilzwOU+uEJaKTtEosqJFb9+pYL739jELecWU3TSIsym1+CfX7TTn135eJefp9SHinTPiZU1LTUAJLk6xcqAH3atAXcybHilPU42BVMGKIe0yOBy4uLPnl/HI+9u5ccXFvPZ48djeNr+G33iKig8Hz77ULdzDd2l6lF8lGjo0wppY8zDxpjvWpbltyzrOcuyvm9Z1lcsy7rZsqynNBmdeCIVMaxqqMJlXMoZ3ZOAHxZcCotut4/ff9A+HiJbYkZkeNirlB3SidtluPa0iYzNTqNyf1P/TkY7XG4onAun3wyzfwz1O2Dds/3/PgMkUuERl3Gx5cAW5ZPugROznKKGPstHZX3lwSJNAT/87WL7561vwVPXtvfL9S32RxjlkBaJPrfL8JkpIwEoHJ2JOynJ7tdHHAmupG4H3JH60GRXMkfnHD2gbRaJF2GxMtAhVjrjl48Xgq81JE46OWyVskNk8LldhlOPHAHA1ILh9hjK5YZjzoNh+ZAyrMeFb0W5RaS6U0POpbhTlH5VoqavOaSvAvpxb7XEKidNx9/W/S1kMhoiFIeSyDYutCvdOhWs25q6rHybiEYM87BPRQ0lAmMMZ0/N582Ne9tXpQ6YKWfDiCnw7r1gWT1fHwMiFR7xW35e3PKi8kn3YH3N+rCY1exrPhizNi6EnSsOPug9WJG8oUU5pEViSXa6nd+2tqnDze2ssVC3vdvnnTb2NKaNmIbh4A1PX8DHo+sfVd8pQg+x0hm/BIKfzzrEyea24IS0VkiLREVOhh0X9zd1WvSVmQ8Nu3t8/iljTiHZHZqazuP2qPCvRE1fJ6S3ognphOek6bjlzVtYtmtZ2OMqYthLu1bZlW476qLybSIaMSyFlrYATV5tnJBwc6eOxusL8EbFnoF9I5cLTvkG7CyHT94Z2PfqJx0LHJ4/6Xw8LvvDp3K99awwpxBXp482LlwHV0buWgVtLaFPCvbLdcEc0pnKIS0SE3Iy7L/F/U1tB08OHwsHdnTxDJvb5eaa4mtIdh38Ww4QYPXe1eo7ReghVnYzfmlWyg6RqMpJt+NaWJ2mYb2bkH5v53v4AqFj87ZA28GdhCKDrK8T0n8HzjXG5PR4pcStSGk6HCpi2AejZ9i51zrqovJtInIC5m9e3cCi9bvxB+JjdaoMjhMm5jIiw8PLa3cN/Jsd+wVIHwnv3jfw79VPnAKHE4dPbN9S62j2NfPSlpe4f+X9SuHRV6NnQFJK6DlPOv78aSzfaufSXFlZq/5KJAZkp0VYCZY1Fpr2ht9Y6qRif0XEvnPdvnX93k6RhDJ6hj1e6SgYJ5ds3gfAqu0HFCdFouDgzqHQ+MawfKjveUI6Uo0FZ1yh8YREQ18npH8JLAcWG2MuMMbkD0CbJMoibeMCmDV6Fr/+zK95YM4DyhvdG1PmQHIaYOwvT0a3lW8TiT9g8ci7WwF4+O0t3Pj4CuY9tFQfXqWd22WYU5zP4o+qafUN8Aeg5DQ48TrY8BLs3Tiw79XPIuVCBXj1k1f5Y/kflcKjk4r9FViE9jMWFhv2b7APpsyBnEnBR+x+2Rp7Al98M4sn3q8E4IfPrlF/JRID0jxuUpJcoQPvrLH297ruV0lHypMJ8Nq219RfypDXbaycMscerzgpbzrEyQff3gLAnS9/pDgpEgXZac7OoQgrpBv39FirqqtxxWvbXtN4QqKirxPSLcD5wAzgWaDKGOOP8KU9+nHGyRl9/8r72bg/fMImLSmNecXzVMSwLxr3QksdTL0UzrgNLn8Y5j3dY7GBRFBWUc2WvY0AWECT1095ZS1lFdXRbZjElHOmjqah1ce7H+8b+Dc78TpweeClW+GNO6Hi5bgoMNoxn7TBtG9Bbwu0KYVHBEW5RaS4Q1dAhxRrcbnhhC/bP3/q23D5w7x+wv2s2F5Pm98eWKu/EokdOeke9nfcmpw52v7+1m+67cdPG3sa4zPHh52vrK9UfylDXreFzVxue7ySkgkFM0PipNcXAKC5LaA4KRIFSW4XWalJEVZI54Hlh0U/7TE2Th85vT0doKPV36rxhERFXyv3vAXoVmiCcXJGd0zT4TIuPC4Prf5WUpNSlabjUKx/DrDg9FsgryjarRlUa6vqaG0LhJxr9vpZV1XH7CJtrBDbqUeNYFhKEi+v2cUZxwxweYL0XMjIhU2vwaZF9nbUsSfE/E0iJ5/02zve5qOaj9hyYAsvbnkxZGWTsw399PGnR7GlseGUMaeQ5EqCDp/Dw4q1tNTZ38+4DZI8rF20sT0vpkP9lUhsyE5PPphDOuCHsl/aP5c/Buue6bIfd7vcnHXEWWyo3RBy3incpv5ShrIeY6XLDb5WmPQZKJyrOCkSQ3IyPKErpAN++OAR++d3fgfv/1+3sfGBOQ9w29u38cKWF0IeU3yUaOjTCmnLskotyzqjN18D1WDpf5FyRqe4U/ivqf/FN0q+oTQdh2rNv2FU0ZCbjAaYWpBFSnJo95LmcVNckBWlFkksSklyc8YxeSwcjBzjGxdCy4HggRVSNT7WOfmkv3rsVzl30rnaht6N93a+F5Y3NqxYS/N+8AyDJHt1yNSCLNI6FWhSfyUSG3LSPdQ6A++NC2F3hxzQPfTjx+Qe032RU5EhqsdY6WsFf6u9ShrFSZFYkp3uCS1quHEh1GwOHvQ8xnG73Jwz8RzFR4kJfU3ZIQnESdPxt3V/C8sZ3eJrIdmVzFeP/arSdByKuirY9h5MuyzaLYmK0sI8CvMz24/TPW5KxmdTWjjAq2Al7sydOpqaRi/vBwvKDZhdq8KLYAWrxscTbUPv3tp9a2n1t4aca/G18FHNRwdPNO+H1Oz2w9LCPErGZ+MOpstUfyUSO3Iykg+uBNu1Cto61TiJw35cJNrW7ltLiz/0M1FIrGytt7+nDAcOxskklx0oFSdFoicnPTk0ZceuVfZNpI4UGyVOaEJ6iHLSdNzy5i0s27Us7PHUpNSDOTel79Y9C1h2/ughyO0y3HHJdAAuOraAe6+cyYL5s3AHP8iKOEoLR+FJcvHK2l0D+0ZdVI1n9PSBfd9+5mxD78ypkH3/yvt5o/KNIbla2h/ws2jborDzITmkAVpqIS2n/dDtMiyYP4speZmMzU5VfyUSQ7LTPQcH3n3sxyMVbgsQCL1BJTLE9CpWOjvKUu0V0E6cPP3oUaQkuRQnRaIoJ71Tyo7RMyC5b2McxUeJFX3KIW2M+VEvL7Usy/rZIbRHBkmkNB2OtKQ05Yw+XGv+DfnTYeSUaLckapwPqedNH6P8ctKljJQkPjNlJK+u3c2PLijGmAEa3DhV43cst7eyYaDgOPt8nCkeUUx6UnpY/73wk4W0BdpIS0pj+sjpQy7V0ts73mZ7/faw8xMyJ4TGs+b9kJYdco3bZUhKMhTmZKm/EokhOenJ1Da3YVkWxunHt75tF2/yZNjHXfTjTuG2Zn9zyPnXtr3GV2Z8ZUj1jyKOXsXK1mCthZSDux3dLsOIYR5y0j2KkyJRlN15hfSUOTDuBNjyJmD1GBtB8VFiR19XSN/ezdePg1/OscQof8DPS1teijgZPWv0LOWMPhwBP3y4ALYvg9FTu6xwKyIHnTN1NDtqm1mzo27g3sSpGn/5wzDjSsCCGVfEdEHDrjgVstOS0jAY3Mb+HbwBLxYWTb6mIVkpe33N+ohxbc4Rcw7Gs4AfaiuhoTqsCnlDi49hKX2t9SwiAykn3YM/YFHf6jvYjxfOBVcSXP5Qt4VpleJIJFyPsTLgh4+DK6irPwqJk01eP+me+PvcJJJIctM9NLT68PoC9gknNo4pgWH59linh6Ltio8SK/o6IX1GF1+XAr8EGoF/AGf2YxulHzmpOl755JWwx9KS0phXPE85ow9VwA8LLoUXbrKP1z1nH2tSWqRbZxXl43YZXl67c2DfyOW2JzIu/ZO9ve2d38Xl36dTIfvXn/k13yj5BnMnzg27ptnXzLp96yI8O3EV5hRGLNBSmFtoHzh9dN122FsBT10b0kfXt/jITNWEtEgsyU63i4/WNgZXg7ncMOl0CPhg7PHdDri7S3GkbckyVHUbK504+ead9gNv/jokTjZ7/WHFDUVkcGVnBONix7QdLjdMONneBXr0OT0uuFF8lFjRpwlpy7Le6OLrWcuyfgB8CrgEyB6AtsphcAoY3vb2bXyw+wN8AV/I4x6XR2k6DtfGhXY6AH8wOLQ1dVvhVkRsORkeTpqYw1MfbOf3izayaP1u/AGr5yceKmPg0zfBvo9h/X8G7n0GkNvl5vTxp/PVY7/KuZPOJc2dFnbNa9teG3K5pDvnwws5dvpoR6cq5PWtPoZpQlokpmQFdy3c/8amg7Ehe4L9YG1lj88/JveYiJNvR+cc3e9tFYkXXcZKJ046BdJ8zSFxUiukRaJvePCz6n2LPw4dM+VOBm8DNO7p1esoPkos6NeihpZlrQaeBf6nP19XDk/HAoYvbHkBn+ULu+bsI85Wmo7DtWuVXdG2I1W4FemRP2Cxq66VXXWt3L1wAzc+voJ5Dy0d2EnpootgxFHw1m/AGsD3GQRdbbvbfGAzf1r5pyEzKb2+Zn3EQXb7So9u+uhWnx+vL0BWavIgtVZEeuIPWNy7eCMAjy/bdjA2ZI2zL6j95JBe18IiYAX6q5kicaXbWNnDWKapzU+aRzduRaLFH7B44M3NACx475PQMVPuZPuifZsO+fUVH2Ww9euEdNA2YNoAvK4cAn/Az59W/okPqz+MmC8M7FQdcyfNHZTJ6NLSUgoLCykpKaGkpITq6uqQx5988kmMMSxffnAV21//+lemTJnClClT+Otf/9rl63Z8jqOsrIzhw4czc+ZMioqK+MlPftK/v1BHo2eEb4/pocKtiEBZRTW7DrQAYGGvwCmvrKWsorr7Jx4Olxs+9R178LUpvNp8POlq250v4OPhNQ/z1YVfHRKT0p13/jj8VvB3Hz0DkjutJA/20Q0t9nOVQ1okdpRVVPNxdQMQGhveqg7+HR/oeYV0xf4KAoQOri0s7lp+15DoF0U662qyyW/57TjpSQ99oMNYptnrIz1Zi5dEoqWsoppNe8LjYllFNeROsi+q2dyr11J8lFgwEBPSs4DmHq+SAeesjH54zcO0BdoiXpOWlDboqToee+wxysvLKS8vJy8vr/18fX09v//975k1a1b7uZqaGn7yk5+wdOlSli1bxk9+8hP279/fp/f79Kc/zYoVK1i+fDmPPvooH3zwQb/9LiEmnGyvtHQlAaZXFW5FBNZW1dHSFvrBp9nrZ13VABY5BJjxecgaC2/9dmDfZxAUjygmPSk97HxboI0V1Su47e3beKPyjYT9gOkP+Hlxy4sRH0sywUnmKXMgryh4NrSPbmi1J6SVQ1okdtixIXSw3Oz1s3qvBanDoXZbj69RlFtEiisl7Pyupl28uf3NfmurSLwwmIjnXbjsODn2BHAFdwt1GssoZYdIdK2tqqM1QlxcV1Vnp7My7l5PSHcVH6ubqlXYUAZNnyakjTETuviabIw53RjzKHAaoKS5UdZxZXTHyWjvHi8bbt1A1YNV7P7pbtIeS+PuT93d5eroW2+9leLiYmbMmMH3vve9AW3zD3/4Q2655RZSU1Pbz73yyivMmTOH3NxccnJymDNnDi+//HLE5//rX//ipJNO4uijj+att94KezwjI4Pjjz+eTZs28dOf/pQTTzyRadOm8ZWvfAWrP7bsr3kSLD+cdTuccVuvKtyKCEwtyAorkpPmcVNckDWwb5zkgVNvhE/egbfvgTfuhIqX47LQ4WljT2P6yOkkucInVL0BLy9seYFb3rwlYVdLv73jbfY0hefM87g8FI0ITkK73DD7x/bPJVeF9NH1WiEtEnO6jA2jMyA1GzaV9dhnnzb2NEaljwo77wv4uPP9OxOyPxTpTvuuoU4CBOw4Oe9pmHgaeIaFjWVU1FAkurodMxkXpI+Aj17o1XjmtLGnMTJtZNh5b8A75AqjS/T0dYX0VmBLhK+NwOvAVcDHwMDOXEq3nJXRD615KOLKaO8uL6deeio7N+7kyNFH8sD9D0R8nZqaGp5++mnWrl3LqlWr+MEPfhB2zeLFi9vTb3T8OvXUU7ts35e//GVKSkr42c9+1j4RvGLFCiorK7ngggtCrt2xYwfjxx/MjTpu3Dh27NgR8XV9Ph/Lli3jnnvuiZiaY9++fSxZsoSpU6fyzW9+k/fff581a9bQ3NzM888/32V7e8Wy4P2HYEwJnPJNOP1mKJyryWiRXigtzKNkfDapyXZI8rhdlIzPprQwr4dn9oOSq+1dDYt+Cot/AU9dG1JRPl64XW4emPMA86fNJ9kVOQ9yk6+JVXtXJeSqh7X71uINeMPOj0obFboDqDW46n7W10L6aGdCOlM5pEVihhMbHOkeNzPHZXLm8q/Bge1Q83GPfbbb5eaWE2/BbcI/j+1p3pOQ/aFIV3q1m8jlhtQsyCoIG8tohbRIdEWKiyXjsymdMsKOhU37YM/6Xo1n3C43508+P+JjXe2uF+lvfZ2Q/lsXX48AdwNfAGZYlhV5xlAGnLMy+oPqDyLm00xyJZEzOodnvvMMbpeba665hrffjvxhPCsri9TUVK677jr+/e9/k54evh38jDPOaE+/0fHr3Xffjfiajz32GKtXr+att97irbfeYsGCBQQCAb773e/ym9/8Juz6SCuXjYm81eyyyy4D4Pjjj2fr1q3t59966y1mzpzJ2Wefza233srUqVNZvHgxs2bNYvr06bz++uusXbs24mv22rb3oHodnHgddNE+EYnM7TIsmD+L+66cSWZqEkVjMlkwfxZu1yD8LX3yLmDs3Q1Y4G0MqSgfT9wuNzccewPH5R1Hqjs14jXNvuaDRf4SSFc5Mc+ffH7oDqDmYMqntJyQ6+pb7A/eStkhEjuc2JCb4aF4TBb3XjmTv32mDrNjebDPpld99qcKPhVx90irvzUh+0ORrvRqNxFAS52dFqeDQMCiWUUNRaLKiYvZaclMLbDj4oL5s3Bves2OhX2IjUDE2Ajw4pYXtYNIBkWfIoplWV8aoHbIYfIH/Ly5/U3ufP9OqhqqwhLUg93hHD3iaBo8DSED9K4meJOSkli2bBmLFi3iiSee4L777uP1118PuWbx4sV897vfDXtuenp6xEnpsWPHApCZmclVV13FsmXLuPjii1mzZg2lpaUA7Nq1i4suuojnnnuOcePGUVZW1v787du3t1/XWUqKnQPJ7Xbj8x2cjP/0pz8dsgK6paWFr3/96yxfvpzx48dz++2309LSEvE1e+39B+0PbtMuP7zXERmi3C7DWcWjufy4fTy+bButPj/pgzHo2bUKOt+8cyrKF84d+PfvZ85K6T+t/BMPrn4wbGtukkliy4EtvFH5BqeNPW1QitkOhq5yYoatimyutb+nZYecVg5pkdjkdhnys1IpyE5ldlE+vLHa7qM76qHPfm/nexEXOCSZJI7OOXogmi0Sk3q9m6jlQNiN2xaf/XlCK6RFosvtMowenkpBdpodF8Eez/QxNoJdgybFlUJroDXk/J4mewfR6eNP7+/mi4QYiKKGMsicFB03v3kz2xu2R5yMTnYlM3/afH7x6V+wbds23nvvPQAef/xxTjstckHDhoYGDhw4wHnnncc999xDeXl52DV9WSHt8/nYu3cvAG1tbTz//PNMmzaN4cOHs3fvXrZu3crWrVs5+eSTee655zjhhBM455xzePXVV9m/fz/79+/n1Vdf5ZxzzjmM/1q0Tz6PHDmShoYGnnzyycN6Pep3w7rnoOSa8MrUItInc4rzafUFeHvj3sF5wx4qyscjt8tNkisp4qphn+XjhS0vcPMbNydUPumucmL6rE43G5r32ylaPMNCTiuHtEjsGp6WxIHm4PbhQ+iz19esj7j92Gf5eHT9ownTD4r0JNLuWYBzJ50beoO6tc5O29FBk1cT0iKxIjs9mdqmDjeXDnE8c9rY0xiROiLsvPJIy2Dpa1FDtzEmbMbNGHOmMeZ3xphfGmMm9V/zpCcdixe2+lsjXpPkSuK4vOO44dgbcLvcFBUV8de//pUZM2ZQU1PDDTfcEPF59fX1XHDBBcyYMYPTTz+du++++7Da2trayjnnnMOMGTMoKSlh7NixXH/99d0+Jzc3lx/+8IeceOKJnHjiifzoRz8iNzf3sNqRnZ3N9ddfz/Tp07nkkks48cQTD+v1WPE3CLTBCdce3uskGH/AXo30wqqdLFq/u/1YpDsnTcolMzWJhet2D84bOhXlk4OhzbhDKsrHq6LcItKS0rp8vNnfzMo9KxMmf+qOhsiZwqoaqkJPNO+3V3112BnkD1isrKwF4P2tNeqrRGJMdprn4IR0e58d7N/cKT322UW5RV2mMVq1JzHz6otE0lWs3Nm4M/REhJQdDcEbt29v3KvP9SJRlpPuYX9ThxuthxAb23WRIbGrxR4i/amvS4HuAm4wxuRblnUAwBjzBeAxDv5f+TpjzHGWZVX2YzslAmdl9IfVH3aZeD7Zlcy1065tn4wGcLlc3H///T2+/pgxY1i2bFm/tTcjI4MPPvigx+s6pugAuPbaa7n22u4nezs+Z+TIke05pEtLSyOm+Ljjjju44447emxLtwJ+u4LtO7+H/OmQq3sxDn/A4gfPrAbgP6uqWPTRbkrGZw9eXmCJW8luF2cU5vH6R9X4A9bA///FqSi/cSEsvR82L4bS78d9QdLTxp7G9JHTWbV3Fc2+5ojXtPhb+Kjmo8TYjtfVuLjj+YAfqteDFbD77ilz8ONi3kNLWbalBoCb/rmSkvGfqK8SiSHD05KpdQbeTp/90Qvwz3lQdCFc9udu++zTxp7G+MzxbKjdEPZYQvWDIj3pbaxs3g/VH4XEyu/8oxyAV9ft5u2P9+pzvUgUZad7QldIH0JsBDuvfHVTdcTH2gudigygvqbs+Ayw2JmMDvoxUAt8EbgFyAZu6o/GSffe3vE2q/eu7nIy2uPyhKyMln4U8NuVa5/6sr2tbd+GHivZDiVlFdVU7K5vP27y+imvrKWsInLAE+norOJ89jV6WbFt/+C8octt51f7wmOQMQrKfjE47zuAnFzSv/7Mr5k1elbEa5JcSRyTe8wgt2xgjMscF/H82Ey7bkF7n719mV2BPFh9vGz9Tsora/EFV3qprxKJPcPTkw+ukAa7zy6+CLLG2T/38BnX7XJz1hFnRXwskfpBkZ70Klb+7WJ752flkpBY+dGuuvbrFStFoisn3b5RG1IfwYmNwyeAcfVqcc36mvXh6e2wY2NIoVORAdLXCenxwMfOgTFmMlAI3GtZ1qOWZd0FvATEXyWoOLS+Zn3ElW9u42bcsHHcdfpdPDDngZDJ6IkTJ7JmzZqw51x66aWUlJSEfL3yyisD2v64tnGhXbnWF0yT4mvtVSXboWJtVR2tbaH5a5u9ftZV1XXxDJGDSgtHkeQyLFw/SGk7HJ4MOO0m2PImbH5jcN97ALhdbk4ffzrziueRnhSe335y1uTQIkZxrKsq4cmuZPsHp8928moHq483rn2ZZm/ojUT1VSKxZXhaMq2+AC1tnW76506Cmi29eo3iEcUJ3w+K9KR3sbLDbtYOsVKf60ViR066B1/Aor41Ql743ElQs7lXr1OUW6TYKFHV1wnpLKBj5PkU9iaflzucWwtEvv0q/SpSjtBkVzLXTb+O5y99njMmnNHrldFPP/10WGHCwy0emNC6q2QrTC3IwpMU2r2kedwUF2R18QyRg7JSkzl58gheG6w80h2dcC1kFsDin4OVGPkRnfQdTrxIdiVzdM7RPH7+4wmzeybSZFNaUtrB1R1d9NlTXZ+Q1qlAk/oqkdgyPM2eLKtr7rQjMHdyrwfdQ6EfFOlJr2JlW6fFTsFYqc/1IrEjO92Oi7WNEXbKKzZKHOnrhPROoGOi3LOAZqBjYuBhQOQSvtKvOnYgBkNaUlpMp+iYOHEi06dPp6SkhBNOOKH9fE1NDXPmzGHKlCnMmTOH/fsPbtP/5S9/yVFHHUVhYWHIiu0PPviA6dOnc9RRR/Gtb30rdLvKYBg9w94K01EvKtkOFaWFeYzPsQObwa7IXTI+m9LCvOg2TOLGnOJ8Nu1pZPOehsF94+RUOP1mqFyaMDseOqbv+GbJN7m79G7+ecE/8SR5ot20fhMpHs4YOePg6o4uqo9PnHYyJeOzcVJgqq8SiT3OhHRtpAnppr3QciDCs0INhX5QpCe9ipVJnQqABmPlhBF2DNXnepHoy063Y1dtszf8wdzJ0Fxj54LvgWKjRFtfM5UvAS4yxlwAtACfBRZZltXxE+JkIHIJX+lXTgfy9o63+ajmI47JPYbTxp4Wk5PRjsWLFzNy5MiQc7/61a+YPXs2t956K7/61a/41a9+xf/+7/+ybt06nnjiCdauXUtVVRVnnXUWGzZswO12c8MNN/DnP/+Zk08+mfPOO4+XX36Zc889d/B+kczRYPnBlQwBnz3R0dtKtkOA22W47Phx3PlyBd8886j2D60qfCK9Nbsojx8/t5bX1u/mK6OGDe6bl1wDb98Dr//M/ps28f//Wyd9R6IW7uoxHk6ZAwXHwda37GNPBow9AffRZ7PgaBen/3oxKUku/ue8IvVVIjHGmZA+EGlCGuy0HQUlPb5OoveDIj3pVawceVRwx6dpH9+4jz6bLx/Yzv88vYbrPj2JkyePUKwUiaKc4Arp/U1drJAGOzaOzenxtRQbJZr6OiH9C+Bi4NngcQD4ufOgMSYLKAWe6I/GSc/62oHcf//93H///QAcOHCAiRMnsnjx4rDr/H4/8+fPZ/ny5RhjuPbaa/nud7/br213PPvss5SVlQHwX//1X5SWlvK///u/PPvss3zhC18gJSWFSZMmcdRRR7Fs2TImTpxIXV0dp5xyCgBf/OIXeeaZZ8ImpG+//Xa2bNnCzp072bBhA7/97W9ZsmQJL730EmPHjuU///kPycnJh9bot38Lnky48B67sx893f4QF8M3AwbbgaY2UpJc3DTnaEwCTOjJ4BqXk07RmCwWrtvNVz5z5OC+eZIHSm+FZ26ART+F5DR71ZD+xmNat/HQ5YbLHoTfFsLRc+H4L7f/ezr/oseOy2Z2Uf6gtllEeuZsTT7QeeCdPcH+/vY9cOwX1EeL9EKPsfK078KT18JJ18ORs9v/rpqDOaS/ccZR7aszRSQ62ldIN0VYIZ19hP39nd/BsVcqNkpM69OEtGVZq40xs4D/Cp76h2VZ73e4ZAbwKvB4P7VP+tnXvvY1vva1r9HW1saZZ57JTTfdFPG68vJyduzY0V4Asba2Nuyaxx57jF//+tdh54866iiefPLJsPPGGM4++2yMMXz1q1/lK1/5CgC7d+9mzJgxAIwZM4bqarti844dOzj55JPbnz9u3Dh27NhBcnIy48aNCzsfyaZNm1i8eDHr1q3jlFNO4amnnuLOO+/k0ksv5YUXXuCSSy6J+Lxu7V4H656Fz9wM0z/b9+cPEfsaveRmeDQZLYdsTnE+972+kX0NrYwYljK4bz7ts/DCTfD23faxswti3tP6UBevWoMlMKZ/DgpDay83tPoYltrXe/QiMhgipuwI+OGV2+yf1z0NH7+qPlqkP7TW298/9R0YPrb9dLPXzsjZue6CiAy+9hXSjZ0mpAN+ePlW++d1z8DHCxUbJab1efRlWdZq4HtdPPY28PbhNkoG3re//W3OPPNMLrzwwoiPT548mc2bN3PjjTdy/vnnc/bZZ4ddc/XVV3P11Vf3+j3feecdCgoKqK6uZs6cORxzzDF85jOf6fL6SHmhjTFdno/k3HPPJTk5menTp+P3+5k7156EmD59Olu3bu1120O8dRd4hsHJXz+05w8RNcEJaZFDNacon98v2sjiij189vhBrpW76XUIBLDr9tJeaZ6NC8MmMyVOOLn00rJDTluWRUOLj0xNSIvEpIgpOzYuhJ0rDh6rjxbpH05O9tThIaebvH6SXAaPu68lqESkvzlxMSxlh2KjxJl+iSjGmGRjzExjTGF/vJ4MrEceeYRPPvmEH//4x11ek5OTw8qVKyktLeUPf/gD1113Xdg1jz32GCUlJWFfn/1s5FXDBQUFAOTl5XHppZeybNkyAPLz89m5cycAO3fuJC/PLpAxbtw4Kisr25+/fft2CgoKGDduHNu3bw87H0lKir2q0uVykZyc3D5x7XK58PkOofbmng2w5t/2Nrb03L4/fwjRhLQcrmljs8jPTOGxpZ/w+0UbWbR+N/7AIBUw3bUK/J1WHXibgnkVJS4119jf00Lz6bW0BfAFLIalHGIKJxEZUOke+2bRwnW7DsaBXavsPrkj9dEih6/lABi3XWuhgyavnzSPWzsfRWKAMYa0ZBdvbKgOHR8pNkqc6dOEtDHmCmPMP40xuR3OHQmsBZYD64wx/zbGaJlRjPrggw+46667ePTRR3G5uv7n37t3L4FAgMsvv5yf/exnfPjhh2HXXH311ZSXl4d9RUrX0djYSH19ffvPr776KtOmTQPgoosu4q9//SsAf/3rX7n44ovbzz/xxBO0trayZcsWNm7cyEknncSYMWPIzMxkyZIlWJbF3/72t/bnDLi37rLzyZ7yzcF5vzimCWk5XAHLrie4Ylstdy/cwI2Pr2DeQ0sHZ1J69Aw7TUdHnnQ7X7zEp/YV0qE3E+tb7dUlStkhEnv8AYsv/cVewLBkc83BOJA/XX20yEBoqbNXR3eaeG7y+khXug6RqPMHLOY9tJSWtgDllQdCx0cav0ic6evo61qgwLKsmg7nfgMcBbwOjMAuevhl4P/6pYXSr+677z5qamo444wzADjhhBN48MEHw67bsWMHX/7ylwkE7AIWv/zlLw/rfXfv3s2ll14KgM/n46qrrmpPn3HrrbdyxRVX8NBDDzFhwgT+9a9/ATB16lSuuOIKiouLSUpK4g9/+ANut/1B6E9/+hNf+tKXaG5u5txzzw0raNivAn57m8vmxbDqn3DK1yFj5MC9X4LQhLQcrrKK6vataBb26pzyylrKKqoHvvjclDl2zrXty6GtEYzLPp4yZ2DfVwZGwA+fvGf/vONDuxhaMJdeQ4u9WyZLE9IiMaesopryytr24/Y44D+W2WNPgE/ehUAbJGeojxY5XAE/VK8HKwAVL4cUQ2vy+snwKE6KRJsTF53lOSHjo8Lg+EWxUeJEX6NKMbDQOTDGZAHnAf+0LOsLxphkoBxNSMesv/zlL7267thjj424KvpQTZ48mZUrV0Z8bMSIESxatCjiY7fddhu33XZb2PkTTjihveBiV26//faQ44aGhi4f61LADwsutXMveRvtczs+tM+rMECXWn1+Glp9jNCEtByGtVV1eH2BkHPNXj/rquoGfkLa5bYLgGxcCB/+FSpehFO/pb/7eOT045+8ax8/d6P9bxos8FIfnJAelqKBtkisWVtVR7PXH3Ku2etn3a5GZs97Gl74HnzwMJz/G5hxhfpokUPlxMpt74Hlh6euDSmG1hxM2SEi0dVlXHTGR4qNEkf6mkN6FLCzw/Ep2JPaTwBYltWGPWF9ZL+0TiTaNi4MnYwGOzfTxoVdP0fY32ivas3RhLQchqkFWWGDnzSPm+KCrMFpgMttFwD53CMwbDS8c8/gvK/0L6cfDwQLv7R1KPACNLRqQlokVnUbB1xuOPoc++TIKRpwixwOJ1ZawYkub2isbFTKDpGY0OP4yOWGo8+2fx55tGKjxLS+TkjXAx1L7p6OvZP67Q7nWoDMw2yXDKJZs2aFFSZcvVqJ7wEVBjhE+xpbAbRCWg5LaWEeJeOzSUmyQ1VKkouS8dmUFuYNbkOSUuDUG2HrW1C5bHDfWw5fD/24s0I6M1VFDUVijRMH3C47n226xx0aB7LH299rt0WphSIJoodY2ez1txcYFZHoceJicldxEWD4OPv7gcootFCk9/o6Ib0RONcYk2KM8QCfA1ZZlrW3wzVHANX91UAZeEuXLg0rTDh9uhLfA3ZhgKTU0HMqDNAjZ4V0bkZKlFsi8cztMiyYP4vff2EmKUkujpuQzYL5s9onJgbV8V+yi+G99dvBf285PD0UeKlvsfurTOWQFok5ThyYfUweSS7DvVfODI0D7YPu7dFrpEgi6CFWNnn9WiEtEgOcuPi5E+wbsj+/dFr4+EixUeJEXyek/wxMxp6YXh/8+eFO18wC1h5+00RiwFFngdtZ5WvAo8IAveGskM7N0IpDOTxul+GcaaO5uKSANTvqaPMHen7SQEgZBiffABtegl3d56+XGOMUqDTBjzyd+nGl7BCJbW6XoWRCNr6AxSlHjggddKcOh5ThWgUmcricWOnoFCublENaJGa4XYbTpowE4JjRWeGLdVKz7YKGdTsGv3EifdCnCWnLsv4K/ApIx07dcV/wCwBjzJnARGBx/zVRJIo2vAStB+DE6+CM2+Dyh9uLe0jXahq9gFZIS/85f0YB9a0+3tq4t+eLB8pJ19sf7l68Gd64065AH/D3/DyJLqdAZfoIyJ8W1o83OEUNtUJaJGY5KcD2NXhDHwj47UnpTYvVJ4scDpcbrvqn/fOk08NiZZPXR4ZSdojEjFGZ9jh7T31r+INWANKy4eNFio0S0/ocVSzL+h/gf7p4+G0gB2js4nGR+OHzwsIfwahjYO7/glsfwnrDH7D48JP9GOCDT2o485j86KRYkIRy6pEjyE5P5vlVVcwpzo9OI1KyID0Xtr1rV6H3pIdUoJcY5nLbffrE0+xClUH+gMWaqgMkuQxvbthDaWGe+iuRGOTc4N7f5GV8bjCtQMAPCy61V4BZfnjqWvXJIofD22B/P+aCsFhZ3+Jj/c46Fq3frVgpEgNGDetiQtqJjfW7FBsl5vU1ZUe3LMvyWpZ1wLIsX3++rkhUvP8g1GyGs+/QZHQv+QMW8x5ayktrdmEB336inHkPLcUfsKLdNIlzyW4Xc6eO5rV1u2lpi9Jd/o0LoWlf8MAKq0AvMczvs3e7pOUcPBXsrxatr8YXsLjx8RXqr0RiVK6zQrqxwwrpjQvtPtgKxgT1ySKHp+WA/T11ePspJ1b6AhbLP9mvWCkSI9pXSDd0mpBWbJQ4ckgT0saYGcaYXxljnjXGvNbh/ERjzBXGmJzuni8S85pq4I3/hcln2HmkpVfKKqopr6zFF/yQ2uT1U15ZS1mF6pzK4btgRgGNXj9lFXui04Bdq6CtOfRchwr0EsNaau3vabntp9RficQPJ2VHTceUHbtW2X1wR+qTRQ6dEys7TEg7sdKhWCkSGzJSkkj3uMNXSCs2Shzp84S0MeanwIfALcCFwBmdXu9x4Jp+aZ1ItLx5l71K4Ow7wGhLWm+traqj2Ru6erXZ62ddVV2UWiSJ5OTJueRmeHh+VVV0GtBDBXqJYc377e8dVkirvxKJH7nDghPSHVdIq08W6V8RVkgrVorErlGZKeET0oqNEkf6NCFtjPkC8ANgIVAC/LLj45ZlbQaWAxf1U/tEBk/Abyf9f+lWWHo/zLwaRk+LdqviytSCrLAK3GkeN8UFWVFqkSSSJLeLudNGs2h9ddjgaFA4Feg9GQfPjT62vQK9xKiAHypesn/et6m9sIv6K5H4kZmSRLLbhKbscPrkpFT7OCnVPlafLNJ3AT9sfsP+efeakFiZmhw6ZaBYKRIbRg2LMCHdHhvT7GN3imKjxKy+rpD+FvAxcLFlWasAb4Rr1gNTDrdhIoPKSf7/1LWw9E92zqUOExfSO6WFeUwdc/ADarrHTcn4bEoL86LYKkkkF8wYQ3Obn8XR2CrqctsFQS5/GE683j43+XQVCIllTt+++Of28Tv32McBP6WFeZSMz8bZA6P+SiR2GWPISfdQ09hh4O30yefdZR8f90UVbRI5FE6sXPJH+3jhj0Ji5dH5me2XKlaKxI5RmSnhOaSd2HjJn+zjqZcoNkrM6uuE9HTgFcuyIk1EO6qA/ENvkkgUOMn/vY0Hz+1apeT/feR2GW48074f9bnjx3HvlTNZMH+WKnFLv5k1aQQjh3l4YdXO6DTA5bYrz59/F0w5B5Y+ENpvSGxx+nZfi33sa24v7OJ2GRbMn0VOhofiMVnqr0RiXG6Gh5rGttCTLjcc+wXA2Cl5NOAW6TsnVvqDQ/y2ppBY+f1ziwD47HH6bC8SSyKm7AA7Fk67FIaNBleSYqPErL5OSBsg0MM1+UDLoTVHJEqU/L/ffLynAYBb5h7D7KJ8fWCVfuV2Gc6dNoZFH+2msdUX3cac9l1oroEVj0a3HdK1Hvp2t8vg8wc4aVKu+iuRGDdiWKcV0g53MmSOhgM7Br9RIomgh1jZ7LN3jF518gTFSpEYMmpYCgea22j1dbGre8SRsO/jwW2USB/0dUJ6I3BqVw8aY9zAacDaw2mUyKAbPcMe0HSk5P+HZGN1PTnpyYwMFiAS6W8XzBhDS1uA1z+KcoX3I06BCafAu/eCv63n62Xw9VDYxbIsGlp9ZKYmRaFxItIXuRkpoUUNO8oaC3XbB7dBIomih1jp1O3I8ChWisSSUZkpAOxt6CI25k6205CKxKi+Tkj/EzjOGPPfXTz+feAo4O+H1SqRwTZyCvh9YNyAsYuWKfn/Idmwu4Ep+ZkYo9UTMjBOmJhLXmZK9NJ2dHTad+FApZ1v8Y077cKoyj0fO5zCLq7gILpT397k9ROwYFiKBtkisW5Ehie0qKEj4Lf/xneuUh8sciicWGmC2/o7xUpnR1q6R9v+RWKJMyEdMW0HQO4kaNoLi36q+Cgxqa8jsHuAzwF3GmOuACwAY8xdwKeBE4AlwJ/7sY0iA8uy4KX/B8lpcN6dULfTXhEwZY7yLfWRZVls2F3PxSUF0W6KJDC3yzB32mj+vnQbd71SwcwJdnGdqGwhPXI2JGfAkmDhEE+6PYhT8ZDY4BR2eeQC2LMeLrk/pG9vCA6yh2mFtEhM8wcs9jd6qW/x8cqaXZxVHEwb4BRj2/EBBNrs4tTqg0X6xomVfy6Fxr1wwd0hsbIpuEJaE9IisSU3w96R/Jd3tnDRsQWh46GAH1Y/af/81m81RpGY1KcV0pZlNQNnAAuA44CTsPNK3wQcDzwKzLUsa0ASexpjzjPGvGmMaTDG1BljlhtjzuzweI4x5kFjzF5jTKMx5jVjTFjOBWNMqjHm18aYncaYZmPMe8aYz0S4zmWM+b4xZqsxpsUYs9IYc3kXbbveGPORMabVGFNhjPla//72MmDWPQMfL4Qzb4OZ18DpN9tFy9RR99nuulbqW3wh1bhF+ps/YPHhtv34Ahb3Lf6YGx9fwbyHluIPWIPfmI9fg4AP+/6sZRc4DBYCkhjhckNyKuQeGda317fYH1cyU5O7eraIRJk/YDHvoaW8tMbeFfOdf5Qf7POdYmyBYNok9cEih8blttMX5hWFxcpGrx0rM7SbSCRm+AMWP39hPQDPlleFj4c2LoSaLcGrNUaR2NTXlB1YlnXAsqwvYRcvPBe4BrgQGGNZ1n9ZllXfv020GWO+CjwLfABcir1S+19AevBxAzwHzAVuBC4HkoHFxphxnV7uIeB64EfABcBO4BVjTEmn634G3A7ch/27LgH+ZYw5r1PbrgceAJ4Kvv+/gD8aY244zF9bBlrLAXjpVntF9ElfjXZr4t6G3faf/5Q8TUjLwCmrqGbznsb24yavn/LKWsoqopBTeteqg1XpHSqIGnua90NaTtjp+hZ7EitTg2yRmFVWUU15ZS1evz3Ibm7r0OerKLVI/2muhdThYaebWv24DKQk9XnqQEQGSFlFNet21rUfh42Hdq0CX0vokxQfJcb0aQRmjNkMvGRZ1jcsy6oBXhmYZoW970TsdCE3W5Z1T4eHOr7/RdgFFc+0LGtx8HnvAVuAW4BvBc8dC1wFXGtZ1l+C597ALsT40+DrYIzJA74H/MqyrLuC77HYGHMU8CvgxeB1ScDPgQWWZd3W4boC4GfGmActy1K1q1j1+h3QsBuu/Du4NSFxuJwJ6aPzh0W5JZLI1lbVtRfYcTR7/ayrqmN2Uf7gNsYpBOQ9OEGugqgxqHk/jJgSdtpJ2aGihiKxq9s+f5z6YJF+01ILadlhpxu9PjI8SaoPIxJDehwPaYwicaCvtzlHAQcGoiE9uBYIAPd3c81FQJUzGQ32am7gP8DFna5rA/7R4Tof8ARwjjEmJXj6HMCDnYako0eB6caYScHjU7D/u3S+bgEwAnuSXGJJwG8n9f/Pd2DZn+HE+TD2+Gi3KiFs3N3AiAwPI4al9HyxyCGaWpBFWqc8hmkeN8UFWYPfGKcQUHJG8ISx+xMVRI0dAT/UV0PN5rCCLg0tyiEtEuu67fPb++B0+wG3R0WpRQ6F32ffvK1eHxYrm71+0lOUylAklvQ4HmovVhqc8utUrFQkFvR1QnotcORANKQHpwEfAV8wxmwyxviMMR8bY77R4ZqpwJoIz10LTDDGDOtw3RbLspoiXOcBjupwXSvwcYTrAIo7XEeE9+58ncQCp/jNk9fCB3+xz1WvV8XZfrKhup4pWh0tA6y0MI+S8dntxXXcBkrG24UNB51TCOizD0PxJYAFM+cpB32sCPjhb5eAr8nOm/fUtXYMCPb5Tg7pYUrZIRKznD4/LdnuVz1uc7DPb++D/wJJaTDxMyrYJNJXAT/87WKwArDtvbBY2ej1k+FRnBSJJU5sdGoYpnvcoeMhJz6OOxHScuHyhxUfJeb0dUL698CFxpgZA9GYbhQAU4BfY6fLOBtYCNxnjPl28JpcYH+E59YEv+f08rrcDt9rLcvqXCUr0nVEeM3O10kscIrftHXYurKzXMn9+4FlWXy8u0EFDWXAuV2GBfNnce+VM5k5IRtjDH+8+riDVaUHm8ttFwD67F8grxjKfmWvNJLoc/p8R6eCLvWtKmooEuucPv+eL5QAMHfaaBbMn3Wwz3f64LwisPwabIv01caFUPXhweNOsbKp1acV0iIxxomN08cOZ9SwFO69cmZobAQ7Ho4/Cdqa4OhzFB8l5vR1Qno78BrwjjHmLmPM540xpxtjPtP5awDamQl81bKs/7Ms63XLsm4AXga+HyxoaIDOk8cEz3c+7u/r6OLabhljvmKMWW6MWb5nz56+Pl0OhYrfDJidB1qob/UxJc4npPV3GR/cLsPsonxuO68IX8CirCIG/q1cLjjjf6BmE6z6R8/XS68c1t/krlXQ1hx6rkOf7xQ11Appkb4Z7FjpdhnOmTqarNQkctI9kW9A5kyE/VsHvC0isWggY2Wj10e6VkiL9NlAx0q3yzAlP5Nktz0uihgbh0+wixs2RKH4u0gP+johXQacD2QANwF/B14HFkf46k/7gt87L2N9FcgHxmCvSI60GtlZGe2sYO7pupoO33NMePWGSNcR4TVzOz0exrKsP1uWdYJlWSeMGjWqq8ukP+VNhc7/pEru3y/aCxrmxXfKDv1dxpfjJuQwOiuVF1bvjHZTbMdcAGOOhTd+BT5vtFuTEA7rb3L0DEjqlNO+Q5/f0OIj3eOO3up6kTgVrViZm+GhpqmLWuE5E+FApXaoyJA0kLGyyesnw6OVlSJ9NRixMic9mZqmbsYc2ePt7wcqB+T9RQ5HX291/pRDWAncD9YCJ0c474wgA8Frzo5wTTGwzbKshg6vdakxJr1THuliwMvBnNFrgRTsnNkfd7oOYF2H68DOJb2zm+skFuxeY+dHc6eA32t/2FJy/37RPiEd5yukJb64XIa500bz92XbqG9pi37qBWPgjB/A3z8Hr3wfhgWrXE+Zo21y0TBlDow4yu77MWF9fkOrj0wVNBSJGzkZHvY3djHwzp4AAR8s/BFM+oz6XZHemjIHco+E6rVEipWNrT7G56ZHt40iElFOhoeWtgDNXn9YkUMAMgvs7+/eB8d+QbFRYkqfRmGWZd0+QO3oydPAfOAc4MkO588BtluWtcsY8xzwZWPM6ZZlvQFgjMkCLsReye14DvgJ8Dngr8HrkoDPA69altUavO5l7Anqq4PXO64B1liWtSV4/B6wN3jda52uqwHeOYzfW/rTzpXw5p0w9TKY8Xl7G9ro6eqU+4E/mDIh3ePmw237KS3M04pDGTQXzBjDI+9u5fWPqrm4ZGy0mwNHngkpmfD+Q/axM7BTIZHB53LDyV+HZ78OJ98Ak05v7/P9AYuPqxvw+gIsWr9b/ZZIHMhN97DzQEv4AwE/LH/Y/nnJH+HDR9TvivSWyw0nfw2eu9GOmR1u6PgDFjWNXrbubVSsFIlBOekeAPY3eUnzpIU+GPDbC2QA1j0NH7+q2CgxpdcT0saYCcCJ2Cuk37csazDX/L+InQbkAWPMSGAz8FnsFdFfDl7zHPbk8KPGmJuxU3R8H3sV9Z3OC1mWVW6M+QdwjzEmGdgC3ABMwp5Udq6rNsbcjZ2juh74EHvS+kzg4g7XtRljfgj80RizA3tS+kzgWuBGy7K0ZzsW+Frh6a9B+kg4/zeQnmsXwJHD5g9YzHtoKUs27yNgwY2Pr6BkfHZ4UQWRAdKetmPVztiYkP74NfC30b6hqGNxIPU7g6+l1v5++i2QZmfdcvqtD7ftV78lEkdyMjys21kX/sDGhbDP2dBoqd8V6atWe6cjp98cFiv3N7Wxv6lNsVIkBuWk27tD9zd5KcjuNCG9cSHsLD94rNgoMaZXOaSNMXdhTwL/E/gXsMUY8+uBbFhHlmVZwCXAE9irlZ/HTuFxtWVZjwSvCQAXYOeZ/iP2qmo/cEaEyfMvA38B7gBeAMYDcy3L+rDTdbcFr/k28ArwKeAKy7L+06l992NPal8RvO5K4JuWZf3hMH916S+Lfw7V6+Cie+3JaOk3ZRXVlFfWEgjOvTV5/ZRX1lJWocIJMjictB1lG/a0F6mLql2r7JtgHal4avQ07wfjgpTh7afUb4nEp9wMDzWNXuyhQQc9FGUTkR401wImYqx0KFaKxB5nhXRtpPoKu1bZsbAjxUaJIT1OSBtjrsIuYGiAj4CK4M83GWOuHNjmHWRZVp1lWd+wLCvfsiyPZVkzLMv6e6draizLutayrFzLstIty5ptWdbKCK/VbFnWTZZljbYsK9WyrFmWZZVFuM5vWdYdlmUdYVlWSvA9n+x8XfDaByzLOjp43RTLsv7Yb7+8HJqAHypetrefvfM7mDkPjo6UZlwOx9qqOpq9/pBzzV4/66oirGASGSDnzxiD1xfg9Y9iYJA0eoadpqMjFU+NjoAfqsrtugEbX7WPUb8lEq9y0j20+gI0t4X+/arfFTkMAb+d2jDJo1gpEmdyMuwJ6ZpI9RUUGyXG9WaF9HzAB5xlWdZUy7KKsXM3B4KPicSegB8WXApPXgsf/g0wULO5/QOW9J+pBVkkuUO37aV53BQXZEWpRTIUHT8hh/ysFF5YtbPniwfalDl2fjZPxsFzY0pUPHWwOXFg0+vga4anrrWPA36mFmSFFX5RvyUS+3Iz7K3JYQNvp981waGNJ0NFq0V6oz1WLrJ3d3WKlanJipUisezgCukIE9JObHQFi74rNkqM6c2E9AzgGcuyFjsnLMt6DXgWKBmgdokcno0L7fxIbY3BE5adP2njwmi2KiGVFuaR4UnCYG+dSPe4KRmfTWlhXrSbJkOIy2U4d9oYyjbsoaHVF+XGuO1iIZc/DCdca5+beJqKhww2Jw5YwRuRHfLmlRbmUTI+u/1S9Vsi8aG9eFNjp63JTr87+QxITrP7XxVtEumZEysDwc9OnWJlx8lnxUqR2JOd7tyojZCyw4mNM4Ol0s7/rWKjxJTeTEjnYKfp6OwjILtfWyPSX5QvadAELItWn58zjhnFTXOO5t4rZ6rYiUTFedPttB2L1u+OdlPsD3qFc+GCu6HoQnjvj9BUE+1WDS3dxAG3y/DXL58EwMmTR6jfEokTucGtyfsjrQRzuWHSp+1c0kecqgG3SG/0ECvvuGQaABfMGKNYKRKDkt0uMlOTIsdFsGPh0efaP+ceqdgoMaU3E9IuIFKVqDbsBZEisSdzDNCp4I3yJQ2IVdsP0NwW4HPHj+fG2VOYXZSvD6oSFScckUNeZgovro6BtB0dnXEbeBvsXPYyeHrIm9fis1dOzz4mT/2WSJzI6W5CGiBnov299pPBaZBIvOspVgbztV9+/DjFSpEYlZPu6TouAuQcYX9XbJQY05sJaQib2ROJYf42+OARMG572yZG+ZIG0JLN+wCYNXlElFsiQ53LZThv+hgWV8RA2o6O8opg2uX2KulXf2QXW1U++4Hn5M1zdIoD9S32/0cyU5Oi0ToROQS56d0UbwIYPt7+/vbd6mtFeqOHWNkULGqY4VGsFIlVORke9jdFWkMalFlgf1+xQLFRYkpvJ6RvN8b4O34BPwLofD74FUMzATLkvP4zO/fZZX+Gzz5ir05ULsEBs2TzPo4Zndm+jVYkmuZOHY3XF+CWf61k0frd+AMxcD814IfabRDwwru/CykYJAPI5YYr/2H/POn0sDjg3LQYpglpkbiRkWLXrHhlza7wPj7gh4U/tH9e85T6WpHecLnhmn/bC3kmnBIWKxuDsTLdozGUSCzyByz8gQAVu+oij30CfvjnPPvnzWWKjRJTejshbfr41dvXFelfGxfa2+JPuBamf9bO4Xr6zfZ3TUb3O68vwPKt+zlZq6MlBvgDFr9/fSMAL67ZxY2Pr2DeQ0ujPym9cSFUrz143KFgkAwwb739vejCsDjgrJAelqIJaZF44A9YfOkvy7CAJVtqwvv4jQth58qDT1BfK9I7/la7APDR54TFykavYqVIrPIHLOY9tJT1O+vZXdcaeezjFC51KDZKDOlx4tiyLNehfA1G40VC1FXB01+F/Glwzi+i3ZohYdX2Wprb/JqQlphQVlFNeWVt+3GT1095ZS1lFdXRaxSoyGo0OYUk03LCHqpvsbc2ZqYmD2aLROQQ9djHq68VOTTNtfb3CLGysdVeRZmeooU9IrHGiYvOBHTEsY9io8QwTRxLfAv47TxIi38FCy4DbzN87pFg7mgZaO9t2ocxMGtSbrSbIsLaqjqavaHbz5q9ftZV1UWpRUGRCgYlp6nI6kAL+GHDy/bPNZvCtiY6KTuUQ1okPvTYx/dQnE1EIgj44aMX7J9rtobFyqbgCmnlkBaJPb0a+yg2SgxTZJH4FfDb+Y92LLe3ngCMOgZyJ0e3XUPIki37OGZ0VnvVe5FomlqQRZrH3V6AByDN46a4ICuKreJgwaAdy4MrFCxIz1WR1YHkxIfKJfbxW3fD1ndCc0grZYdIXOmxj3f62k/egYBPBa1FetIeK5fax0v/BFUfdsohbf+9pSVrhbRIrOnV2MeJjduW2Ol5ktIUGyVmaIW0xC8nH5IzGQ1woFL5kAZJq88fzB+t1dESG0oL8ygZnx1SeOfYccMpLcyLYquwB3XznrYLBZ1xGxxxGjTWHNwiK/3PiQ++VvvY1xyWL8/JIa0V0iLxwenj3S4D2EXWSsZnH+zjnb52+hX28UX3qaC1SHfaY2WLfexrCYuVTV4f6R43ruDfnYjEDicupiTZ03qpya7QuAgHY+PZP7OPT7pesVFihiakJX4pH1JUraw8QKsvwCnKHy0xwu0yLJg/i3uvnMmlMwsAuO7Tk9snL6LK5T5YZPX839gTpEv+GO1WJa5exIf6Vm1DFoknTh9/5jF5JLsN9145kwXzZ4X28S43HDXb/jmvSANuke70IlY2ev2kK06KxCQnLn7nrKMB+EbpUeFxEexYeNwXAWPvHlJslBihCWmJX6MKgU6drfIhDZqD+aM1IS2xw+0yzC7K55eXzSDD4+a19buj3aRwecdA0YXw3h/gtZ/YefA75WyUw9SLfHn1LW0MS0nSqi+ROOJ2GWaMHU6b3+LTU0ZFvuGYad+Q5O271b+KdKcXsbKx1ccwFTQUiVlul2FOcT4AE0akd70Qx+2BjJGw7lnFRokZmpCW+GRZsP55IABJKbTf7VM+pEGzZPM+isdkMTw9OdpNEQmTmuym9Jg8Fq7b3V55OmYE/FC3w14l/fZv4alr7RyO+mDYf5x8ea7gqq4I8aGhxad0HSJxKDv4ueNAc1v4gwE/LPqJ/fOqf6h/FelOe6wMfpaPECsbW7VCWiTW5QbrOdU0eiNf4OSLb6qB6nWKjRIzNCEt8WnZn2H1P+H0W+Fzf7Pzsl7+sPIhDQJ/wOKlNTtZtrWGguy02JvsEwk6Z+po9jZ4+XDb/mg3JdTGhbDno4PH3sawnI1ymJx8eQXHQfrIsPjgD1hs3tNAqy/AovUxeNNCRLo0PN0eeB9ojjDw3rgwNHWb+leRrjmxcnIpJKdFjJXb9zdxoNmrWCkSw4anJeMysL+rCWknX7wVnIBWbJQYoQlpiT+fvAuv/A8Ungen/7+DeVkL52oyeoD5AxbzHlrKd58oxx+weHPDHuY9tFQfUCUmnVE4Co/bxStrdkW7KaGU/35wuNz2DpqRU0Lig9OPraispabRy42Pr1A/JhJHstPs1Zy1TRFWSO9aBW3qX0V6zeWG1Cw71U2EWLlhdz07alsUK0VimNtlyE73sK+rCWmNPSRGaUJa4kPAb+c6evUH8PfPQ/YRcOn94NL/hQdTWUU15ZW1tPgCALT6ApRX1lJWUR3llomEy0xN5tSjRvDKul1YVgwNoCLlbExOU/77/hbww/5PoHFfSK48px9zxtRNXr/6MZE44qTsiDgh3YucuCLSQcAPezdCW7NipUgcy83wdJ2yQ7FRYpRm8yT2OTmPnrwW3r0XWusgLQc8w6LdsiFnbVUdzd7QXFPNXj/rquqi1CKR7p0zdTSVNc2s31kf7aYc5ORs9GTQXpg1Y5Ty3/cnJ24cqIR9G0Jy5akfE4lv2Wl2yo7aSDmke5E/XkSCnFi5ew3UVylWisSxbiekndiYlGofJ6UoNkpM0IS0xD4n51Fb48Fze9Yr51EUTC3IIjU5tNtI87gpLsiKUotEundWUT7GwCtrYyhth5Oz8fKH7fz3406Epv32zTbpH07cILi0q0OuvKkFWaR5QtM7qR8TiR/D21dIRxh4O/1r8SX28aUPqL6ISFfa88raOx8VK0XiV256NxPSTmy84G77uOQaxUaJCZqQlti3a5X9Aakj5TyKitLCPPKz7DurBkj3uCkZn01pYV50GybShVGZKZx4RG5sTUiD/QHQyX9/wd3grYP3/hjtViWObnLllRbmUTI+u/20+jGR+JKZkoQxUBdphTTY/etRs+2f84o14BbpimKlSMLIHdbNhDTYsXDG58G47d3mio0SAzQhLbHPH6FjVc6jqLALJiQzITeNm+Yczb1XzmTB/Fm4XSbaTRPp0tlT8/loVz3b9jX1fHE0jJ4ORRfZKYleuz0kh6McotEz7LzcHQXjhttleOTLJwFwyuQR6sdE4ozLZRielhw5ZYcja6z9/c1fq08V6croGZAcOa+s22V48L9OAOC0o0YqVorEuBEZHvY3eQn0VHg0dThsfFWxUWKCJqQltu1aY68a9AwLfmAyygcYRVW1zZRXHuDzJ07gxtlTmF2Urw+mEvPOmToaiLG0HR0F/FBXBb5mePvukByOcoimzIG8ouBBeNxobrP/284uylM/JhKHstOSIxc1BLvvXPxz++eVj6tPFenKlDlQcOzB406xsqXNTuVxlmKlSMzLSfcQsOBAVzdrnZzxLbX27gjFRokBmpCW2NVQDY9/wb6L9/Wl8Nm/2PlWL39YOY+i5OU19oTeudNGR7klIr03Pjed4jFZsTshvXGhnRff0SGHoxwilxvO+IH9c8nVYXGjodUHQGZqUrRaKCKHYXi6p+sV0hsX2gsaHOpTRSJzueHC39s/F10UFisbg7EyI0WxUiTWjRhmF/zd11Xajm5yxotEiyakJbYE/Pb2kdd/Dn85Dxr3wpWPQ/a4g/lWC+dqMjpKXlqzk2NGZzJ51LBoN0WkT+YU57P8k/388sX1LFq/G39P29kGUzc5HOUQBfyw5U375zHH2qu9OsSN+hZ7IiszNTkarRORw+APWPj9ATbsqovcn+9aBW3qU0V6FPDDhlfsn0cVhsXKRq8mpEXixfDgZ9r/e2tz17FR4w2JMYouEjucbSQ7lh8sYphXrFzRMWJ3XQvLP9nPd886OtpNEekTf8DijQ3VADzw5mYWLPmEkvHZsZMLcfQMO2djx+KtSanq+w6VE0u2vWcfv/Zj+Oj50BXSLfYge5gG2SJxxR+wmPfQUtbvqscfsLjx8RXh/XmkPlW1R0RCObGycql9/O69ULms0wppeyu/JqRFYps/YHH3axsA+Mf7lfxnZZVio8QFrZCW2OFsI+nYSdZ+om0kMeLlNbuwLDhvutJ1SHwpq6hmw+6G9uMmr5/yylrKKqqj2KoOpsyxczZ6MoDgh8bkVOXJP1ROLHEK4rY1hW1JrA9uQx6mlB0icaWsopryytr2lV8R+3OnT3UF/75Ve0QknBMrfS32sa8lLFa2p+zwaGeqSCzr1VjHiY1JqfZxUopio0SdJqQlduxaFToZDdpGEkNeXL2To/OHcVReZrSbItIna6vqaPaGFuxo9vpZV1UXpRZ14nLbK5Iuf9jOkz/zi9C8H978Nbxxp6pg91UvtiQ6K6QztepLJK70qj93+tSSa+zjyWfCrK8NYitF4kAvYmVTMGVHukexUiSWra2qo6Wtl7Hx4j/axyOmKDZK1Cm6SOyINOGibSQxYU99K8u21vCtM6dEuykifTa1IIs0j5umDpMYaR43xQVZUWxVJy63nR+/cC54m2H1P6HsV/ZjnnR7BYOKufZOL7YkHixqqBzSIvGkT/151Qf294+eh82vqx8V6ahXsdL+O1N6K5HY1qfY+OFfAQO718C/r1NslKjSCmmJDTs+hHd+Z2+rTE4HjLZYxpBX1jrpOsZEuykifVZamEfJ+GzSg1tO3QZKxmdTWpgX5ZZ1YcsbgHXwS1Ww+8bZkmiCH6wjxBKnqKFSdojEF6c/9yTZQ5jUZFfk/nzjQti3KXigflQkTHtqm+CN2Qixsn2FdIomqkRimRMbnco46R5317Fxx3LsMQaKjRJ1mpCW6KvZDH+/AjJGwTfeh8/+xd62fvnDulsXI15as5PJozI4On9YtJsi0mdul2HB/Fnce+VMjp+QjTGGP1x9XGwUNIxk1yrweUPPKX1R7zlbEkccCdlHRIwlDS0+jIH0ZMUXkXji9OffKD0SgO+edXTkArW7VkFbc+g59aMiBzmx8ohTISUrcqxsVQFgkXjgxMYJuelMGpnOvVfO7Do29pCqR2QwaUJaoiPgt/OiLvwxPDwX/G1wzVMwfKy9Zf30m+3vmoyOun0NrSzZXMP508dgTIxO4In0wO0yzC7K57YLivEFLBZ/FCMFDSNxttF2pPRFfddaD8lpER+qb/UxzJOEK1ZvSohIl9wuwxnH2Ku+Jo8aFvnmovpRkd5pbbALKUfQ1OrHZSAlSVMGIrHO7TJMGJFOVpqH2UX5io0SFxRdZPAF/LDgUnjyWnjnHmjYDTkT7dVsEnNeXbcbf8Di3GlK1yHxb+b4bAqGp/Li6l3RbkrXnG20yRn2sXEpfVFfODGmfifs+QieutY+7lCnoKHFR6bSdYjErZx0DwD7m7yRL3D6UWeoozRwIqGcWLlzBTRUR46VrT4yUpK0IEUkTuRmeKjtKi7CwdjotmMoyemKjRJVmpCWwbdxIWxfDm0dimjs26jcRTHGH7BYtH4395dtIi8zRek6JCEYY5g7bQxvbtzTnkc45jjbaD/7MEwqBSsA596pHSO95cQYR6f8eP6AxaY9DbT6Aixab99wE5H4kpMRnJBu7GLg7fSj+cWQNVZp4EQ6c3LJWgH7OEKs/Li6HstCsVIkTuSke6jpKi7Cwdh44lfs43N+odgoUaUJaRl8O1eGTkaDchfFGH/AYt5DS/nm31fwSU0TNY1evvjwMn0YlYRw/ozReH0BFq2P4bQdLredtujy/wOTBK/dDm/caac66rB6SSLYtQraIufHc/q28spa9jV6ufHxFcx7aKn6NpE4k+Fx43G72N/Uw43FlCx7ok1EQnWTS9aJle9trqGh1adYKRIncjM81Lf4aPMHur7I5YYjPmX/vHOlfRNKYwuJEk1Iy+CyLKhaEX5euYtiSllFNeWVtTS32cHJF7Aor6ylrCKGJ/BEemnm+BxGZ6Xywuqd0W5Kz9JHQHoObHgJFv8i4pZa6WT0jPB8mMEY4/Rtzpi6yetX3yYSh4wxZKcnd71C2klHsH0ZtNSq7xTprJtcsk6sdCagFStF4kNOejLQTTorsOPgm/9r//zBI4qPElWakJbB9dZd9sRK1lg7nx9Gef1i0NqqOpq9oUGp2etnXVVdlFok0n9cLsO500fzxoYYTtvh2LjQLs4HgBW2pVYimDIHRh0TPAiNMerbRBJHTrqn60G3k44g4LOP1XeKhJoyB8bMPHisWCkS95x0VrXd7R7auBD2VgQPNLaQ6NKEtAy8gN/eZv73z8Prd8D0z8G3Vtr5/M64TXn9YtDUgixSk0O7hzSPm+KCrCi1SKR/nTd9DF5fgNc/ivHVPrtWga819JxSHPXsqLPt70eeCZc+2B5jphZkkeYJjTXq20TiU05GctcT0t2kIxCRoBmft7+PPUGxUiQB5AYL/nabR3rXKmhrCT2n+ChRohLzMrCcLZPbloC/FYwb6neBy2XnRy2cG+0WSgSlhXlkp3toPtCCwf4QWjI+m9LCvGg3TaRfHD8hh/ysFF5cvZOLS8ZGuzldc7bUdsyBmpymFEdd6RhzALa9a6+QLDwHsPu2kvHZvLtpHwDp6ttE4lZOuoeN1Q2RH4zUdyo9nIjNiZWVy+zj3ath2f1hsfK9TfuwUKwUiRfZ6T0U/AXFR4kpWiEtA2vjQqhcak9GA1h+qPpQW0JiXJs/QENLGydNyuWmOUdz75UzWTB/Fm6XiXbTRPqFy2U4d9oYyir20Njqi3ZzujZljr1yyUlxBJAyHKyAihxG4mzTd2JOW3PINkS3y/DIl08C4NTJI9S3icSxnAxP14PukL4TwAXpo+y+U32mDHVOrPQ128e+1rBYuWD+LDJTk5gxbrhipUicyA2m7Oi24K8TH01wbaorGXIm2bsKRQaZJqRlYK17BnzaEhJvnl+1k/pWPzfNOZobZ09hdlG+PoRKwjlv+hhafQEWxXLaDpfb3kLrpDgqPA8adsKTX1aRw0h6sU3fKdY6uzhffZtIHMtJT6a2uY2AU6W0I6fvvPRBSE4HAlD7Cfz7OvWZIr2IlW6XwesPMGtSrmKlSJzI7k1RQ5cbrn4Sssfbx4E2qNkCj31WsVEGnSakZeBsfRtWP0X7qj6HtoTEvMeWfsKRozKYNSk32k0RGTAnHJFDXmYKL67aGe2mdM/lttMbnX4zlFwFuII3+lSIJIyzDbGjTjGnIbgiPjNFWctE4llOugd/wKK+pYtdLi63nSLOKWyoPlPE1otY6Q9YtLQFyFCsFIkbqcluMjzu7nNIA2x6HRo6LMhpU2yU6NCEtPQvp4DhczfCgssgZyJMOPngdvMOFZwlNq2tOsCKbbVcPesIjNFqCElcLpfh7Kn5vLZ+N3e9UsGi9bvxR1ppF0uq1wOd2qhdJwdNmQMFx9P+8SYpxT7uEHPqW+xtjMNSNcgWiWfD0+yVYL9btKHr/nvXKvB32rqsPlOGOidWOgXl3eGxstFr38gZpglpkbjhD1ikJLt5d9Pe7sc1u1ZBmwr/SvQpwkj/6Vggw9cMGMgYAV98zr4Lt2u1fed9ypyDH4Ak5vx96TZSklxcfty4aDdFZED5Axbl22rxBSzuW/xxe9GemM6TqEIkPTOdDjr9Uza0aJAtEu/8AYuH39kCwF/e2coT71dG7r9Hz7BvTHVMH6c+U8SOjc5clQmPlU59Da2QFokP/oDFvIeWUtvkpabRy42Pr+h6XKPxhMQIrZCW/rNxYYfJaADLvvu26fWD280L52oyOoY1tPp4ZsUOLjy2gOHBHFQiiaqsoprNew9+EGvy+imvrKWsIoZzSjuFSFzBv08VIgm1cSHs+AAI2Me+Fvu4wxbEeidlh1ZIi8StsopqtgT7b4tu+u8pc2BU0cHjCLsmRIYcJ1ZawXyxEWJlY6v9WLpH4zaReFBWUU15ZS3OouhuxzXOLgnT9Y5CkcGgCWnpPx8v7DAZHaStH3Hl2fIdNHr9XD1rQrSbIjLg1lbV0ewNLd7R7PWzrqouSi3qBacQSc5E+1iFSEL1olCTs0JaE9Ii8WttVR2tbYGQc1323yHpx8JXgooMOb2Ilc4Kae0mEokPfR7XmPb/QbFRokUT0tI/dq+FlU+gAobxy7IsHl2yjeIxWZSMz452c0QG3NSCLNI6rfxJ87gpLsiKUot6adPrUF918FiFSA7qRaGm+vaUHdoFIhKvet1/b1wIe9YfPI6wElRkyOlFrFTKDpH40qdxTS92SYgMBk1Iy6FzChi+eDM8PBeSh8G4E1XAME6VV9ayfmcdV82aoGKGMiSUFuZRMj67fTuqy0DJ+GxKC/Oi3LIe9GJl05A1ZQ6MmXnwOMIWxIZWFTUUiXdO/+1wagCE9d+7VkFbS+g59Zcy1LUXAA6KECsbgystMzyKlSLxwImLyW57HJ+W3EVcBI0lJGYowsihcQoYbl8GbcEChqOOgS+9oAKGceqxpdvI8Li5ZObYaDdFZFC4XYYF82dRVlHN/725maVbavjN546N3YKGjkiFSJK1G6VdwNfhIHJRQ2MgQ3kxReKW03+f+PPXGJ2Vwn+fXUhpYV7kwk3J6fZOEod274n0WAD44AppxUqReODExV+/UsH9b2zi1nOP4ZqTj4g8rlFRQ4kRWiEth2bjwg6T0QAWVK9VAcM4daCpjf+srOLimWOVK06GFLfLMLsonzsunY4FvLB6Z7Sb1DOnsKGzGwXsD5E7y+1dK0M5l/TGhbBr5cHjLooaDktJ0k4QkTjndhnG56QxMjOV2UX5kQfdU+bAuBNo7yvdKgQrcrAAcFCEWNmgHNIiccftMpxVZK+InjQyo+tFNs5YIinNPjZuxUaJCk1Iy6H5eGGHyeggbfOIW099uJ1WX4CrTlIxQxmajsobxvSxw3m2vKrni6PN5YZ5T8PlD0Pp9yE1Gxr3QNmv4Klr7d0rQ3VSuhfb8xtafGRqgC2SEEYMS2FfQ2vXFziFYNNH2Md+nwrBivRiu36TVzmkReJRflYqALvrWrq+yImNI460jy2/YqNEhSakpXecfNFv3Anv/RHK/44KGMY/f8DitXW7uPf1jUwamUHRmBgv5iYygC4uKWD1jgN8XN0Q7ab0zOW2d6GMORb83uBJy956N5QLHOZNC9+Z0yE2+QMWm/Y00OoLsGj9bvwBKwqNFJH+MnKYh30N3u4v2vQ6tNYHDywVghXJmwZuT+i5TrFy9Y4DALy7aa9ipUgcGZWZAkB1fTc3a8GOjfu3HDxWbJQo0IS09MzJF/3UtbD4F/DK9+1z405QAcM45g9YzHtoKd/8+wr2N7WxY38z8x5aqg+dMmRddGwBLgPPlu+IdlN6b9cq7VZxBPyw7E+hKzuMq71Qk9PnlVfWsq/Ry42Pr1CfJxLnRgxLYV9jK5bVzd/xrlUdbtwFDdV+UqQ9VrYdPBchVr60ehcA336iXLFSJI6kJrvJTk/ufoU0qLChxARNSEvPNi6075Z5G4HghxGXG067yd4yfsZt9vd5TytndBwpq6imvLKWFl8AAK8/QHllLWUV1VFumUh05GWl8qmjRvJM+Y7uJzdiiVOUpCN3kj35MtS23LXnxOzwb+dOhpNvAJe7vc9zxtRNXr/6PJE4NyLDQ5vfoq7Z1/VFo2dAUmroueQ07eqTocmJlVbg4LkIsdIXDJaKlSLxJz8ztecJ6dEz7FjYkWKjDDJNSEvPIt09a2uG3WtVwDCOra2qo9kbOmHV7PWzrqouSi0Sib5LSsZSWdPMh9v2R7spveMUJUnuMCntb4P3/jD0cklHilU+rx2rUJ8nkohGDrO3Ju9t7GZr8pFnQlKn9ARuj4o3ydCkWCmS8PKyUthd10PKjiPPDE/do9gog0wT0hJZx5zR1esJWXEGyhedAKYWZOHqVHk3zeOmuEB5pGXoOmfaaFKTXTyzIg6KG8LBAoenfBNcyQfPD8U8cD2s9JhakEWaJ/TGqfo8kfg2Ypg9mO42j/Sm1+1ihh352+zzIkONYqVIwsvPSqW6pxXSm163Y2FHio0yyDQhLeE654xe+28wbkhKQ/miE8ekkRn4AxZJLoMB0j1uSsZnU1qYF+2miUTNsJQkzirK5/lVVbT5Az0/IRa43PZ220CnCZehlgeuh5UepYV5lIzPbn9IfZ5I/GtfId3QzUqwXaugrfNOvyHWP4o4ehkrnTUripUi8Sc/K4Xq+lYC3eV+V2yUGJAU7QZIDArJGR2UlGKvwHN77DvoU+YoRUec+7+3NpPsNvzqshlU1TZTXJBFaWEe7k6rpkWGmktnjuX5VTt5c8MeZhflR7s5vePkku7Yb3fMJT0U+uvuVnoUzsXtMvzlSydS+MOXOXXyCOZ/epL6PJE4d3CFdDcT0s6K0I4Db+XJlKGqF7FywfxZlP56MclJLm47r0ixUiTO5Gel4gtY1DR522/chlFslBigFdJykJOmY8kfQic1wM4Z7fYoX3SCqKpt5skPtvOFEydw+fHjuHH2FGYX5evDpgjwmaNHkZOezDPlcZK2A5RLGoIrPTrHrsaQlR4tbfaq99nF+erzRBJAbro9Ib23u5QdypMpclAvYqXbZXC5DNPHDlesFIlDeZl2Id9uCxsqNkoM0IS02Dqm6djyZvjjyhmdUP785mYsC75WemS0myISc5LdLs6dPpqX1+zkrlcqWLR+N/7utrzFgpBc0h02Pw2lXNJ508B0+lhjXJA3tf2wvtVeFZaZog1iIonAGENGipvFFdVd99XKkylyUC9iJUBDi48MxUqRuDQyuHvowbe2KDZKTNOEtNg2LoTty8NXRoNyRieY6voWHl+2jcuPG8fY7LSenyAyxPgDFqu3H6DNb3Hf4o+58fEVzHtoaXxMSruTw1dDexthyR/tHTCJvFK6qwVcHc7Xt9h5tjNTNcgWiXf+gMW8h5bS1Opn1fYDXffVEfNkNsLOlYPXWJFY0YtYCdDQ6tPNW5E45A9Y/PKljwB4esWOvsfGoTBmkJihCemhzEnR8cadsPpf4du3MDDpdLj8YXvl3QCm6aivr6ekpKT9a+TIkXznO98JuebJJ5/EGMPy5cvbz23bto2zzz6boqIiiouL2bp1a9hrl5aWhjzHUVZWxvDhw5k5cyZFRUX85Cc/6e9fKyY99NYW2vwBbtDqaJGIyiqq2bTnYH/Y5PVTXllLWUV1FFvVS04u6c62vGnvgEnk9B27VoHVqRClZcHute2HDa32hPQwTUiLxL2yimrKK2txhthd9tVOnszO1j+XuP2hSFd2r4kQKwMhsdLnD9DqC2iFtEgcKquoZv3OuvbjbmPjUB0zSMzQhPRQ1TFFx+JfwJp/h1/jSYeTvz4oOaMzMzMpLy9v/zriiCO47LLL2h+vr6/n97//PbNmzQp53he/+EVuvvlm1q9fz7Jly8jL61sF6E9/+tOsWLGC5cuX8+ijj/LBBx/0y+8Tq/Y3elmw5BMuOraAiSMzot0ckZi0tqqOZm/oB7Bmr591VXVdPCOGOLmkPZ3/vi17pXSipu8I+GH9f8LPdyrO0hBcIT1Mg2yRuNfrvnrKHMidHP4CNVsSsz8U6U4vUnY0ttp/V5qQFok/fYqNQ3HMIDFFE9JD1caFdifjbQQsIMDWWotj/tDIfz3TzIz7m/js09A09lNdvsStt95KcXExM2bM4Hvf+17/NW3jRqqrq/n0pz/dfu6HP/wht9xyC6mpqe3n1q1bh8/nY84cO5XIsGHDSE+PcJcP+Ne//sVJJ53E0UcfzVtvvRX2eEZGBscffzybNm3ipz/9KSeeeCLTpk3jK1/5CpYV49v0++Av72yhyevnG2ccFe2miMSsqQVZpHlCb8KledwUF2RFqUV94OSSvvxhmPiZ8Me9TSGFixLGxoX25FJnuZND0k3VtQRzSKcmD1bLRGSA9Lqvdrmh6MLwF+hUyE1kSOhFyo4Gr3PzVkXsReJNn2LjvKfh0gchf1r4CyXqmEFiiiakhxonTceSP0TMF12x189XrrueVW/8h6xp5/DH+x+I+DI1NTU8/fTTrF27llWrVvGDH/wg7JrFixeHpOFwvk499dRum/j444/z+c9/HmPsT0YrVqygsrKSCy64IOS6DRs2kJ2dzWWXXcbMmTO5+eab8fsjbyvx+XwsW7aMe+65J2Jqjn379rFkyRKmTp3KN7/5Td5//33WrFlDc3Mzzz//fLftjRd1LW385d2tnDttNFPyM6PdHJGYVVqYR8n4bNKDH+ZcBkrGZ1Na2LcdGFHjctuTsM014Y91WjGcMHatipB2Cii6KGSHj5OyQzmkReKf01cnu+zPi+ked9d9df6MXhVyE0l4vUlvFdxNpBXSIvHHiY3B0Nh9bARYdj/sqQg/70lPzDGDxBRFmaHESdOxo4vihcmpjB+Tyqe++QcArpnn4fe//33E1c9ZWVmkpqZy3XXXcf7554dNFgOcccYZlJeX97mZTzzxBAsWLLCbHAjw3e9+l0ceeSTsOp/Px1tvvcWKFSuYMGECn//853nkkUeYP39+2LVO+o/jjz8+JM/0W2+9xcyZM3G5XNx6661MnTqVp556ijvvvJOmpiZqamqYOnUqF14YYWVNnPnbu1upb/FpdbRID9wuw4L5syirqOaBNzaz/JMafveFmbhdXS0rikFdrRjOGAk7y+2fp8wZ8HRMg8bZgtxxkG1ckB/6QVopO0QSh9NX/8+/V/GP5dv51WUzOH/GmMh9daTu27LCJ+ZEEllv01u1akJaJF45sfHSP77DrgMt/PKy6ZQW5kWOjRsXwvblEGgLPe9KgoLjQ3YZigwErZAeSkLSdHTiyYD8GZhORV+cVcqdJSUlsWzZMi6//HKeeeYZ5s6dG3bNoayQXrlyJT6fj+OPPx6wc0evWbOG0tJSJk6cyJIlS7joootYvnw548aNY+bMmUyePJmkpCQuueQSPvzww4ivm5KSAoDb7cbn87Wfd3JIf/DBB3zta1+jpaWFr3/96zz55JOsXr2a66+/npaWli7bGy8aW3089PYWzjwmj2ljh0e7OSIxz+0yzC7K50cXFhOwYNH63dFuUt9EqpwNULcTyn6VeMVKerEFGaC+xYfL0L76XUTim9tlOHHSCABmjBve9Y3DSIXcsGDhbYnTD4r0pJfprRpbdfNWJJ65XYaj8oaR7HYxuyi/69jY1XgBuv5sLdKPNCE9VAT8sOapCJPRBiadbucbvewBtm3bxnvvvQfYqTNOO+20iC/X0NDAgQMHOO+887jnnnsiroR2Vkh3/nr33Xe7bObjjz/OlVde2X48fPhw9u7dy9atW9m6dSsnn3wyzz33HCeccAInnngi+/fvZ8+ePQC8/vrrFBcX9+2/SyfO5PPIkSNpaGjgySefPKzXizZ/wGLR+t3c8OgH7G9q42unHxntJonElakFWRwxIp0XVu+MdlP6pqvK2YE2ErJYSaTJJisQsgXZH7BYv7OOZLeL1z+qxh9InPoAIkNZTrqdE762ua3ri0bPgKSU8PP1OxOnHxTpSS/SW/kDFks27QNgzY4DipUicSo7zcOB7uIidDNe8MGODxQfZcBpQnoocFJ1rP13+GOedDj561A4F1xuioqK+Otf/8qMGTOoqanhhhtuiPiS9fX1XHDBBcyYMYPTTz+du+++u1+a+s9//jNkQro7brebu+66i9mzZzN9+nQsy+L6668/rPfPzs7m+uuvZ/r06VxyySWceOKJh/V60eQPWMx7aCk3Pr6CNzfuxWXgntc26IOlSB8YYzh32hje3bSP/Y3eaDen90IqZxt7611niVSsxEnZ0VGH/LBOf1i2YQ+tvgA3Pr6CeQ8tVX8okgCy0z0A7G/qpo+eMgcyRoef93kTpx8U6UlXsTKY3sqJlQ++ba+ivvPljxQrReJUdnoyDa0+2vzdpKaaMsdOzREphV8ijRMkZmkfTiIL+O27WqufhK1vha8eS0qxJyw6bNFyuVzcf//9Pb70mDFjWLZsWX+3mM2bN3f7eFlZWcjxnDlzWLVqVa+fM3LkyPYc0qWlpZSWloZdf8cdd3DHHXf0prkxrayimvLKWpq89lbUgAXllbWUVVQzuyg/yq0TiR/nTx/D/W9sYuG63Vxx4vhoN6d3nMrZGxfCzpVQ/ijUbgu9JpEKHBrsfLAdWVb7dkOnP3QG1U1ev/pDkQTRvkK6uwlpgNRhcKDTuUTqB0V60stY6Q1OYDW3BRQrReLUwdjYxqjMCDuEHKb9f0KpqKEMAq2QTlTOqugnr4U1/4pctKXoYnvCIlGKWkmItVV1NHtD8yI2e/2sq6qLUotE4tO0sVmMz02Lv7QdLre9+2XMsdC4J/zxTjkj49quVUDnFVxW+8oO9YciiSvHWSHd2M3W5I0LoWZr+PlE6gdFeqJYKTJkDA/GxgPN3dys3bgQtr9vp+joKMLCRZGBoAnpROUUMIyUJwzsbdzTLg+ZjJ44cSJr1qwJu/TSSy8NK0z4yiuvDFTLpZ9MLcgiyR16tzPN46a4ICtKLRKJT8YYzps+hnc+3tvzCrxYtGsVtHUuzmpCckbGva6KkgU/YE8tyCKtUyFD9YciiSErLRljelghHbFwU4L1gyI9UawUGTKcFdL7m7q5WRtxjIAWLsqgUcqORLVrlZ33JxJPRp/ueD399NP92DAZLEVjsvAHLNwuQyBgkeZxUzI+m9LCvGg3TSTunDdtDA+8sZlX1+3mihPiJG2HwylY0rGorSfdXjmdKLr6wBzMnV1amEfJ+Gze27QPC0hXfyiSMNwuw/C05O4H3UOhHxTpSS9j5bItNfgClmKlSBzLTrNXSNf2OTaGL1wUGSiakE5UkTqXpBQougSmXWZPRquTSWi/e20jLgN3XDKNPfWtFBdkUVqYh9sVIUeUiHRrxrjhjMtJ46XVO+NvQtopcLhjuX2j0pOeeNvwxpRAckborqDkjPbJJrfLsGD+LGb+7FWOyE3nO2cdrf5QJIHkpHt6LmqY6P2gSE96GSuveXAJa6vquPvzJYqVInEqu32FtGKjxC6l7EhUTufiyQCM/X38yXDpn+ycojE0GV1ZWckZZ5xBUVERU6dO5Xe/+137Y7fffjtjx45tTxXy4osvtj/2y1/+kqOOOorCwsKQFCIffPAB06dP56ijjuJb3/oWVufiHUPAR7vq+NcHlfzXqZP4wkkTuHH2FGYX5esDpcghctJ2vP3xXg40d7PSIBY5BQ4vfxjOuM3+nmjb8KbMgXGdYt640A/UbpfB6wtwypEj1R+KJJjs9OTuV4ENhX5QpCe9jJXDUpMpyE5TrBSJY86E9AHFRolhWiGdqJzOZeNCu1DF6Okxuyo6KSmJ3/zmNxx33HHU19dz/PHHM2fOHIqLiwH47ne/y/e+972Q56xbt44nnniCtWvXUlVVxVlnncWGDRtwu93ccMMN/PnPf+bkk0/mvPPO4+WXX+bcc8+Nxq8WNb988SOGpSRx45lHRbspIgnjnKmj+fObm7nlyVVcccK4+Fo15BQ4LJwb7ZYMjF7EvDZ/gJa2AMNS9NFHJJH4Axb+gEXF7noWrd/ddd+c6P2gSE96OT5sbPUpVorEubRkNy4DC9ftYvKoDMVGiUmKNImsj53L/fffz/333w/AgQMHmDhxIosXLw67zu/3M3/+fJYvX44xhmuvvZbvfve7h9zMMWPGMGbMGAAyMzMpKipix44d7RPSkTz77LN84QtfICUlhUmTJnHUUUexbNkyJk6cSF1dHaeccgoAX/ziF3nmmWfCJqRvv/12tmzZws6dO9mwYQO//e1vWbJkCS+99BJjx47lP//5D8nJyYf8O0XTWxv38MaGPfzg/CKyg9V1ReTw+AMWv3m1AgO8snYXb23cQ8n4bBbMnxU/k9KJroeY19hqF23SIFskcfgDFvMeWsraqjr8AYsbH1+hvlmkO70YHza2+jSGEIlj/oDFFx9eRsCCZVv3s6ZKsVFik1J2SLuvfe1rlJeX8/777zNu3DhuuummiNeVl5ezY8cO1qxZw+rVq/nyl78cds1jjz3Wnmaj49dnP/vZbtuwdetWVqxYwaxZs9rP3XfffcyYMYNrr72W/fv3A7Bjxw7Gjz+Yx3XcuHHs2LGDHTt2MG7cuLDzkWzatIkXXniBZ599lmuuuYYzzjiD1atXk5aWxgsvvNBtO2OVP2Dx8xfWMz43jXmnHBHt5ogkjLKKasora3ESADV5/ZRX1lJWUR3Vdknv1bcEJ6RTNSEtkiicvtkfsHtn9c0ih69BK6RF4poTGx2KjRKrNCEtYb797W9z5plncuGFF0Z8fPLkyWzevJkbb7yRl19+maysrLBrrr76asrLy8O+nnzyyS7ft6Ghgcsvv5x77rmn/TVvuOEGNm3aRHl5OWPGjOG///u/ASLmhTbGdHk+knPPPZfk5GSmT5+O3+9n7lx7pcD06dPZunVrl+2MZf/+cDsf7arnlnOOISUp9tKziMSrtVV1NHv9IeeavX7WVdVFqUXSV86EdJYmpEUShvpmkf7X0OojI0XjCJF4pdgo8UIT0hLikUce4ZNPPuHHP/5xl9fk5OSwcuVKSktL+cMf/sB1110Xdk1fV0i3tbVx+eWXc/XVV3PZZZe1n8/Pz8ftduNyubj++utZtmwZYK98rqysbL9u+/btFBQUMG7cOLZv3x52PpKUlBQAXC4XycnJ7RPXLpcLn8/X5e8fq5q9fu56tYKS8dlcMGNMtJsjklCmFmSR5gkdnKV53BQXhN+Qk9jU0J6yIz7TMYlIOPXNIv2vsdWvWCkSxxQbJV5omZC0++CDD7jrrrt46623cLm6vlexd+9ePB4Pl19+OUceeSRf+tKXwq65+uqrufrqq3v1vpZlMX/+fIqKisLShOzcubM9v/TTTz/NtGnTALjooou46qqruOmmm6iqqmLjxo2cdNJJuN1uMjMzWbJkCbNmzeJvf/sbN954Yy//C8S3h97ezO66Vu676rguV4WLyKEpLcyjZHw25ZW1NAVXHEwfO5zSwrwot0x6q6HVrjKulB0iicPpmz/4ZD+tvgCpyS5KxmerbxY5RJZl0ej1MUwrpEXilhMbl22pwRewSPe4FRslJmlUJu3uu+8+ampqOOOMMwA44YQTePDBB8Ou27FjB1/+8pcJBAIA/PKXvzys933nnXdYsGAB06dPp6SkBIBf/OIXnHfeedxyyy2Ul5djjGHixIk88MADAEydOpUrrriC4uJikpKS+MMf/oDbbX9w+tOf/sSXvvQlmpubOffcc8MKGiaiPfWt/KlsE+dMzefEibnRbo5IwnG7DAvmz6KsoppX1+3mH+9XctVJE1QYJI6055BWXkyRhOH0zX9YvJHfLtzId846mus/PVl9s8ghavL6sSzIUKwUiVtObLzpH+U8u7KKu68o4azifMVGiTmKNNLuL3/5S6+uO/bYY/nwww/77X1PO+20iLmfARYsWNDl82677TZuu+22sPMnnHACa9as6fY9b7/99pDjhoaGLh+LB79btIFWX4D/N/eYaDdFJGG5XYbZRfmUFuaxaH01r6zbxcUzx0a7WdJLTsoO5ZAWSSxul+GMwnx+u3AjR44apgG3yGFoT2+lWCkS19wuw6zJI3h2ZRUzxg9XbJSYpBzSInHKH7BYtH43tz+3hr8v3caVJ41n8qhh0W6WSMJzuwxzp+Wz+KM9YQVDJDb5AxYrttUCsPyTGvyByDdBRSQ+Zafb+W73N3mj3BKR+OUPWCxctxuArXsbFStF4tzIYR4A9tYrNkps0q1P6dasWbNobW0NOeek15Do8Qcs5j20NCSf7Ue76vEHLN39FBkE504bw6NLtvHGhmrmTlMR0Vjm9Jfvb6kB4Hv/WsWjS7axYP4s9ZciCcKZkD7Q1BbllojEJydWfrhtPwB/e+8T1lbVKVaKxLGRmSkA7GloAYZHtzEiEWhCWrq1dOnSaDdBIiirqA6ZjAZYW1VHWUU1s4vyo9gykaFh1qRcctKTeWnNLk1Ixzinv2wLrvRq8vopr6xVfymSQIalJOF2GWqbtQpM5FA4sbKlza4R1OoLKFaKxLlRw+wJaa2QllillB0icWhtVV1YqoBmr591VXVRapHI0JLkdnHO1NEsWl9NS5vSdsQy9Zciic8YQ3ZaMrVaIS1ySBQrRRLPqPYV0q09XCkSHZqQFolDUwuySHKHbp9L87gpLsiKUotEhp6500bT0Orj7Y17o90U6cbUgizSPO6Qc+ovRRLP8PRkaps1IS1yKBQrRRJParKbzJQk9tRrQlpikyakReLQxBEZ+Px2vmgDpHvclIzPprQwL9pNExkyTj1yJFmpSby0Zle0myLdKC3Mo2R8Nk4KTPWXIokpOy1ZOaRFDpETKz3BBS9pyYqVIolgZGYKe7VCWmKUckiLxBnLsrj9P2tJ97j56cXTqKptprggi9LCPBUdERlEniQXZxXns3DdLry+6XiSdI83FrldhgXzZzH7N2Vg4IfnF6u/FElA2ekedte1RLsZInHJiZU3P7mSf3+4g99+/ljOLh6tWCkS50YO82iFtMQsjZ5F4swLq3fy1sa93HxOIZcfP44bZ09hdlG+PjCKRMHc4tHUtfi49d+rWLR+N/5g4TyJLW6XwWUM0wqGq78USUD+gEVzm49tNU3qi0UOkdtlGDM8lSSXYe5UTUaLxDt/wCJgWWzYXa/YKDFJE9IicaSupY2f/mcd08cOZ94pE6PdHJEhzR+wePjdLQD8+8Md3Pj4CuY9tFQf9mJUfauPzFRtDBNJNP6AxbyHlvL+lv3Ut/jUF4schoYWHxkpSRijyWiReObExpWVB9jf1KbYKDFJE9IiceS3r25gT0MrP790mlYtiERZWUU1q7YfaD9u8vopr6ylrKI6iq2SrjS0+MhMTY52M0Skn5VVVFNeWYsvOMhWXyxy6Bpa/QxL0c1bkXin2CjxQBPSInFi9fYD/O29rcw7+QhmjMuOdnNEhry1VXU0e/0h55q9ftZV1UWpRdKVNn+A5jYNskUSkfpikf7T0NqmWCmSABQbJR5oQlokDvgDFrc9s5oRw1L43jmF0W6OiABTC7JI87hDzqV53BQXZEWpRdKVxlYfgAbZIglIfbFI/2ls9TNM6a1E4p5io8QDTUiLxIHHln7Cqu0H+OEFxWRpy7lITCgtzKNkfDbpHT7szRg3nNLCvCi2SiKpbwlOSGuQLZJwnL44Jcke1qQkuSgZn62+WOQQ1Lf6dPNWJAEoNko8iJsJaWPMp4wxrxpjqo0xdcaYD40x13a6JscY86AxZq8xptEY85oxZnqE10o1xvzaGLPTGNNsjHnPGPOZCNe5jDHfN8ZsNca0GGNWGmMu76J91xtjPjLGtBpjKowxX+u/316Gsuq6Fn79cgWfnjKSC2eMiXZzRCTI7TIsmD+Le6+cyWePGwfANbOOUH73GNQQXCGdqUG2SMJx+uL/Oa8IgC+dOpEF82epLxY5BA0tStkhkgic2HhLcHf19Z+ZrNgoMScuJqSNMTOA14Bk4HrgcuB94CFjzA3BawzwHDAXuDF4TTKw2BgzrtNLPhR8nR8BFwA7gVeMMSWdrvsZcDtwH3AusAT4lzHmvE7tux54AHgq+P7/Av7otE2kr/wBi0Xrd/P7RRv55uMraPH5+enF01TxWiTGuF2G2UX5/O9nZzAqM4X/rKqKdpOkE3/A4o0NewDYWF2v6uIiCcjtMpwfvGlfkJ2mAbfIIfAHLPY1ePlkXyOL1u9WvBSJc26X4azifAAmjchQbJSYEy+3P78AuIELLctqCJ5baIw5Fvgi8CfgIuA04EzLshYDGGPeA7YAtwDfCp47FrgKuNayrL8Ez70BrAV+GnwdjDF5wPeAX1mWdVfwPRcbY44CfgW8GLwuCfg5sMCyrNs6XFcA/MwY86BlWW0D8N9EEpQ/YDHvoaWUV9bS7PVjAeNz0piQmx7tpolIF9wuw4UzCnh0ySccaGpjeLpS68QCpz/94JP9APyxbBNLNtdohYhIAspJ92AM7Gv0RrspInHHiZe1zW3UNrdx4+MrKBmfrXgpEuecdJ8HmjUlJbEnLlZIAx6gDWjudL6Wg7/DRUCVMxkNYFnWAeA/wMUdnnNR8LX+0eE6H/AEcI4xJiV4+pzg+z7a6T0fBaYbYyYFj08BRkW4bgEwAnuSXKTXyiqqKa+spSk4GQ324Kqsojqq7RKR7l1cUoDXH+DltTuj3RQJcvrTVl8AgJa2AOWVtepPRRKQ22XITkumprE12k0RiTtOvHQ0ef2KlyIJIDNYP6WuRRPSEnviZUL6keD33xtjCowx2cE0GbOBu4OPTQXWRHjuWmCCMWZYh+u2WJbVFOE6D3BUh+tagY8jXAdQ3OE6Irx35+tEemVtVR3NXn/IuWavn3VVdVFqkYj0xoxxw5k0MoNnVihtR6xQfyoytORmeKjRCmmRPlO8FElMSW4Xw1KSqGv2RbspImHiYkLasqw1QCn2SucdwH7gD8DXLMt6InhZbvB8ZzXB7zm9vC63w/day7I6J8+KdB0RXrPzdWGMMV8xxiw3xizfs2dPV5fJEDO1IKu9Gq4jzeOmuCArSi0aWvR3KYfKGMNFxxawZMs+dh1oiXZzEsbh/E1OLcgizeMOOaf+VOTwxWqsHJGRwt4GTUjL0HO4f5NTC7JITVa8FOlPsRIrs1KTlLJDYlJcTEgbY6ZgFwxcC1wInAXcD9xvjLnauQyIVHmhc9KrgbiOLq7tlmVZf7Ys6wTLsk4YNWpUX58uCeqkSfY9DBP8Sve4KRmfTWlhXlTbNVTo71IOx8UlBVgWPK/ihv3mcP4mSwvzKBmfTbLbDtXqT0X6R6zGSq2QlqHqcP8mSwvzOGZ0Zvux4qXI4YuVWJmVlqyUHRKT4qWo4S+w8z5f0KFA4CJjzAjgd8aYx7FXJEdajeysjHZWMNcAE7q5rqbD9xxjjOm0SjrSdQTfu2Pi0NxOj4v0ym9e3UCLL8DNZxcSsCyKC7IoLcxTQRGRODB51DBmjBvOM+U7uO7Tk6PdnCHP7TIsmD+Lr/xtOW99vJd7r5yp/lQkgY0Y5mHZVk1Ii/SV22X4wQXFXP6nd7l0ZgEXzChQvBRJEFlpyVohLTEpLlZIA9OBlR0mox3LsAsH5mGvnp7a+YnYOZy3WZbVEDxeC0wyxqRHuM7LwZzRa4EU4MgI1wGs63AdEd6783UiPXr347088u5WvvypiXzjzKO4cfYUZhfl68OgSBy56NgC1uyo4+Pqhp4vlgHndhmy0z2MzPCoPxVJcCMyPOxv8uIP9HnjosiQ19Jm55C+8qQjFC9FEsjwtGTqNCEtMSheJqR3ASXGGE+n87OAFuxVyM8BY40xpzsPGmOysFN8PNfhOc8BycDnOlyXBHweeNWyLKc098vYE9RXE+oaYI1lWVuCx+8Be7u4rgZ4p/e/pgxldS1t3PzkKiaPzOCWc46JdnNE5BCdP30MAD94ejWL1u/WxEgMaGhtIzM1OdrNEJEBlp2ejGXBr1/5SP2vSB/Vt9hFzzJS3D1cKSLxwh+waGz1sWN/s+KixJx4SdlxH/Av4D/GmD8CzcBFwJXA3ZZleY0xz2FPDj9qjLkZO0XH97HT8N7pvJBlWeXGmH8A9xhjkoEtwA3AJDpMKluWVW2MuRv4vjGmHvgQe9L6TOziis51bcaYHwJ/NMbsAF4LXnMtcKNlWdo3KL1yx/Pr2HmgmSdvODWsCJeIxAd/wOK//7USl4ElW2pYteMAJeOzWTB/llYaRVFDq49hqfHykUdEDoU/YPHE+5UAPPDGZv723ifqf0X6oKHVnpDOTNENXJFE4A9YzHtoKcu21OALWNz4+ArFRYkpcbFC2rKsJ4HzsFNoPIhd4PA04BvAzcFrAsAFwELgj8DTgB84w7Ksyk4v+WXgL8AdwAvAeGCuZVkfdrrutuA13wZeAT4FXGFZ1n86te9+7EntK4LXXQl807KsPxzu7y5Dw6L1u/nn8u187fQjOW5CTs9PEJGYVFZRTXllLc7igyavn/LKWsoqqqPbsCGuocXHsBRNSIsksrKKaj7Z1wTYlcbV/4r0TWOrVkiLJBJnXOILDkwUFyXWxM3ozLKsl4CXerimBntl8rU9XNcM3BT86u46P/aE9B29aN8DwAM9XSfS2f5GL7f+ezXHjM7k22dNiXZzROQwrK2qo9nrDznX7PWzrqqO2UX5UWqV1Lf4GJfbuXSEiCSStVV1eH2BkHPqf0V6z1khrR1FIolB4xKJdXGxQlokkf3oubXUNnn57RUlpCRpRYJIPJtakBWWcifN46a4ICtKLRKA+lYfmVohLZLQphZkkZqs/lfkUNW3+Eh2G41HRBKExiUS6zQhLRJFz6+q4j8rq/j27CkKDCIJoLQwj5Lx2aR3+PA3cUQ6pYV5UWyVNLT4yNSKL5GE5vS/jnSPm5Lx2ep/RXqpsVXprUQSiRMXU5PtaT9PkktxUWKKJqRFBpk/YLFo/W5++eJ6/t9Tq5gxNouvnX5ktJslIv3A7TIsmD+Le6+cybdnTyEt2UVhfqYKh0RRa5uf5jY/a3bUqbq4SAJzuwyPXjcrOBE9nHuvnKnCTSK95A9YbKyubx+nKFaKxD9nXPLbK0oAuGD6GMVFiSm6BSoyiJxKt+WVtTQF8zm5XS6MUVAQSRRul2F2UT6zi/LZXdfCf1ZW0ez1h22Zk4HnD1jMe3gZAO9t3sfK7bWqLi6SwNwuw+isVMZmpys/pkgvOeOT97fU4LfgxsdXKFaKJAi3y3De9DHkZnhI9bj1Ny0xRSukRQaRU+m2qUNxgYrd9ap0K5KgLi4ZS6PXz8L1u6PdlCGprKKa1dtr249VXVwk8eVmeNjX2BrtZojEDWd84g8uilasFEk8Bdmp7KxtjnYzREJoQlpkEHVX6VZEEs+sSbmMzkrl2RU7ot2UIWltVR0tbYGQc+pzRRLbiGEeahq90W6GSNzQ+EQk8Y0ZnkZVbUu0myESQhPSIoNoSv4w6LRLRpVuRRKXy2W4qKSANzbs0QRJFEwtyCIlKfSjjvpckcSWm5Gi/lakD6YWZIWlFVOsFEksY7PTqNIKaYkxmpAWGURvb9yLZUFKkguDKsCLDAUXlxTgC1i8uHpntJsy5JQW5jFpVAaA+lyRIWJEhof9TW0EVJRNpFdKC/MoGZ/dfqxYKZJ4CrJTqW/1UdfSFu2miLRTUUORQfLS6p08tnQb80+byKlHjmRdVR3FBVmUFuapuIBIAisek8WUvGE8W76Da04+ItrNGVLcLsNXP3Mk3/lHOf916hF8esoo9bkiCS43w4M/YHGguY2cDE+0myMS89wuw4L5syj64cvMGDecG0qPVKwUSTAF2WkA7KxtIWt0cpRbI2LTCmmRQVBZ08QtT63i2PHZ/L+5RcwuyufG2VOYXZSvD3siCc4YO23H+1v3c8fz61i0fjd+rdwbNI1eHwBfO/0o9bkiQ0BOuj3Q/t2iDepvRXrJsiy8/gCfOXqUYqVIAsrPSgXg/jc2KTZKzNCEtMgAa/MH+NYTK8CCe78wE0+S/uxEhhJ/wKLsoz0APPj2Fm58fAXzHlqqD4KDpKHFnpDOTNWmMJFE5w9Y/N9bmwH467ufqL8V6aXGVruo4bAUxUqRROMPWPzvSx8B8PSKHYqNEjM0MyYywO56tYIV22r51eUzmDAiPdrNEZFBVlZRzfpdByvVN3n9lFfWUlZRHcVWDR0NrT6MsXNiikhiK6uoZvPeRgAs1N+K9FZ9q51Xdphu3ooknLKKatbt1FhEYo8mpEUGUFlFNQ+8sZmrZk3g/Bljot0cEYmCtVV1NHv9IeeavX7WVdV18QzpT/UtPoalJGGMth+LJLq1VXW0tgVCzqm/FelZQ2twN5FWSIskHI1FJFZpQlpkgOyua+G//7mSY0Zn8qMLiqPdHBGJkqkFWaR1Wp2b5nFTXJAVpRYNLQ2tPg2wRYYI9bcih8ZJb6UV0iKJR7FRYpUmpEUGgD9g8Z0nymny+rnvqpmkJmuruMhQVVqYR8n47PaUEQYoGZ9NaWFedBs2RDS0+MhMVTVxkaHA6W8d6R63+luRXqgPrpBWDmmRxOPERqdWqWKjxApNSIv0I3/AYtH63Vzz4FLe27yP2y8q5qi8zGg3S0SiyO0yLJg/i3uvnMnsY/KwgB9eUKwK9oPAH7D4pKaR+pY2VRQXGQKc/jY7LZmpBVnce+VMFsyfpf5WpBv+gMWSTfsAWFt1QLFSJME4sfHovEzGZqcqNkrM0IS0SD/xByzmPbSUbzz2Ie9t3ofbZXi2vEof6kQEt8swuyifX14+HZeBl9bsinaTEp7TJ1fsqqfqQIsqiosMEW6XYfTwVMYMT2N2Ub4G3CLdcGLlX97ZCsDPX/hIsVIkAbldhgkj0slMTVZslJihCWmRflJWUc2KbbW0+OxiOv6Apeq1IhIiLzOVWZNG8MKqKixLg72BVFZRTXllLc6YWhXFRYaOnHQPtU3eaDdDJOY5sdLrt8cvzW2KlSKJKjM1mfpgvniRWKAJaZF+smr7AZrbVL1WRLp3/owxbNrTSMXu+mg3JaGporjI0JWdnkxtc1u0myES8xQrRYaOzNQk6loUGyV2aEJapJ+sjfDBTdVrRaSzudNG4zLwwqqd0W5KQlNFcZGhK1srpEV6RbFSZOjITE2iodVHQCl5JEZoQlqkHzxbvoPX1u9mzPBU0j1uDKpeKyKRjRyWwilHjuCFVTuVtmMAORXFHeqTRYaOnPRkapva1MeK9MCJlUnBfLKKlSKJKzM1CcuCRq/Sdkhs0IS0yGFav7OO//fUKk6amMvi75Vy75UzuWnO0apeKyJdOnfaGDbvbeSHz65l0frdKh40ANwuw31XHgdAaeEo9ckiQ4Q/YLG3vhVfwOKFVTvVv4p0w+0yLJg/i2PHDyc3w6NYKZKg/AGL7fubAXh5zS7FRokJSdFugEg8q23y8tUFHzA8LZn7rp5JarKb2UX5zC7Kj3bTRCRG+QMWz5bvAODRJZ/w7w+3UzI+WwPAAdDUZq8AOW/aGPXLIkOAP2Ax76GlLN+6H4Cbn1zJ35dtU/8q0g23y5DuSWJCbrpipUgCcmLjB5/YsfGHz67h6RU7FBsl6rRCWuQQ+QMW336inJ0HmvnTNceTl5ka7SaJSBwoq6gOyTnf5FVF+4HS0GpPSA9L1f13kaGgrKKa8spavP4AAM1tAfWvIr3Q0OojU7FSJCE5sbHVZ8fGFsVGiRGakBY5RL97bQNvbNjD7RdN5bgJOdFujojECVW0HzwNLcEJ6RQNskWGAvWvIoemocWnWCmSoBQbJVZpQlrkECxct5vfv/4xV5wwjqtOmhDt5ohIHFFF+8FTH5yQ1qovkaFB/avIoWlo1YS0SKJSbJRYpQlpkV7yBywWrd/N7c+t5Vt//5DpY7P46cXTMEZ5l0Sk95yK9ukdPhiqon3/8wcs3tu8D4C1VQdUvEVkCHD617Rku39Ndhv1ryI98Acsahu9fLynQYWWRRJQ57GHYqPECk1Ii/SCUwjgxsdX8Mi7W2n2BfAkuUl2609IRPrGqWh/75UzOX/6GAC+UXqUior0I6fPfuSdrQD8/IWPmPfQUg2yRRKc07/+/soSDHDO1NEq2iTSDSdeNvsCrNhWy42Pr1C8FEkwHcceniQXn5kySrFRYoJm00R6wSkE0NQh99L6nXUqBCAih8TtMswuyufXn5tBusfN86t3RrtJCSW8sJkKR4oMFW6XYU7xaHIzPAxPS9aAW6QbTrx0qNCySGJyxh7jstNI9bgVGyUmaEJapBfWVtWFTEaDCgGIyOFL9yQxpzifl9bsxBusfC2HT8VbRCQnw8P+Jm+0myES0xQvRYaWkcNS2FvfGu1miACakBbplUavL+ycCgGISH+46NgCapvaePvjPdFuSsJQ8RYRyU33UNOoCWmR7kwtyCI1OXRKQPFSJHGNGOZhn2KjxAhNSIv0YGVlLX95ewuZKUmke9wYIN3jViEAEekXn54yiuFpyTxXXhXtpiQMp3iLsx1RfbbI0JOTkcz+xrZoN0MkppUW5nFUXiaAxjgiQ8DIYSnsbdAKaYkNSdFugEgs23mgmev/tpy8rFT+fcOprN5xgHVVdRQXZFFamKfcSyJy2DxJLuZOG80zK3Yw/tWK9oGg+pdD5xRv+dz97/LJvibu/OwM/TcVGUL8AYtmr5/K/U0sWr9bf/8iXXC7DP8952i+9Mj7fP7E8cwpztffi0iC8gcsDjR7qW1q45W1uzirKF9/6xJVmpAW6UKT18d1f11Ok9fPgvmzyMtKZXZWKrOL8qPdNBFJIP6AxZodB2j1Bbj39Y/bVyep+vXhcbsM6Z4kjhiRrn5bZAjxByzmPbSU97fU0BawuPHxFepTRbrR1GbnkP6vUydSNEapOkQSkRMbl2+tAeA7T5Qzc4Jio0SXUnaIRBAIWNz0j5Ws31nHvVfOpHB0ZrSbJCIJqqyimi17G9uPVeG+/9S3+hiWmhztZojIICqrqKa8spa2gAWoTxXpSUOLXSsnM1Vr1UQSlRMbvX47Nja3KTZK9GlCWiSCu16t4OW1u7jt/GLOOEY51ERk4KjC/cBpaGkjM0UDbJGhRH2qSN/UtwYnpFN0A1ckUSk2SizShLRIJ//+cDt/LNvElSeN59pPTYx2c0QkwU0tyCLN4w45pwr3/7+9ew+Pqrr3P/7+ziThHm7lDgoKIiACVcRSbbl4oVr09Gir1HoEta2eyvHRX7UX7TnWerR3W6GttlqhqGjVWi+nVSsStF5ACgG5BVBuEiRIIAFCbjPr98fMDpNkQgaSzG1/Xs8zTzI7a5I1O3uv715r9vqu1nGwqpbOGpAW8RW1qSLHxrtDulO7YDMlRSRTKTZKOtKAtAiRnEqL1u/mO8+u5vZnVnP2kB7cfelpmCmfkoi0rUnDezN2UDc6Ri8SDbTCfSsIhR37K2rYXHKARet3E4pO3xeR7Oa1qe1zI92cdjkBtakiTQiFHWuLy8gJGEs27lGsFMlSDfsbOQFTbJSU04C0+J6X4P+mJ1bw1Hs7CIUdYRwBDUaLSBIEA8aC6yYwZ8Y4zhvRGwfcduFwLTDSAl67XlUb5l/b9zN74UqufmSpOtoiPuC1qff9+2gA/v3TA7Rok0gcXqx8fUMJtdEFQBUrRbJTbH/jU53zGNU/X7FRUk4D0uJ7XoL/wzVhABywZme5EvyLSNIEA8bUEX345RVjaZcT4C8rdqa6ShnNa9c9WtRMxF+CAePSMQMIBoyendqpwy0Shxcra7UAqIgveP2NsYO6c7gmpNgoKacBafG91R+VUaEE/yKSBvLb5zLttL48X7iTyppQ8y+QuLRwi4gEAkbPTnnsOVCV6qqIpCXFShF/OqFHR3aUHsY5zYaQ1NKAtPhaOOx498O9jbYrwb+IpMqXzxhEeWUtr67bneqqZKxR/fNpl1v/Ekftuoj/fKpzO/Yc1IC0SDxa5EzEnwb16MDhmhB7D1WnuiricxqQFl/7ySsbWLqllBN6dKRjXhADOuYFleBfRFJm4sk96d+1PQ8WfMADizZpQb7jMGl4b4b17gygdl3Ep0JhR8BgbXGZ2lGROLxFzrxJ+4qVIv4woGsHAH7+apHio6RUTqorIJIq89/eykNLPuRrZ5/AXdNHsWTjHtYVlzOyfz6ThvdWTiURSQlHZKr5ul3lrN9VTodoB1ELjyQuGDBuOe8Urp2/nCvPGsR5I/qoXRfxEW+xtvUfHyAUXaxN7ahIfd4iZ+Pv+Qf9unXg1vNPUawUyXKhsOO3Sz4A4MllO3ihsFjxUVJGd0iLL728Zhd3vbiW80f24YeXnEZOMMDUEX2YPXUYU0f0UWMsIilTUFTC3ugUc4cWGTpeFdEc3Nd+dojadRGf8RZrC2mxNpGjCgaMmrBj/OAeipUiPlBQVMLG3Qfqnis+SippQFp8Z/nWUm5+spCxg7rxwJXjdOElImllbXE5lTXhetu0yNCxO1hZC0Dn9poMJuI3WqxNJDHhsONgVS35ipUivqD4KOlEA9LiKx/sOcj1f1pO/24deOSa8Y0W8hARSTUtMtQ6DngD0u3UyRbxG7WjIompqAnhnD68FfELxUdJJxqQlqwXCjsWrd/NfX9bz1cefIegwfxZZ9GjU16qqyYi0oi3yFD73EiIzgsGtMjQMQqFHat37gfg3Q/3arEWEZ/x2tG8nEg72j5X7ahIPGUVNQAs21Kqxc1EfMCLjx4tZiqppAFpyWreojazF67koTc+ZO+hagZ078iA7h1SXTURkbi8RYbmzhhH53Y5jB6Qr4VGjoHX7v/9/Y8BuPnJQq5+ZKk62SI+4rWj3/jcSQDcdsFwtaMiDYTCjpueWAHAa+tLmL1wpeKlSJbz4mMwAGcN7sGcGeMUHyVlNCAtWc1b1KYiJk/S5pKDStovImktGDDOG9mX6WP6UbT7IGGnzmGivHa/VouZifhaMGBMPLknACP656uzLdJAQVEJ6z8+kjdW8VLEHyLx0Bg/pLsWM5WU0oC0ZLX3d5bVG4wGJe0XkcwxaXhvDlbVsnzrvlRXJWNosRYR8Xg55A9VhZopKeI/a4vLqdIiyiK+5JzD0EC0pJYGpCVrOeco3LG/0XYl7ReRTPHZoZ8iJwDz397CA4s2Kb9jArRYi4h42udG2oK/rPhI7adIA6P659flWfcoXopkv1DYEXawfKtyx0tqaTldyVr3v7aJgqI9DOjWnn0VNRyuDtFBSftFJIN0yA3SqV0ur6zdzStrd9e1Ycr11jRvsZZ3P9xL2GmxFhG/CoUd3//L+wD8fc3HLNm4R+2nSIxJw3szsHsHPthzCAP1k0R8wFtrBeDdLaWs3lmm2CgpowFpyUrz3orcTfiVMwdy75dGs2TjHtYVlzOyfz6ThvdWYysiGaGgqISK6lq8+xZi8ztOHdEnpXVLV95iLef85HW6tM/hO9NOVbsv4kMFRSWs2xU/P67aT5FIvLxi/CDu/dsG/nPyUD59QjfFS5Es56214lFslFRSyg7JOs8X7uSuF9dxwcg+3Pul0eQEA0wd0YfZU4cpab+IZJS1xeXUhupPo1N+x+YFA4ZzMHZQN7X7Ij6lfPIizfPW2rn1/FMUL0V8QLFR0onukJaMFwo7CopKWFtcTsg55i7axIQhPXhgxjhygvrMRUQyl5cPOXZxVuV3bF4o7NhfUc3mkoMsWr9bd3yJ+JDaT5GjC4Uda4vLyQ0aBUUlipUiPqDYKOlEA9KS0bwcSIU79nO4OoQDOuUFeejqM+oWshERyVRePuQV2/dRWRMmN2jK79gMLy5U1oZZsX0/sxeuVG48ER9SPnmRpnmxctmWUmrDTrFSxCe82Oid+4qNkkq6fVQympcDqSI6GA0QdvCvbftSWi8Rkdbg5UP+zVc/zYk9O9IhN8gf/uNMdRaP4mi58UTEP7z2c9LwXuQFAzxw5VgNtolEebGyNhzpQSlWiviDFxu/dvYJANx58QjFRkkZDUhLRouXA6myRjmQRCR7BAPG1BF9+Ollp1NeWcvTy3ekukppTbnxRMQTDBgTT/4U1aEwZ5zYQx1ukSjFShH/CgaMy88YBEB+h1zFRkkZDUhLRuvdpV2jbcqBJCLZaMJJPRk/uDsPvfEh1bXhVFcnbY3qn0+73PqXN4oLIv51Ys9OAGwrrUhxTUTSh5dHNpZipYh/nNKnC7lBY81OfQglqaMBaclYxfsPM+f1TQQCRvvcAIbyA4pIdvvW5KHsKqvk3r+t44FFm1i0fjehsGv+hT4yaXhvhvXuAqC4ICIM7N4BgN8v+UBtpkiUl0fWuy9SsVLEX4IBo1/X9vz9/V2KjZIyWtRQMlJJeSVf/cO7lB+u5dkbJrL3UBXrissZ2T9fK0SLSNY6Z+in6JQXZP7b24DI3UxahKi+YMC49fxTmDXvPa48axDnjeijuCDiU6Gw44cvrgXgb2s+pmDjHrWZIhzJI3vGj15lYPeO3HL+KYqVIj7hLWpavL9Si5pKSmlAWjLOJwer+OrDS9lzoIo/XTeBsSd0A2DqiD6prZiISBtbsnEPtWFXt4hr7CJEagOPOFRdC8Cszw7hlD5dUlwbEUmVgqISVn9UVvdcbabIEcGAURNyTDipp84HER852qKmagskmZSyQ9JeKOxYtH43DyzaxAuFO7nqD+/y0b4K/jhzPGec2D3V1RMRSZq1xeWN8kdrEaL6QmHHe1tKAVi1Y7+mIIr4mBZuE2ladW2YQ9Uh1haXacq+iI8oNkq60B3Skta86SSFO/ZzuDqEGTgH82edxYSTeqa6eiIiSeUtQlQRcxGpRYiO8GLGe1sjA9L/88Janlu5U1MQRXxKbaZIfKGw42uPLAXg3Q9LWf1Rmabsi/iEYqOkC90hLWnNm05SUR3CAWEHeTkBasLhZl8rIpJtvEWIcqKdRS1CVJ8XM2pCjacgioj/aOE2kfgKikp4/6P9dc8VL0X8w4uN7XIiw4HtcwOKjZISGpCWtBZvOkl1bVjTSUTEl7xFiGacNQiA//7iSN3NFENTEEUkltdm9uvWnmG9OzNnxji1mSJE4mVljVKAifiRFxuvP3cIAN+Zdqpio6SEBqQlrQ3t3Qlr0C5qOomI+FkwYFx+RmRA+s1Nn1BQVKK8j1HeFMRYihkiEsAIO7WTIp5R/fPr7o70KF6K+EcwYIwd2A2ATbsPqj8hKaEBaUlbh6tD/OntbXVpOgxNtRQRCYUdP/77BgD+7/1dzF64kqsfWaqLSI5MQQxGr24UM0T8zcsrv7PsMB/sOaT2UiRq0vDeDOnVCUB9LBEfCoUd97+2EYCFy7YrPkpKaFFDSUuVNSG+/qflLNtayi+/PIauHXNZV1zOyP75TBreW9NJRMS3CopKWNVE3sepI/qkrmJpwJuCOH3OPyk9VM3/fuk0xQwRH/Pyyns3R6u9FIkIBoxvnHsSt/x5FddMHMy5wz6leCniIwVFJXyw5xAADsVHSQ0NSEtaCIUdBUUlrC0uZ1ifzjz+7jbe+mAvP798DP9+xkAANYwiIhw9T7LayYjK2lCjqcgi4j9qL0XiC4Ud/9q+D4DRA7pqMFrEZ9YWl1NdGz+PvOKjJIsGpCXlvOmUhTv2c7g6hBmEHfz4stFcFh2MFhGRCC9PckXMIIvyPkZ48WTLnkM4YPbClYwd1E0LtYj4lNpLkca8WPne1lIAfvD8Gp5d8ZFipYiPjOqfT/vcIIdrFB8ldXT7kKScN52yojqEIzIYnRcM0Ktzu1RXTUQk7Xh5kjvGLN43sl++8j4SMz0/+jx2+qGI+I/XXuYGI4NsypMrciRW1oQi0VKxUsR/vPjoUXyUVNCAtKRcvOmUNaEw64rLU1QjEZH05eVJnjNjHNefM4SAwdgTuumuJo4+PV9E/MdrL2dOHAzAd6adqrtAxfcUK0UkGDAeu34C3TrkMKp/PnNmjFN8lKRTyg5JuaG9O2NG3YIzoOkiIiJHEwwYU0f0YeqIPpQcqGTBO9vICwY448Tuvs4Dqen5ItJQMGBcOKovf3hzCyu272Ng9w6+bidFFCtFxNO9Yx4HK2tTXQ3xKd0hLSl1qKqW+W9vqUvTYWi6iIhIokJhx/bSCqpqw/y24ANmL1zJ1Y8sJRR2zb84C00a3pvRA7rWPVc8EZFQ2PGTlzcA8Hxhse/bSRFvqn40k41ipYgPebnkt5dWsK20QrFRUkJ3SEvKHKisYdaj77Fyx37u/8oY8jvksq64nJH983XniohIAgqKSti4+2Dd89g8kH5cITsYMH7xlTGc85PFnDeiDzPOGqR4IuJzBUUlrI1JReD3dlLES2XzhV+/waGqEHdfOkqxUsRnvFzy0VTyio2SEhqQlqQKhR0FRSX8a9s+/r7mY7bvPcQDMz7Nxaf3A1DjJyJyDI6WB9KP7Wko7Fi8IbIo08m9OqmDLSJqJ0WaUFkTol2OJkyL+JFio6QDDUhL0njTQgq376eiJtL4ndq3C9NO65vimomIZCblgTzCizErtu8DYN7bW3l/Z5kWaBHxObWTIvV58XJH6WEcMHvhSsYO6qZ4KeIjio2SDvSRqCRNQVEJK2MGowG2l1ZQUFSSwlqJiGQuLw9kx7wgAAHDt3kgvamHlTVhAKpqw3VTD0XEv7x2MqB8uSLAkXjpZYqNnaovIv7gxcbcaDL5DrmKjZJ8GpCWpFn6YSmHa+JPCxERkWPn5YGcM2McZw/pQdjB6AFdKSgq8d2iJEebeigi/hUMGPNmnUWfru3p0j6H688ZwrxZZ+lOUPEtxUsR8WLjucM+BcCV4wcpNkrSaUBakmJHaQV/WflRo+2aFiIi0jLBgDFpeG8ORTuXD73xoS9XyvamHsZSjBGRUNgx89Fl7C6r5EBlLQ//cwszH13mq/ZRJJbipYh4sfGfm/cC8OR72xUbJek0IC1tIhR2LFq/mwcWbeLxd7fx5Qffpro2zOkDutIxL4ihKZMiIq2loKiED/YcrHvux+m3k4b3ZszArgSjVzZ5OQHGDOyqGCPic156Aq+P7cf2USTWucN6MaBb+7rnHXID6pOJ+IwXG6trI6nuDtco1Z0knxY1lFZXt3jhjv0crg7hgJyA8ddvfZYR/fIpKCphXXE5I/vnM2l4b00LERFpIa2UHWFmgAEOq3suIn6m9lHkCO+uyB37DgMQNBjcs5Om6ov4jGKjpAPdIS2tzvu0rSI6GA2QEzR2l1cSDBhTR/Rh9tRhTB3RRxc+IiKtQNNvj8Qeb6qhFjUUEVD7KBKr4QLAIQfbSit4c9OeFNdMRJJJsVHSgQakpdXF+7StqiashTJERNqIt1J2x+iFZcCgZ6c8ws75JhecFmkSkXgapvNpp3Q+4mOKlSICjfsOhv/6DpJ6GpCWVhcKOxo2Yfq0TUSk7QQDxoLrJvDrK8bSKS9I2MFH+w5z85OFvlncUHd6iEhTzAwjMivPOaXzEf9SrBQRqN936NwuiMN/fQdJPQ1IS6t6YVUxc1/fRKe8IB1ytXihiEiyBANGIGDURi8gHf5avMu708PLBKXYIyJwJEWB1zZWh5TOR/zLi5V50SkDWtBQxL+8vkN1rT/7DpJ6GpCWFguFHYvW7+b6+e/xXwtX8ukTu/PWd6cw96vjuPX8U5gzYxwLrpugfNEiIm1sbXF53WrZHr9MxQ0GjHmzzqJ3l3Z07ZDL9ecM0SJNIqIUBSIxvFg54aQeAFx99mDFShEfW1tcTk3In30HSb2cVFdAMlso7Lj6kaW8t7WUmpAjaJELnS7tc5k6oo9WaBURSSJvKm5FzOCLX6bihsKOmY8uY3d5FQ54+J9bWL5tnz4QFfE5P7eLIg15sfK9raUAPLZ0G2uKyxQrRXxqVP982ucGOFxzZFBaMVKSRXdIS4u8vmE3y7ZEBqMhslLz6o/KNMVDRCQFGi5QAtAnvx3v7yxj0frdWZ0PzpuW771DTTkUETjSLnbIjXR7DDihR0fOHdYrtRUTSQEvVnp9N8VKEX+bNLw3p8UMPmvhX0kmDUjLcasJhfnlPzbW5eTzaIqHiEhqeAuUzJkxjhs+fxJBg217K/j1a5uYvXBlVi9Somn5IhKPl6JgcM9OBCySI3N7aQUzH12Wte2hSFMUK0WkoZxg/YVOtfCvJIsGpOWYePmif/FqEV/67Vus33WA3GD9BktTPEREUicYMKaO6MP4wT3ICQYIO38sUuJNOYzVPjegeCQivLlpD9tKK/DGn7O9PRRpimKliMQqKCph1Uf7655X1WrhX0keDUhLwrx80Tc9sZI5r29mzc5yTu7ViTNP7E7HvCAGdMwLaqVmEZE04LcFDs8d1ovcYP3LmrycgKbli4juChWJOndYL/JyFCtFJELxUVJJixpKwgqKSli5fV+9hPe7yir57hdOJWDGuuJyRvbPZ9Lw3loUQ0QkxUb07UJO0OryREJ2z2B5c9Oeeu8VoCbkeHPTHi2wK+Jz8RZt0l2h4keKlSISa0TfLgQDVi8Nazb3FyS9pPwOaTMbaGZzzOwdM6swM2dmg+OU625mD5vZJ2Z2yMxeM7PRccq1N7OfmdkuMzsc/b2fi1MuYGbfM7OtZlZpZqvM7LIm6vh1M9tgZlVmVmRmNzRR7t/MbGX0920zszvNLBivbCZasnFPvQt5iHx6tmHXAaaO6MPsqcOYOqJPmw1G33HHHQwaNIjOnTvX215VVcUVV1zB0KFDmTBhAlu3bq372bRp0+jWrRtf/OIX673muuuuY8yYMZx++ulcfvnlHDx4sNHfmzdvHjfddFPcugwePJjRo0czZswYLrjgAj7++OOWv0ERkVYSCjsefXsrtTGdzoCR1YuUrC0up7JGd3iISGO6K1QkQndDioinrr8Q9k9/QdJLygekgaHAV4B9wJvxClgkq/oLwDRgNnAZkAssNrOBDYo/Anwd+G/gi8Au4BUzG9ug3I+Au4C5wBeAd4GnzeyiBn/768BDwLPRv/808Fszu7FBuQujZd6L/r5fA3cC9za/C9KTly/6gUWbeGjJBzy9fEejMsn89Gz69OksW7as0fZHHnmE7t27s3nzZm655Ra+853v1P3stttuY8GCBY1ec//997Nq1SpWr17NCSecwNy5c4+5PosXL2bVqlWceeaZ3Htvxv6bRSQLFRSVULhjP7H3QOUGA1x7zpCsncHi3REeS3d4iAgc/a5QET9RDmkR8Xj9hVjZ3l+Q9JIOA9JvOOf6OOcuIjLYG88lwDnA1c65hc65l6PbAsDtXiEzGwN8FbjFOfcH59wiIoPd24G7Y8r1Br4N/Ng593Pn3GLn3DeBxcCPY8rlAP8LLHDO3REtdycwD/iRmeXG1PHHwD+dc9+IlvslkcHoW8ysbwv2T0p4+aJnL1zJ/f/YyH1/30D1vt3snfef7P/7/RT/8SZKn7+P03q3b/LTs+9+97uMHDmS008/nW9/+9strtPZZ59Nv379Gm1//vnnueaaawC4/PLLWbRoEc5FOh1Tp06lS5cujV6Tnx+56HLOcfjw4SZXki0uLmbatGkMGzaM22+/PW6Zz33uc2zevJlly5YxceJExo0bx8SJEykqKjqu9yki0lLx7oCqrg2zYdeBFNWobekODxE5Gt0VKhKh2QIi4vFbf0HST8oHpJ1z4eZLcQlQ7JxbHPO6MuBF4NIG5WqAp2LK1QJPAheaWbvo5guBPOCxBn/nMWC0mQ2JPv8M0CtOuQVATyKD5JjZIGBsE+VyidwxnVG8T8sqqkNH7rAz4+Du7fzw9pv5xcJXmThiEGcefi/up2elpaU899xzrF27ltWrV3PnnXc2KrN48WLGjh3b6DFx4sRjquvOnTsZNGgQADk5OXTt2pW9e/c2+7pZs2bRt29fNmzYwOzZs+OWKSws5KmnnuL999/nqaeeYseOxneJv/TSS4wePZpTTz2VN954g5UrV3L33Xfz/e9//5jeh4hIaxnVP58OefUzRgUMqkMhHli0iUXrdxMKuyZenXnq7giPeUu6w0NEPPHaxLycAKf2bXzTgkg202wBEfHEi425wQAf7DmYdX0FSU+ZsqjhKGBNnO1rgf8ws87OuYPRcluccxVxyuURSQ+yNlquCtgcpxzASGBLtBxx/nZsucVNlXPObTGzimi5jLJmZxkVDT4tq6oN0b1XP26+ajoAo+zrPPDAA3DbbY1en5+fT/v27bn++uu5+OKLG+VwBpg8eTKFhYUtrqtzjRvKpu54jvXoo48SCoWYPXs2Tz31FLNmzWpUZurUqXTt2hWAkSNHsm3btrrB78mTJxMMBjn99NO55557KCsr45prrmHTpk2YGTU1NS18ZyIix2fS8N6MHdSNwh37OVwdImAQcvDgkg+pDTk65AUZO6gbC66bkBUDtke7w+P8kRk3SUlEWtmk4b0ZM7ArS7eU4vWva0JhHn17K1PacP0TkXRztNkCWtRQxF9i+wve2E91KMzzhcW8um53VvUVJD2l/A7pBPUgkmO6odLo1+4JlusR83W/azySGa8ccX5nouW8bT3ibMfMvmFmy81s+Z49qf9U2ssZff8/NvLymsaL9LXPDZLbYIpXUwO/OTk5LFu2jMsuu4y//vWvTJs2rVGZ1rpDeuDAgXV3LtfW1lJWVkaPHnF3eSPBYJArrriCZ599Nu7P27VrV69sbW1tvfoXFhbypz/9iW7duvGDH/yAyZMns2bNGl588UUqKyuP6X1Ieki381LkeAQDxoLrJjBnxjhuPf8Ubpx8MsGAURNyOKCiOkThjv0UFJWkuqrNSuScVE5MkeTKtFgZDBjXnjOE3OCRdiLsyJh2UKQ5iZ6To/rn0y6nfv9N8VKkbaR7rIztL/zb2P7kRtdiybS+gmSuTBmQNiDefIGGo6FtUY4myiZarsmPk5xzv3fOnemcO7NXr9Tm7YrNGf3rRZtY//EB2uUE6JAbwICOeUFG9sunZNdO3nnnHQAWLlzIOeecE/f3HTx4kLKyMi666CJ+9atfxb0T2rtDuuHj7bffPqa6X3LJJcyfPx+AZ555hilTphz1DmnnHJs3b677/sUXX+TUU089pr8ZT1lZGQMGDABg3rx5Lf59khrpdF6KtEQwYEwd0YfZU4eREwg0mnaXKflTEzknlRNTJLkyMVauLS6nqrZ+psBMaQdFmpPoOXnusF7kBBUvRZIhk2Ll7vLKRul8FCOlrWVKyo5S4t9l7N0ZvS+m3AlHKVca87W7mVmDu6TjlSP6t3fFlOtxlHINdYv5edoqKCph5fb9HK45MoUrGDCuj95NMrJ/PoPbVbB5wQjmz5/PN7/5TYYNG8aNN94Y9/cdOHCASy+9lMrKSpxz3H///S2u4+23384TTzxBRUUFAwcO5Prrr+euu+7iuuuu4+qrr2bo0KH06NGDJ598su415557Lhs2bODgwYMMHDiQRx55hPPPP59rrrmG8vJynHOMGTOG3/3ud61Sv2uuuYZf/vKXTJkypcW/T0SkNYTCjlfiznrJnjuijpYTU1OQRcQP7aBIIhQvRcTj3ZQYm7IjVoe8oGKktKlMGZBeC1wQZ/tIYHs0f7RX7ktm1rFBHumRQDVHckavBdoBJ1M/j7SX63ldTDmI5IjelWC5d7xCZjYY6BhTLu2Ewo6CohLmvL6p3mA0RD4Ryw0GmD11GABbt24lEAjw4IMPNvt7+/Xrx7Jly1q1rj/96U/56U9/2mh7+/btefrpp+O+5s0334y7/a233mr2782cOZOZM2fWPX/ppZfqvt+6dWuj8p/5zGfYuHFj3fMf/ehHzf4NEZG2VlBUwrbShksrwIk9OzFpeO8U1Kj1rS0ub3QhXaGcmCIS5Yd2UCQR7+8sa3KmgOKliL94i4LHG4zuGF1vRjFS2lKmpOx4ARhgZp/3NphZPjA9+rPYcrnAl2PK5QBXAK8656qim18mMkB9VYO/8zVgjXNuS/T5O8AnTZQrBd4CcM5tB1Y1Ua4G+HuibzSZvE/EvvX4Cgp3lDX6uT4RExHJfPEWMDLgC6f1y5pFSkb07ULDtxIwOLVvl9RUSETSih/aQZHmaKaAiMRqKjZ+9uSezJkxTgsaSptLizukzezy6LdnRL9+wcz2AHucc0uIDDS/AzxmZrcRSdHxPSLnS90ts865QjN7CviVmeUCW4AbgSHEDBY750rM7H7ge2Z2AFhBZNB6CnBpTLkaM/sB8Fsz2wm8Fi1zLTDbOVcd8za+D7xkZg8BC4FxwJ3Ar51zjSN/Goik6dhHZYNPySH+J2KDBw9mzZo1jcp+6UtfYsuWLfW2/eQnP+HCCy9s/UqLiMgxGdU/nw55wXp3P3TIC3LagCzqfDZ1raxraBHBJ+2gSDM0U0BEYjUVG689Z4hmTEhSpMWANNAw38Jvo1+XAJOcc2Ez+yLw8+jP2hMZoJ7snNvR4LWzgP8F7iGSv3kVMM05t6JBuTuAg8DNQF+gCPiKc+7F2ELOuQfNzAH/D7gN2A7c5Jz7bYNyf4sOrP8PMBPYDdwbrUtaWltcTmVN/cFoAyae3JNrzxnCpOG9E/pE7LnnnmujGoqISEtNGt6bsYO6UbhjP4erQ3TIwil463cdwDVYVtg52LDrAOeP7JuaSolI2vBDOyjSHM0UEJFYio2SamkxIO2cazYCOudKidyZfG0z5Q4Dt0YfRysXIjJofU8Cf/sh4KEEyv0F+Etz5dKFPhETEcl+wYCx4LoJFBSVsK64nJH98xP+wDFTNBXPNAVZRMAf7aBIczRTQERiKTZKqmVKDmlpA94nYh3zghjpnbj+5ZdfZvjw4QwdOpQf//jHqa6OiEhGCQaMqSP6MHvqMKaO6JN1F5qZFM9EJDWyvR0UaY5ipYg0pNgoqZQWd0hLamTKJ2KhUIhvfetb/OMf/2DgwIGMHz+eSy65hJEjR6a6aiIikgYyJZ6JiIikimKliIikEw1I+5z3iVgiKToefPBBHnzwQQDKysoYPHgwixcvblQuFApx3XXXsXz5csyMa6+9lltuueW467hs2TKGDh3KSSedBMCVV17J888/32hAeubMmXTo0IENGzawbds2Hn30UebPn88777zDhAkTmDdv3nHXQURE0tuxxDMRERE/UqwUEZF0oQFpSdgNN9zADTfcQE1NDVOmTOHWW+On6S4sLGTnzp2sWbMGgP379zcq8/jjj/Ozn/2s0fahQ4fyzDPP1Nu2c+dOBg0aVPd84MCBLF26NO7f3rdvH6+//jovvPAC06dP56233uLhhx9m/PjxFBYWMnbs2ATfrYiIiIiIiIiIiLQ2DUjLMbv55puZMmUK06dPj/vzk046iQ8//JDZs2dz8cUXc8EFFzQqc9VVV3HVVVcl9Pecc422mcWfWjZ9+nTMjNGjR9OnTx9Gjx4NwKhRo9i6dasGpEVERERERERERFJIA9JyTObNm8e2bduYO3duk2W6d+/OqlWreOWVV/jNb37Dn//8Z/74xz/WK3Msd0gPHDiQHTt21D3/6KOP6N+/f9y/3a5dOwACgUDd997z2tra5t+giIiIiIiIiIiItBkNSEvC/vWvf/Hzn/+cN998k0Ag0GS5Tz75hLy8PC677DJOPvlkZs6c2ajMsdwhPX78eDZt2sSWLVsYMGAATz75JE888cTxvg0RERERERERERFJEQ1IS8Lmzp1LaWkpkydPBuDMM8/k4YcfblRu586dzJo1i3A4DMB9993Xor+bk5PD3LlzufDCCwmFQlx77bWMGjWqRb9TREREREREREREkk8D0pKwRx99NKFyY8aMYcWKFa36ty+66CIuuuiio5aZN29e3feDBw+uW1Sx4c9EREREREREREQkNZrOuyAiIiIiIiIiIiIi0op0h7S0yIQJE6iqqqq3bcGCBYwePTpFNRIREREREREREZF0pQFpaZGlS5emugoiIiIiIiIiIiKSIZSyQ0RERERERERERESSQgPSIiIiIiIiIiIiIpIUGpAWERERERERERERkaTQgLSIiIiIiIiIiIiIJIUGpEVEREREREREREQkKTQgLSIiIiIiIiIiIiJJoQFpEREREREREREREUkKDUiLiIiIiIiIiIiISFJoQFpEREREREREREREkkID0iIiIiIiIiIiIiKSFBqQFhEREREREREREZGk0IC0iIiIiIiIiIiIiCSFBqRFREREREREREREJCnMOZfqOghgZnuAbQ02fwr4JAXVkfr0f2hbJzrneqW6EvE0cV62BR1jR2hfHJHKfZGW52UC56SOn+yg/2NjaXlOQqPzUv+7xGlfJSad91NanpeKla1C++jo0nn/ZMp5mc77MBW0P+rLpv3R5DmpAek0ZmbLnXNnproefqf/g7Q1HWNHaF8coX1x7LTPsoP+j5lL/7vEaV8lRvup9WmfNk/76Oi0f1pO+7A+7Y/6/LI/lLJDRERERERERERERJJCA9IiIiIiIiIiIiIikhQakE5vv091BQTQ/0Hano6xI7QvjtC+OHbaZ9lB/8fMpf9d4rSvEqP91Pq0T5unfXR02j8tp31Yn/ZHfb7YH8ohLSIiIiIiIiIiIiJJoTukRURERERERERERCQpNCCdZsxskJk9Y2ZlZlZuZn8xsxNSXa9MY2aXm9mzZrbNzA6bWZGZ3WdmXRqU625mD5vZJ2Z2yMxeM7PRcX5fezP7mZntiv6+d8zsc3HKBczse2a21cwqzWyVmV3Wlu9V0lNLzmUzGxJ97f7ocbnYzDJ2lV0zG2hmc6LnTYWZOTMbnOBrEzr3MkUL98W9Zvaqme2Nvm5m29Y2PbTwXMqq4yfTtfB/6Zp4jG3javtKMtrrbLlWOt59ZWZnmtnvzWxD9HXbzexxMxsSp+zWJo77f2uL99QWWnhMJXTeZ8sx1ZZa0v5mAkug72dmg49yTHVr8Puyrj0zs0lNvPf9Dcp1N/WPm6V4WZ9iYn2KfYnRgHQaMbOOwOvAqcA1wNXAMGCxmXVKZd0y0LeBEPB9YBrwO+BG4B9mFgAwMwNeiP58NnAZkEtkfw9s8PseAb4O/DfwRWAX8ErDRgH4EXAXMBf4AvAu8LSZXdS6b0/SWUvOZTPrCfwTOA34JnBl9EeLzWxEm1W6bQ0FvgLsA948xtcmeu5lipbsi9lAB+Cl1q5UumqFuJhtx0/GaqVrnHnAZxo8NrZ6Zf0tGe11tlwrHe++uhIYBTxA5P1/F/g0sNzMBsUp/wqNj/slx1/tpGvJMQWJnffZcky1CZ/0MZvt+8W4j8bH1IEGZbK5Pfsv6r/387wfqH98TBQv61NMrE+xLxHOOT3S5AHcTCSQDo3ZNgSoBW5Ndf0y6QH0irPtPwAHTIk+vzT6fHJMma5AKfBAzLYx0XKzYrblAEXACzHbegNVwA8b/N1FwOpU7xM9kvdoybkM3BktF/vaTsBu4M+pfm/HuT8CMd9fHz2fBifwuoTOvUx6HO++iH0tkQscB8xM9ftJwv5qybmUdcdPJj9aeo0T/V/ek+r3ke2Ptm6vs+laqQX7Kt416olAGLi7wfatwGOpfq+p2E/R8s2e99l0TLXh/yDr+5hNnFcN+36Do8+vb+Z3ZWV7BkyKvq/zjlJG/ePE96fiZevsj6yMiYp9iT10h3R6uQR41zm32dvgnNsCvEUkOEiCnHN74mx+L/p1QPTrJUCxc25xzOvKgBepv78vAWqAp2LK1QJPAheaWbvo5guBPOCxBn/3MWB0vGknkrVaci6fDWxq8NpDRD5Z/aKZ5bRBfduUcy58nC9N9NzLGC3YFy16bQZrybmUdcdPhtM1TgZIQnudNddKx7uv4l2jOue2AXs4co2aNZIQu7LmmGpDWd/+Jtj3S5Tv2rMY6h8nSPGyPsXE+hT7EqMB6fQyClgTZ/taYGSS65KNPh/9uj769Wj7+wQz6xxTbotzriJOuTwidyt65aqAzXHKgf6HftKSczkEVMfZXkUkXcPJLataRkn03JPs1ZJzScdPemmNa5wbzawqmovvdTM7t/WqJy2ka6UWiKbk6s2Ra9RY06PHfJWZvZuOuTLbWHPnvY6p5vm1j9mw7+e5z8xqLZJP+wVrnB8529uzx80sZJE1SZ6w+rnE1T9ue9p3zVBMBHwS+zQgnV56EMkx01Ap0D3JdckqZjYAuBt4zTm3PLr5aPsbjuzz5sr1iPm630XnShylnGS/lpzLRcCwaC5pILJgAXBWzO/2i0TPPcleLTmXdPykl5Ze4zwG/CeRXJffAHoCr5vZpFaqn7SMrpWOU3Tm04NE7gZ7pMGPXySSx/VC4CqgEnjOzL6W1EqmTiLnvY6p5vmuj9lE368KeIjIGi2TieSdHg283WCdlmxtz8qAXxBJHzCFSP7Z84B3zKx3tIz6x21P++4oFBMBH8W+jJv67QMNDygAS3otskj0k9znieRJmxX7IxLb361dTvzheI+FB4ksNvInM/svoAK4g0iuP4jk0/ILnVMCx38M6PhJP8f9/3DOXR3z9E0ze57IXVz3AOe0Qt2kZXStdPzmAhOBi51z9QYpnHOzY5+b2XNEFi26j8bTdLNOgue9jqnE+GYfNdX3c87tAm6IKfqmmb1M5I7COwBvUCsr2zPn3EpgZcymJWb2BrCMSN/jTtQ/Tgbtu6PzfUz0U+zTHdLpZR/xP8noTvxP0aQZZtaeyErBJwEXOuc+ivlxKU3vbziyz5srVxrztXt0deKjlZPsd9znsnPuQyKf+J5BZApOMZFVde+PFtnVetVMe4mee5K9WhIXdfykl1a9xnHOHQD+DxjfwnpJ69C10nEws/uI3P10rXPu1ebKO+dCwNPAQDPr19b1SzdNnPc6pprnmz5mM32/RpxzO4B/0viY8kV75pxbAWzkyPtX/7jtad81QTExvmyOfRqQTi9rieSCaWgksC7Jdcl4ZpYLPEsk1cFFzrn3GxQ52v7e7pw7GFNuiJl1jFOumiN5e9YC7Wic49fL36P/oX+06Fx2zj1LZBGHkURWRD8D6AzscM5tb82KprlEzz3JXi05l3T8pJe2uMZp6u4QST5dKx0jM7sD+C5ws3NuwbG8NPrVr8d+w/Nex1TzfNHHTKDv1+RLaXxM+ak9i33/6h+3Pe27OBQTm5WVsU8D0unlBeBsMzvJ22Bmg4HPRn8mCYrm3H0cmApc6px7N06xF4ABZvb5mNflA9Opv79fAHKBL8eUywGuAF51zlVFN79MJIhc1eDvfA1YE13NWvyhxeeycy7knFvvnPvAzPoTOd5+1xaVTWOJnnuSvVpyLun4SS+teo0TjdcXA0tbq4LSIrpWOgbRlFz3AHc45+Ycw+tyiOzj7c65j9uqfumqifNex1Tzsr6PmWDfL97rTiCyH2KPKd+0Z2Z2JnAKR96/+sdtT/uuAcXEo8vm2Kcc0unlD8BNwPNmdieRT0B+BOwgsgCDJO43RBqn/wUOmdnZMT/7KDp96wXgHeAxM7uNyBSk7xH59OmnXmHnXKGZPQX8KvrJ+xbgRiI5fa+KKVdiZvcD3zOzA8AKIoFlCnBpm71TSUcJnctmdiLwAXC3c+7u6LZcIsffEqCcyF0K3yPyKegvkvgeWpWZXR799ozo1y+Y2R5gj3NuSbx9kei5l2mOZ19EX/d5oBfQN7rpTDM7COCceyY5tU+64z6XsvX4yWAtaRe/DQwHFhNJY3QikcWo+qL/Zatry/Y6266VjmdfmdmVwK+IdCZfb3CNWu6cWxctN4PIPvkbkfOkD/Ct6N+a0aZvrJUd535K6LzPtmOqjfihj9ls38/MfkHkhrx3iCyYNpzINXYYuNcrnK3tmZk9TuS9rAD2A+OIvP+dgDcIqP7xMVC8rE8xsT7FvgQ45/RIowdwApGpRuXAAeCvwOBU1yvTHsBWIhdb8R53xZTrAfyRSI6dCmARMCbO7+sA/BL4mMhqrkuBSXHKBYksCLGNyErOq4HLU70/9Ej+I5FzGRgc55jMAV4CdkePoQ+IfGLcMdXvqYX7o6nzsaCpfRHdntC5l0mPFuyLgqZem+r31Mb767jOpWw9fjL50YJ2cTrwFvAJUAPsJdJpPivV7ykbH23dXpNF10rHs6+Aec29LlrubOB1ItcDNUAZ8BqRvLgpf+9J2E8Jn/fZdEy14f8gq/uYJND3A64F3iMyyFobbaueAIbH+X1Z154RGVheHW1LaogM6v0e6NegnPrHie9TxcsW7g+yOCYe5/7wVeyz6BsREREREREREREREWlTyiEtIiIiIiIiIiIiIkmhAWkRERERERERERERSQoNSIuIiIiIiIiIiIhIUmhAWkRERERERERERESSQgPSIiIiIiIiIiIiIpIUGpAWERERERERERERkaTQgLSIiIiIiIiIiIiIJIUGpEVEREREREREREQkKTQgLSIiIiIiIiIiIiJJ8f8BE+k0f4lzQqYAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fv3_level_make_plots(ak_gfs,bk_gfs,\"GFS v15 levels\",zss,do_ylog,zcoord_type)\n", + "fv3_level_make_plots(ak47,bk47,\"HiRAM QBO mid-top setup\",zss,do_ylog,zcoord_type)\n", + "fv3_level_make_plots(ak_bad,bk_bad,\"Bad levels\",zss,do_ylog,zcoord_type)" + ] + }, + { + "cell_type": "markdown", + "id": "59848a95", + "metadata": {}, + "source": [ + "If you have compiled the `fv_eta` wrapper (instructions given in `fv_eta.F90`, be sure to download `fv_eta.h` also), you can select any of the standard FV3 level setups. It is apparent different vertical level setups are chosen for different applications: in particular the kilometer-scale models (X-SHiELD and T-SHiELD) place many more levels in the boundary layer than the 13-km SHiELD, which more emphasizes consistency throughout the column.\n", + "\n", + "Compilation instructions for the `fv_eta` wrapper:\n", + "- Requires an up-to-date version of `gcc` in your path, and f2py or f2py3.\n", + "- Download `fv_eta.F90` and `fv_eta.h` into the directory you are running this notebook from." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "38e355cd", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "from fv_eta import fv_eta_mod as fv_eta\n", + "ak, bk = fv_eta.set_eta(79,'gcrm')\n", + "fv3_level_make_plots(ak,bk,\"X-SHiELD\",zss,do_ylog,'z')\n", + "\n", + "ak, bk = fv_eta.set_eta(91,'')\n", + "fv3_level_make_plots(ak,bk,\"SHiELD 2020\",zss,do_ylog,'z')\n", + "\n", + "ak, bk = fv_eta.set_eta(75,'')\n", + "fv3_level_make_plots(ak,bk,\"T-SHiELD 2021\",zss,do_ylog,'z')\n" + ] + }, + { + "cell_type": "markdown", + "id": "288b4ea3", + "metadata": {}, + "source": [ + "Here are levels for two GFDL atmosphere models used for climate modeling. The 33-level AM4 setup is very similar to what GFDL has used back to AM2.1 (ca. 2003), the first FV-powered GFDL model, with the addition of a very thin first level (Shin et al., JAMES, 2018). " + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "f294a670", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "ak, bk = fv_eta.set_eta(33,'')\n", + "fv3_level_make_plots(ak,bk,\"GFDL AM4\",zss,do_ylog,'p')\n", + "\n", + "ak, bk = fv_eta.set_eta(63,'hitop')\n", + "fv3_level_make_plots(ak,bk,\"Nonhydrostatic HiRAM\",zss,do_ylog,'p')\n", + "\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.4" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/examples/FV3_level_transmogrifier/fv_eta.F90 b/docs/examples/FV3_level_transmogrifier/fv_eta.F90 new file mode 100644 index 000000000..9e8f97b42 --- /dev/null +++ b/docs/examples/FV3_level_transmogrifier/fv_eta.F90 @@ -0,0 +1,2318 @@ +!*********************************************************************** +!* GNU Lesser General Public License +!* +!* This file is part of the FV3 dynamical core. +!* +!* The FV3 dynamical core is free software: you can redistribute it +!* and/or modify it under the terms of the +!* GNU Lesser General Public License as published by the +!* Free Software Foundation, either version 3 of the License, or +!* (at your option) any later version. +!* +!* The FV3 dynamical core is distributed in the hope that it will be +!* useful, but WITHOUT ANY WARRANTY; without even the implied warranty +!* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. +!* See the GNU General Public License for more details. +!* +!* You should have received a copy of the GNU Lesser General Public +!* License along with the FV3 dynamical core. +!* If not, see . +!*********************************************************************** + +!Compiling at GFDL (your modules, shell, and compilers may vary) +! source $MODULESHOME/init/bash +! module load gcc +! f2py3 -c -m fv_eta fv_eta.F90 -I. 2>&1 1> out #the -I. is for the include file + +module fv_eta_mod + implicit none + public + + !using GFS constants + real, public, parameter :: PI = 3.1415926535897931 !< Ratio of circle circumference to diameter [N/A] + real, public, parameter :: GRAV = 9.80665 !< Acceleration due to gravity [m/s^2] + real, public, parameter :: RDGAS = 287.05 !< Gas constant for dry air [J/kg/deg] + real, public, parameter :: RVGAS = 461.50 !< Gas constant for water vapor [J/kg/deg] + real, public, parameter :: CP_AIR = 1004.6 !< Specific heat capacity of dry air at constant pressure [J/kg/deg] + real, public, parameter :: KAPPA = RDGAS/CP_AIR !< RDGAS / CP_AIR [dimensionless] + real, public, parameter :: TFREEZE = 273.15 !< Freezing temperature of fresh water [K] + real, public, parameter :: CP_VAPOR = 4.0*RVGAS !< Specific heat capacity of water vapor at constant pressure [J/kg/deg] + + contains + + !This is the version of set_eta used in SHiELD and AM4 + subroutine set_eta(km, ak, bk, npz_type) + +!Level definitions are now in this header file +#include + + integer, intent(in):: km ! vertical dimension + real, intent(out):: ak(km+1) + real, intent(out):: bk(km+1) + character(24), intent(IN) :: npz_type + character(len=:), dimension(:), allocatable :: eta_level_unit + + real :: ptop + integer :: ks + + real:: p0=1000.E2 + real:: pc=200.E2 + + real pt, lnpe, dlnp + real press(km+1), pt1(km) + integer :: l, k + integer :: var_fn = 0 + + real :: pint = 100.E2 + real :: stretch_fac = 1.03 + integer :: auto_routine = 0 + + + ptop = 1. + + ! Definition: press(i,j,k) = ak(k) + bk(k) * ps(i,j) + + if (trim(npz_type) == 'superC' .or. trim(npz_type) == 'superK') then + + auto_routine = 1 + select case (km) + case (20) + ptop = 56.e2 + pint = ptop + stretch_fac = 1.03 + case (24) + ptop = 56.e2 + pint = ptop + stretch_fac = 1.03 + case (30) + ptop = 56.e2 + pint = ptop + stretch_fac = 1.03 + case (40) + ptop = 56.e2 + pint = ptop + stretch_fac = 1.03 + case (50) + ptop = 56.e2 + pint = ptop + stretch_fac = 1.03 + case (60) + ptop = 56.e2 + pint = ptop + stretch_fac = 1.03 + case (80) + ptop = 56.e2 + pint = ptop + stretch_fac = 1.03 + case (90) ! super-duper cell + ptop = 40.e2 + stretch_fac = 1.025 + auto_routine = 2 + end select + + else if (trim(npz_type) == 'input') then +! Jili Dong add ak/bk input + print*, 'input type not supported' + + else + + select case (km) + + case (5,10) ! does this work???? + + ! Equivalent Shallow Water: for modon test + ptop = 500.e2 + ks = 0 + do k=1,km+1 + bk(k) = real(k-1) / real (km) + ak(k) = ptop*(1.-bk(k)) + enddo + + case (24) + + ks = 5 + do k=1,km+1 + ak(k) = a24(k) + bk(k) = b24(k) + enddo + + case (26) + + ks = 7 + do k=1,km+1 + ak(k) = a26(k) + bk(k) = b26(k) + enddo + + case (30) ! For Baroclinic Instability Test + ptop = 2.26e2 + pint = 250.E2 + stretch_fac = 1.03 + auto_routine = 1 + + case (31) ! N = 4, M=2 + if (trim(npz_type) == 'lowtop') then + ptop = 300. + pint = 100.E2 + stretch_fac = 1.035 + auto_routine = 5 + else + ptop = 100. + stretch_fac = 1.035 + auto_routine = 1 + endif + + case (32) + + if (trim(npz_type) == 'old32') then + ks = 13 ! high-res trop_32 setup + do k=1,km+1 + ak(k) = a32old(k) + bk(k) = b32old(k) + enddo + elseif (trim(npz_type) == 'lowtop') then + ptop = 100. + stretch_fac = 1.035 + auto_routine = 1 + else + ks = 7 + do k=1,km+1 + ak(k) = a32(k) + bk(k) = b32(k) + enddo + endif + !miz + case (33) + ks = 7 + do k=1,km+1 + ak(k) = a33(k) + bk(k) = b33(k) + enddo + !miz + + case (39) ! N = 5 + ptop = 100. + stretch_fac = 1.035 + auto_routine = 1 + + case (40) + ptop = 50.e2 ! For super cell test + pint = 300.E2 + stretch_fac = 1.03 + auto_routine = 1 + + case (41) + ptop = 100. + pint = 100.E2 + stretch_fac = 1.035 + auto_routine = 1 + + case (47) + + if (trim(npz_type) == 'lowtop') then + ptop = 100. + stretch_fac = 1.035 + auto_routine = 1 + else + ! ks = 27 ! high-res trop-strat + ks = 20 ! Oct 23, 2012 + do k=1,km+1 + ak(k) = a47(k) + bk(k) = b47(k) + enddo + endif + + case (48) + ks = 28 + do k=1,km+1 + ak(k) = a48(k) + bk(k) = b48(k) + enddo + + case (50) + ! ! *Very-low top: for idealized super-cell simulation: + ! ptop = 50.e2 + ! pint = 250.E2 + ! stretch_fac = 1.03 + ! auto_routine = 1 + + + ks = 19 + do k=1,km+1 + ak(k) = a50(k) + bk(k) = b50(k) + enddo + + case (51) + if (trim(npz_type) == 'lowtop') then + ptop = 100. + stretch_fac = 1.03 + auto_routine = 1 + elseif (trim(npz_type) == 'meso') then + ptop = 20.E2 + pint = 100.E2 + stretch_fac = 1.05 + auto_routine = 1 + elseif (trim(npz_type) == 'meso2') then + ptop = 1.E2 + pint = 100.E2 + stretch_fac = 1.05 + auto_routine = 6 + else + ptop = 100. + pint = 100.E2 + stretch_fac = 1.035 + auto_routine = 1 + endif + + case (52) + + if (trim(npz_type) == 'rce') then + ptop = 30.e2 ! for special DPM RCE experiments + stretch_fac = 1.03 + auto_routine = 1 + else + ks = 35 ! pint = 223 + do k=1,km+1 + ak(k) = a52(k) + bk(k) = b52(k) + enddo + endif + + case (54) + ks = 11 ! pint = 109.4 + do k=1,km+1 + ak(k) = a54(k) + bk(k) = b54(k) + enddo + + ! Mid-top: + case (55) ! N = 7 + ptop = 10. + pint = 100.E2 + stretch_fac = 1.035 + auto_routine = 1 + + case (56) + ks = 26 + do k=1,km+1 + ak(k) = a56(k) + bk(k) = b56(k) + enddo + + case (60) + + if (trim(npz_type) == 'gfs') then + ks = 20 + do k=1,km+1 + ak(k) = a60gfs(k) + bk(k) = b60gfs(k) + enddo + else if (trim(npz_type) == 'BCwave') then + ptop = 3.e2 + ! pint = 250.E2 + pint = 300.E2 ! revised for Moist test + stretch_fac = 1.03 + auto_routine = 1 + else if (trim(npz_type) == 'meso') then + + ptop = 40.e2 + pint = 250.E2 + stretch_fac = 1.03 + auto_routine = 1 + + else + ks = 37 + do k=1,km+1 + ak(k) = a60(k) + bk(k) = b60(k) + enddo + endif + + case (63) + if (trim(npz_type) == 'meso') then + ks = 11 + do k=1,km+1 + ak(k) = a63meso(k) + bk(k) = b63meso(k) + enddo + elseif (trim(npz_type) == 'hitop') then + ptop = 1. ! high top + pint = 100.E2 + stretch_fac = 1.035 + auto_routine = 1 + else!if (trim(npz_type) == 'gfs') then + !Used for fvGFS + ! GFS L64 equivalent setting + ks = 23 + do k=1,km+1 + ak(k) = a63(k) + bk(k) = b63(k) + enddo + endif + + case (64) + + if (trim(npz_type) == 'gfs') then + ks = 23 + do k=1,km+1 + ak(k) = a64gfs(k) + bk(k) = b64gfs(k) + enddo + + else + + ks = 46 + do k=1,km+1 + ak(k) = a64(k) + bk(k) = b64(k) + enddo + + endif + + ! xi chen's l65 + case (65) + ks = 29 + do k=1,km+1 + ak(k) = a65(k) + bk(k) = b65(k) + enddo + + !-->cjg + case (68) + ks = 27 + do k=1,km+1 + ak(k) = a68(k) + bk(k) = b68(k) + enddo + + case (71) ! N = 9 + ptop = 1. + stretch_fac = 1.03 + auto_routine = 1 + + ! kgao: introduce EMC's L75 config + case (75) + if (trim(npz_type) == 'emc') then + ! EMC's L75 config + ks = 12 + do k=1,km+1 + ak(k) = a75(k) + bk(k) = b75(k) + enddo + else + ! HS-SGO test configuration + pint = 100.E2 + ptop = 10.E2 + stretch_fac = 1.035 + auto_routine = 6 + endif + + case (79) ! N = 10, M=5 + if (trim(npz_type) == 'gcrm') then + pint = 100.E2 + ptop = 3.E2 + stretch_fac = 1.035 + auto_routine = 6 + else + ptop = 1. + stretch_fac = 1.03 + auto_routine = 1 + endif + case (90) ! super-duper cell + ptop = 40.e2 + stretch_fac = 1.025 + auto_routine = 2 + + ! NGGPS_GFS + case (91) + pint = 100.E2 + ptop = 40. + stretch_fac = 1.029 + auto_routine = 6 + + case (95) + ! Mid-top settings: + pint = 100.E2 + ptop = 20. + stretch_fac = 1.029 + auto_routine = 6 + + case (96) + ks = 27 + do k=1,km+1 + ak(k) = a96(k) + bk(k) = b96(k) + enddo + !<--cjg + + ! kgao L88 + case (88) + ks = 20 !19 bug fix + do k=1,km+1 + ak(k) = a88(k) + bk(k) = b88(k) + enddo + + case (100) + ks = 38 + do k=1,km+1 + ak(k) = a100(k) + bk(k) = b100(k) + enddo + + case (104) + ks = 73 + do k=1,km+1 + ak(k) = a104(k) + bk(k) = b104(k) + enddo + + ! IFS-like L125 + case (125) + ks = 33 + ptop = a125(1) + pint = a125(ks+1) + do k=1,km+1 + ak(k) = a125(k) + bk(k) = b125(k) + enddo + + case (127) ! N = 10, M=5 + if (trim(npz_type) == 'hitop') then + ptop = 1. + stretch_fac = 1.03 + auto_routine = 2 + elseif (trim(npz_type) == 'gfs') then + ks = 39 + ptop = a127(1) + pint = a127(ks+1) + do k=1,km+1 + ak(k) = a127(k) + bk(k) = b127(k) + enddo + else + ptop = 1. + pint = 75.E2 + stretch_fac = 1.028 + auto_routine = 6 + endif + case (151) + !LES applications + ptop = 75.e2 + pint = 500.E2 + stretch_fac = 1.01 + auto_routine = 3 + + case default + + if(trim(npz_type) == 'hitop') then + ptop = 1. + pint = 100.E2 + elseif(trim(npz_type) == 'midtop') then + ptop = 10. + pint = 100.E2 + elseif(trim(npz_type) == 'lowtop') then + ptop = 1.E2 + pint = 100.E2 + endif + + if (trim(npz_type) == 'gfs') then + auto_routine = 6 + elseif(trim(npz_type) == 'les') then + auto_routine = 3 + elseif(trim(npz_type) == 'mountain_wave') then + auto_routine = 4 + elseif (km > 79) then + auto_routine = 2 + else + auto_routine = 1 + endif + + end select + + endif ! superC/superK + + select case (auto_routine) + + case (1) + call var_hi(km, ak, bk, ptop, ks, pint, stretch_fac) + case (2) + call var_hi2(km, ak, bk, ptop, ks, pint, stretch_fac) + case (3) + call var_les(km, ak, bk, ptop, ks, pint, stretch_fac) + case (4) + call mount_waves(km, ak, bk, ptop, ks, pint) + case (5) + call var_dz(km, ak, bk, ptop, ks, pint, stretch_fac) + case (6) + call var_gfs(km, ak, bk, ptop, ks, pint, stretch_fac) + end select + + ptop = ak(1) + pint = ak(ks+1) + + call check_eta_levels (ak, bk) + + if (is_master()) then + write(*, '(A4, A13, A13, A11)') 'klev', 'ak', 'bk', 'p_ref' + do k=1,km+1 + write(*,'(I4, F13.5, F13.5, F11.2)') k, ak(k), bk(k), 1000.E2*bk(k) + ak(k) + enddo + endif + + + end subroutine set_eta + + subroutine set_external_eta(ak, bk, ptop, ks) + implicit none + real, intent(in) :: ak(:) + real, intent(in) :: bk(:) + real, intent(out) :: ptop ! model top (Pa) + integer, intent(out) :: ks ! number of pure p layers + !--- local variables + integer :: k + real :: eps = 1.d-7 + + ptop = ak(1) + ks = 1 + do k = 1, size(bk(:)) + if (bk(k).lt.eps) ks = k + enddo + !--- change ks to layers from levels + ks = ks - 1 + + if (is_master()) write(6,*) ' ptop & ks ', ptop, ks + + call check_eta_levels (ak, bk) + + end subroutine set_external_eta + + + subroutine var_les(km, ak, bk, ptop, ks, pint, s_rate) + implicit none + integer, intent(in):: km + real, intent(in):: ptop + real, intent(in):: s_rate ! between [1. 1.1] + real, intent(out):: ak(km+1), bk(km+1) + real, intent(inout):: pint + integer, intent(out):: ks +! Local + real, parameter:: p00 = 1.E5 + real, dimension(km+1):: ze, pe1, peln, eta + real, dimension(km):: dz, s_fac, dlnp, pm, dp, dk + real ztop, t0, dz0, sum1, tmp1 + real ep, es, alpha, beta, gama + real, parameter:: akap = 2./7. +!---- Tunable parameters: + integer:: k_inc = 10 ! # of layers from bottom up to near const dz region + real:: s0 = 0.8 ! lowest layer stretch factor +!----------------------- + real:: s_inc + integer k + + pe1(1) = ptop + peln(1) = log(pe1(1)) + pe1(km+1) = p00 + peln(km+1) = log(pe1(km+1)) + + t0 = 273. + ztop = rdgas/grav*t0*(peln(km+1) - peln(1)) + + s_inc = (1.-s0) / real(k_inc) + s_fac(km) = s0 + + do k=km-1, km-k_inc, -1 + s_fac(k) = s_fac(k+1) + s_inc + enddo + + s_fac(km-k_inc-1) = 0.5*(s_fac(km-k_inc) + s_rate) + + do k=km-k_inc-2, 5, -1 + s_fac(k) = s_rate * s_fac(k+1) + enddo + + s_fac(4) = 0.5*(1.1+s_rate)*s_fac(5) + s_fac(3) = 1.1 *s_fac(4) + s_fac(2) = 1.1 *s_fac(3) + s_fac(1) = 1.1 *s_fac(2) + + sum1 = 0. + do k=1,km + sum1 = sum1 + s_fac(k) + enddo + + dz0 = ztop / sum1 + + do k=1,km + dz(k) = s_fac(k) * dz0 + enddo + + ze(km+1) = 0. + do k=km,1,-1 + ze(k) = ze(k+1) + dz(k) + enddo + +! Re-scale dz with the stretched ztop + do k=1,km + dz(k) = dz(k) * (ztop/ze(1)) + enddo + + do k=km,1,-1 + ze(k) = ze(k+1) + dz(k) + enddo +! ze(1) = ztop + + if ( is_master() ) then + write(*,*) 'var_les: computed model top (m)=', ztop, ' bottom/top dz=', dz(km), dz(1) +! do k=1,km +! write(*,*) k, s_fac(k) +! enddo + endif + + call sm1_edge(1, 1, 1, 1, km, 1, 1, ze, 2) + +! Given z --> p + do k=1,km + dz(k) = ze(k) - ze(k+1) + dlnp(k) = grav*dz(k) / (rdgas*t0) + !write(*,*) k, dz(k) + enddo + do k=2,km + peln(k) = peln(k-1) + dlnp(k-1) + pe1(k) = exp(peln(k)) + enddo + + +! Pe(k) = ak(k) + bk(k) * PS +! Locate pint and KS + ks = 0 + do k=2,km + if ( pint < pe1(k)) then + ks = k-1 + exit + endif + enddo + if ( is_master() ) then + write(*,*) 'For (input) PINT=', 0.01*pint, ' KS=', ks, 'pint(computed)=', 0.01*pe1(ks+1) + endif + pint = pe1(ks+1) + + do k=1,km+1 + eta(k) = pe1(k) / pe1(km+1) + enddo + + ep = eta(ks+1) + es = eta(km) +! es = 1. + alpha = (ep**2-2.*ep*es) / (es-ep)**2 + beta = 2.*ep*es**2 / (es-ep)**2 + gama = -(ep*es)**2 / (es-ep)**2 + +! Pure pressure: + do k=1,ks+1 + ak(k) = eta(k)*1.e5 + bk(k) = 0. + enddo + + do k=ks+2, km + ak(k) = alpha*eta(k) + beta + gama/eta(k) + ak(k) = ak(k)*1.e5 + enddo + ak(km+1) = 0. + + do k=ks+2, km + bk(k) = (pe1(k) - ak(k))/pe1(km+1) + enddo + bk(km+1) = 1. + + if ( is_master() ) then + ! write(*,*) 'KS=', ks, 'PINT (mb)=', pint/100. + ! do k=1,km + ! pm(k) = 0.5*(pe1(k)+pe1(k+1))/100. + ! write(*,*) k, pm(k), dz(k) + ! enddo + tmp1 = ak(ks+1) + do k=ks+1,km + tmp1 = max(tmp1, (ak(k)-ak(k+1))/max(1.E-5, (bk(k+1)-bk(k))) ) + enddo + write(*,*) 'Hybrid Sigma-P: minimum allowable surface pressure (hpa)=', tmp1/100. + write(*,800) (pm(k), k=km,1,-1) + endif + + do k=1,km + dp(k) = (pe1(k+1) - pe1(k))/100. + dk(k) = pe1(k+1)**akap - pe1(k)**akap + enddo + +800 format(1x,5(1x,f9.4)) + + end subroutine var_les + + + + subroutine var_gfs(km, ak, bk, ptop, ks, pint, s_rate) + integer, intent(in):: km + real, intent(in):: ptop + real, intent(in):: s_rate ! between [1. 1.1] + real, intent(out):: ak(km+1), bk(km+1) + real, intent(inout):: pint + integer, intent(out):: ks +! Local + real, parameter:: p00 = 1.E5 + real, dimension(km+1):: ze, pe1, peln, eta + real, dimension(km):: dz, s_fac, dlnp + real ztop, t0, dz0, sum1, tmp1 + real ep, es, alpha, beta, gama +!---- Tunable parameters: + integer:: k_inc = 25 ! # of layers from bottom up to near const dz region + real:: s0 = 0.13 ! lowest layer stretch factor +!----------------------- + real:: s_inc + integer k + + pe1(1) = ptop + peln(1) = log(pe1(1)) + pe1(km+1) = p00 + peln(km+1) = log(pe1(km+1)) + + t0 = 270. + ztop = rdgas/grav*t0*(peln(km+1) - peln(1)) + + s_inc = (1.-s0) / real(k_inc) + s_fac(km) = s0 + + do k=km-1, km-k_inc, -1 + s_fac(k) = s_fac(k+1) + s_inc + enddo + + do k=km-k_inc-1, 9, -1 + s_fac(k) = s_rate * s_fac(k+1) + enddo + s_fac(8) = 0.5*(1.1+s_rate)*s_fac(9) + s_fac(7) = 1.10*s_fac(8) + s_fac(6) = 1.15*s_fac(7) + s_fac(5) = 1.20*s_fac(6) + s_fac(4) = 1.26*s_fac(5) + s_fac(3) = 1.33*s_fac(4) + s_fac(2) = 1.41*s_fac(3) + s_fac(1) = 1.60*s_fac(2) + + sum1 = 0. + do k=1,km + sum1 = sum1 + s_fac(k) + enddo + + dz0 = ztop / sum1 + + do k=1,km + dz(k) = s_fac(k) * dz0 + enddo + + ze(km+1) = 0. + do k=km,1,-1 + ze(k) = ze(k+1) + dz(k) + enddo + +! Re-scale dz with the stretched ztop + do k=1,km + dz(k) = dz(k) * (ztop/ze(1)) + enddo + + do k=km,1,-1 + ze(k) = ze(k+1) + dz(k) + enddo +! ze(1) = ztop + + if ( is_master() ) then + write(*,*) 'var_gfs: computed model top (m)=', ztop*0.001, ' bottom/top dz=', dz(km), dz(1) +! do k=1,km +! write(*,*) k, s_fac(k) +! enddo + endif + +! call sm1_edge(1, 1, 1, 1, km, 1, 1, ze, 3) + +! Given z --> p + do k=1,km + dz(k) = ze(k) - ze(k+1) + dlnp(k) = grav*dz(k) / (rdgas*t0) + enddo + do k=2,km + peln(k) = peln(k-1) + dlnp(k-1) + pe1(k) = exp(peln(k)) + enddo + +! Pe(k) = ak(k) + bk(k) * PS +! Locate pint and KS + ks = 0 + do k=2,km + if ( pint < pe1(k)) then + ks = k-1 + exit + endif + enddo + if ( is_master() ) then + write(*,*) 'For (input) PINT=', 0.01*pint, ' KS=', ks, 'pint(computed)=', 0.01*pe1(ks+1) + write(*,*) 'ptop =', ptop + endif + pint = pe1(ks+1) + +#ifdef NO_UKMO_HB + do k=1,ks+1 + ak(k) = pe1(k) + bk(k) = 0. + enddo + + do k=ks+2,km+1 + bk(k) = (pe1(k) - pint) / (pe1(km+1)-pint) ! bk == sigma + ak(k) = pe1(k) - bk(k) * pe1(km+1) + enddo + bk(km+1) = 1. + ak(km+1) = 0. +#else +! Problematic for non-hydrostatic + do k=1,km+1 + eta(k) = pe1(k) / pe1(km+1) + enddo + + ep = eta(ks+1) + es = eta(km) +! es = 1. + alpha = (ep**2-2.*ep*es) / (es-ep)**2 + beta = 2.*ep*es**2 / (es-ep)**2 + gama = -(ep*es)**2 / (es-ep)**2 + +! Pure pressure: + do k=1,ks+1 + ak(k) = eta(k)*1.e5 + bk(k) = 0. + enddo + + do k=ks+2, km + ak(k) = alpha*eta(k) + beta + gama/eta(k) + ak(k) = ak(k)*1.e5 + enddo + ak(km+1) = 0. + + do k=ks+2, km + bk(k) = (pe1(k) - ak(k))/pe1(km+1) + enddo + bk(km+1) = 1. +#endif + + if ( is_master() ) then + write(*,*) 'KS=', ks, 'PINT (mb)=', pint/100. + do k=1,km + write(*,*) k, 0.5*(pe1(k)+pe1(k+1))/100., dz(k) + enddo + tmp1 = ak(ks+1) + do k=ks+1,km + tmp1 = max(tmp1, (ak(k)-ak(k+1))/max(1.E-5, (bk(k+1)-bk(k))) ) + enddo + write(*,*) 'Hybrid Sigma-P: minimum allowable surface pressure (hpa)=', tmp1/100. + endif + + end subroutine var_gfs + + subroutine var_hi(km, ak, bk, ptop, ks, pint, s_rate) + integer, intent(in):: km + real, intent(in):: ptop + real, intent(in):: s_rate ! between [1. 1.1] + real, intent(out):: ak(km+1), bk(km+1) + real, intent(inout):: pint + integer, intent(out):: ks +! Local + real, parameter:: p00 = 1.E5 + real, dimension(km+1):: ze, pe1, peln, eta + real, dimension(km):: dz, s_fac, dlnp + real ztop, t0, dz0, sum1, tmp1 + real ep, es, alpha, beta, gama +!---- Tunable parameters: + integer:: k_inc = 15 ! # of layers from bottom up to near const dz region + real:: s0 = 0.10 ! lowest layer stretch factor +!----------------------- + real:: s_inc + integer k + + pe1(1) = ptop + peln(1) = log(pe1(1)) + pe1(km+1) = p00 + peln(km+1) = log(pe1(km+1)) + + t0 = 270. + ztop = rdgas/grav*t0*(peln(km+1) - peln(1)) + + s_inc = (1.-s0) / real(k_inc) + s_fac(km) = s0 + + do k=km-1, km-k_inc, -1 + s_fac(k) = s_fac(k+1) + s_inc + enddo + + s_fac(km-k_inc-1) = 0.5*(s_fac(km-k_inc) + s_rate) + +#ifdef HIWPP + do k=km-k_inc-2, 4, -1 + s_fac(k) = s_rate * s_fac(k+1) + enddo + s_fac(3) = 0.5*(1.15+s_rate)*s_fac(4) + s_fac(2) = 1.15 *s_fac(3) + s_fac(1) = 1.3 *s_fac(2) +#else + do k=km-k_inc-2, 9, -1 + s_fac(k) = s_rate * s_fac(k+1) + enddo + + s_fac(8) = 0.5*(1.1+s_rate)*s_fac(9) + s_fac(7) = 1.1 *s_fac(8) + s_fac(6) = 1.15*s_fac(7) + s_fac(5) = 1.2 *s_fac(6) + s_fac(4) = 1.3 *s_fac(5) + s_fac(3) = 1.4 *s_fac(4) + s_fac(2) = 1.45 *s_fac(3) + s_fac(1) = 1.5 *s_fac(2) +#endif + + sum1 = 0. + do k=1,km + sum1 = sum1 + s_fac(k) + enddo + + dz0 = ztop / sum1 + + do k=1,km + dz(k) = s_fac(k) * dz0 + enddo + + ze(km+1) = 0. + do k=km,1,-1 + ze(k) = ze(k+1) + dz(k) + enddo + +! Re-scale dz with the stretched ztop + do k=1,km + dz(k) = dz(k) * (ztop/ze(1)) + enddo + + do k=km,1,-1 + ze(k) = ze(k+1) + dz(k) + enddo +! ze(1) = ztop + + if ( is_master() ) then + write(*,*) 'var_hi: computed model top (m)=', ztop*0.001, ' bottom/top dz=', dz(km), dz(1) +! do k=1,km +! write(*,*) k, s_fac(k) +! enddo + endif + + call sm1_edge(1, 1, 1, 1, km, 1, 1, ze, 1) + +! Given z --> p + do k=1,km + dz(k) = ze(k) - ze(k+1) + dlnp(k) = grav*dz(k) / (rdgas*t0) + enddo + do k=2,km + peln(k) = peln(k-1) + dlnp(k-1) + pe1(k) = exp(peln(k)) + enddo + +! Pe(k) = ak(k) + bk(k) * PS +! Locate pint and KS + ks = 0 + do k=2,km + if ( pint < pe1(k)) then + ks = k-1 + exit + endif + enddo + if ( is_master() ) then + write(*,*) 'For (input) PINT=', 0.01*pint, ' KS=', ks, 'pint(computed)=', 0.01*pe1(ks+1) + write(*,*) 'ptop =', ptop + endif + pint = pe1(ks+1) + +#ifdef NO_UKMO_HB + do k=1,ks+1 + ak(k) = pe1(k) + bk(k) = 0. + enddo + + do k=ks+2,km+1 + bk(k) = (pe1(k) - pint) / (pe1(km+1)-pint) ! bk == sigma + ak(k) = pe1(k) - bk(k) * pe1(km+1) + enddo + bk(km+1) = 1. + ak(km+1) = 0. +#else +! Problematic for non-hydrostatic + do k=1,km+1 + eta(k) = pe1(k) / pe1(km+1) + enddo + + ep = eta(ks+1) + es = eta(km) +! es = 1. + alpha = (ep**2-2.*ep*es) / (es-ep)**2 + beta = 2.*ep*es**2 / (es-ep)**2 + gama = -(ep*es)**2 / (es-ep)**2 + +! Pure pressure: + do k=1,ks+1 + ak(k) = eta(k)*1.e5 + bk(k) = 0. + enddo + + do k=ks+2, km + ak(k) = alpha*eta(k) + beta + gama/eta(k) + ak(k) = ak(k)*1.e5 + enddo + ak(km+1) = 0. + + do k=ks+2, km + bk(k) = (pe1(k) - ak(k))/pe1(km+1) + enddo + bk(km+1) = 1. +#endif + + if ( is_master() ) then + write(*,*) 'KS=', ks, 'PINT (mb)=', pint/100. + do k=1,km + write(*,*) k, 0.5*(pe1(k)+pe1(k+1))/100., dz(k) + enddo + tmp1 = ak(ks+1) + do k=ks+1,km + tmp1 = max(tmp1, (ak(k)-ak(k+1))/max(1.E-5, (bk(k+1)-bk(k))) ) + enddo + write(*,*) 'Hybrid Sigma-P: minimum allowable surface pressure (hpa)=', tmp1/100. + endif + + + end subroutine var_hi + subroutine var_hi2(km, ak, bk, ptop, ks, pint, s_rate) + integer, intent(in):: km + real, intent(in):: ptop + real, intent(in):: s_rate ! between [1. 1.1] + real, intent(out):: ak(km+1), bk(km+1) + real, intent(inout):: pint + integer, intent(out):: ks +! Local + real, parameter:: p00 = 1.E5 + real, dimension(km+1):: ze, pe1, peln, eta + real, dimension(km):: dz, s_fac, dlnp + real ztop, t0, dz0, sum1, tmp1 + real ep, es, alpha, beta, gama + integer k + + pe1(1) = ptop + peln(1) = log(pe1(1)) + pe1(km+1) = p00 + peln(km+1) = log(pe1(km+1)) + + t0 = 270. + ztop = rdgas/grav*t0*(peln(km+1) - peln(1)) + + s_fac(km ) = 0.15 + s_fac(km-1) = 0.20 + s_fac(km-2) = 0.30 + s_fac(km-3) = 0.40 + s_fac(km-4) = 0.50 + s_fac(km-5) = 0.60 + s_fac(km-6) = 0.70 + s_fac(km-7) = 0.80 + s_fac(km-8) = 0.90 + s_fac(km-9) = 0.95 + s_fac(km-10) = 0.5*(s_fac(km-9) + s_rate) + + do k=km-11, 8, -1 + s_fac(k) = s_rate * s_fac(k+1) + enddo + + s_fac(7) = 0.5*(1.1+s_rate)*s_fac(9) + s_fac(6) = 1.05*s_fac(7) + s_fac(5) = 1.1*s_fac(6) + s_fac(4) = 1.15*s_fac(5) + s_fac(3) = 1.2*s_fac(4) + s_fac(2) = 1.3*s_fac(3) + s_fac(1) = 1.4*s_fac(2) + + sum1 = 0. + do k=1,km + sum1 = sum1 + s_fac(k) + enddo + + dz0 = ztop / sum1 + + do k=1,km + dz(k) = s_fac(k) * dz0 + enddo + + ze(km+1) = 0. + do k=km,1,-1 + ze(k) = ze(k+1) + dz(k) + enddo + +! Re-scale dz with the stretched ztop + do k=1,km + dz(k) = dz(k) * (ztop/ze(1)) + enddo + + do k=km,1,-1 + ze(k) = ze(k+1) + dz(k) + enddo +! ze(1) = ztop + + if ( is_master() ) write(*,*) 'var_hi2: computed model top (m)=', ztop*0.001, ' bottom/top dz=', dz(km), dz(1) + call sm1_edge(1, 1, 1, 1, km, 1, 1, ze, 1) + +! Given z --> p + do k=1,km + dz(k) = ze(k) - ze(k+1) + dlnp(k) = grav*dz(k) / (rdgas*t0) + enddo + do k=2,km + peln(k) = peln(k-1) + dlnp(k-1) + pe1(k) = exp(peln(k)) + enddo + +! Pe(k) = ak(k) + bk(k) * PS +! Locate pint and KS + ks = 0 + do k=2,km + if ( pint < pe1(k)) then + ks = k-1 + exit + endif + enddo + if ( is_master() ) then + write(*,*) 'For (input) PINT=', 0.01*pint, ' KS=', ks, 'pint(computed)=', 0.01*pe1(ks+1) + endif + pint = pe1(ks+1) + +#ifdef NO_UKMO_HB + do k=1,ks+1 + ak(k) = pe1(k) + bk(k) = 0. + enddo + + do k=ks+2,km+1 + bk(k) = (pe1(k) - pint) / (pe1(km+1)-pint) ! bk == sigma + ak(k) = pe1(k) - bk(k) * pe1(km+1) + enddo + bk(km+1) = 1. + ak(km+1) = 0. +#else +! Problematic for non-hydrostatic + do k=1,km+1 + eta(k) = pe1(k) / pe1(km+1) + enddo + + ep = eta(ks+1) + es = eta(km) +! es = 1. + alpha = (ep**2-2.*ep*es) / (es-ep)**2 + beta = 2.*ep*es**2 / (es-ep)**2 + gama = -(ep*es)**2 / (es-ep)**2 + +! Pure pressure: + do k=1,ks+1 + ak(k) = eta(k)*1.e5 + bk(k) = 0. + enddo + + do k=ks+2, km + ak(k) = alpha*eta(k) + beta + gama/eta(k) + ak(k) = ak(k)*1.e5 + enddo + ak(km+1) = 0. + + do k=ks+2, km + bk(k) = (pe1(k) - ak(k))/pe1(km+1) + enddo + bk(km+1) = 1. +#endif + + if ( is_master() ) then + write(*,*) 'KS=', ks, 'PINT (mb)=', pint/100. + do k=1,km + write(*,*) k, 0.5*(pe1(k)+pe1(k+1))/100., dz(k) + enddo + tmp1 = ak(ks+1) + do k=ks+1,km + tmp1 = max(tmp1, (ak(k)-ak(k+1))/max(1.E-5, (bk(k+1)-bk(k))) ) + enddo + write(*,*) 'Hybrid Sigma-P: minimum allowable surface pressure (hpa)=', tmp1/100. + endif + + + end subroutine var_hi2 + + + subroutine var_dz(km, ak, bk, ptop, ks, pint, s_rate) + integer, intent(in):: km + real, intent(in):: ptop + real, intent(in):: s_rate ! between [1. 1.1] + real, intent(out):: ak(km+1), bk(km+1) + real, intent(inout):: pint + integer, intent(out):: ks +! Local + real, parameter:: p00 = 1.E5 + real, dimension(km+1):: ze, pe1, peln, eta + real, dimension(km):: dz, s_fac, dlnp + real ztop, t0, dz0, sum1, tmp1 + real ep, es, alpha, beta, gama + integer k + + pe1(1) = ptop + peln(1) = log(pe1(1)) + pe1(km+1) = p00 + peln(km+1) = log(pe1(km+1)) + + t0 = 270. + ztop = rdgas/grav*t0*(peln(km+1) - peln(1)) + + s_fac(km ) = 0.10 + s_fac(km-1) = 0.20 + s_fac(km-2) = 0.30 + s_fac(km-3) = 0.40 + s_fac(km-4) = 0.50 + s_fac(km-5) = 0.60 + s_fac(km-6) = 0.70 + s_fac(km-7) = 0.80 + s_fac(km-8) = 0.90 + s_fac(km-9) = 0.95 + s_fac(km-10) = 0.5*(s_fac(km-9) + s_rate) + + do k=km-11, 9, -1 + s_fac(k) = min(10.0, s_rate * s_fac(k+1) ) + enddo + + s_fac(8) = 0.5*(1.1+s_rate)*s_fac(9) + s_fac(7) = 1.1 *s_fac(8) + s_fac(6) = 1.15*s_fac(7) + s_fac(5) = 1.2 *s_fac(6) + s_fac(4) = 1.3 *s_fac(5) + s_fac(3) = 1.4 *s_fac(4) + s_fac(2) = 1.5 *s_fac(3) + s_fac(1) = 1.6 *s_fac(2) + + sum1 = 0. + do k=1,km + sum1 = sum1 + s_fac(k) + enddo + + dz0 = ztop / sum1 + + do k=1,km + dz(k) = s_fac(k) * dz0 + enddo + + ze(km+1) = 0. + do k=km,1,-1 + ze(k) = ze(k+1) + dz(k) + enddo + +! Re-scale dz with the stretched ztop + do k=1,km + dz(k) = dz(k) * (ztop/ze(1)) + enddo + + do k=km,1,-1 + ze(k) = ze(k+1) + dz(k) + enddo +! ze(1) = ztop + + if ( is_master() ) write(*,*) 'var_dz: computed model top (m)=', ztop*0.001, ' bottom/top dz=', dz(km), dz(1) + call sm1_edge(1, 1, 1, 1, km, 1, 1, ze, 1) + +! Given z --> p + do k=1,km + dz(k) = ze(k) - ze(k+1) + dlnp(k) = grav*dz(k) / (rdgas*t0) + enddo + do k=2,km + peln(k) = peln(k-1) + dlnp(k-1) + pe1(k) = exp(peln(k)) + enddo + +! Pe(k) = ak(k) + bk(k) * PS +! Locate pint and KS + ks = 0 + do k=2,km + if ( pint < pe1(k)) then + ks = k-1 + exit + endif + enddo + if ( is_master() ) then + write(*,*) 'For (input) PINT=', 0.01*pint, ' KS=', ks, 'pint(computed)=', 0.01*pe1(ks+1) + write(*,*) 'ptop =', ptop + endif + pint = pe1(ks+1) + +#ifdef NO_UKMO_HB + do k=1,ks+1 + ak(k) = pe1(k) + bk(k) = 0. + enddo + + do k=ks+2,km+1 + bk(k) = (pe1(k) - pint) / (pe1(km+1)-pint) ! bk == sigma + ak(k) = pe1(k) - bk(k) * pe1(km+1) + enddo + bk(km+1) = 1. + ak(km+1) = 0. +#else +! Problematic for non-hydrostatic + do k=1,km+1 + eta(k) = pe1(k) / pe1(km+1) + enddo + + ep = eta(ks+1) + es = eta(km) +! es = 1. + alpha = (ep**2-2.*ep*es) / (es-ep)**2 + beta = 2.*ep*es**2 / (es-ep)**2 + gama = -(ep*es)**2 / (es-ep)**2 + +! Pure pressure: + do k=1,ks+1 + ak(k) = eta(k)*1.e5 + bk(k) = 0. + enddo + + do k=ks+2, km + ak(k) = alpha*eta(k) + beta + gama/eta(k) + ak(k) = ak(k)*1.e5 + enddo + ak(km+1) = 0. + + do k=ks+2, km + bk(k) = (pe1(k) - ak(k))/pe1(km+1) + enddo + bk(km+1) = 1. +#endif + + if ( is_master() ) then + write(*,*) 'KS=', ks, 'PINT (mb)=', pint/100. + do k=1,km + write(*,*) k, 0.5*(pe1(k)+pe1(k+1))/100., dz(k) + enddo + tmp1 = ak(ks+1) + do k=ks+1,km + tmp1 = max(tmp1, (ak(k)-ak(k+1))/max(1.E-5, (bk(k+1)-bk(k))) ) + enddo + write(*,*) 'Hybrid Sigma-P: minimum allowable surface pressure (hpa)=', tmp1/100. + endif + + + end subroutine var_dz + + + subroutine var55_dz(km, ak, bk, ptop, ks, pint, s_rate) + integer, intent(in):: km + real, intent(in):: ptop + real, intent(in):: s_rate ! between [1. 1.1] + real, intent(out):: ak(km+1), bk(km+1) + real, intent(inout):: pint + integer, intent(out):: ks +! Local + real, parameter:: p00 = 1.E5 + real, dimension(km+1):: ze, pe1, peln, eta + real, dimension(km):: dz, s_fac, dlnp + real ztop, t0, dz0, sum1, tmp1 + real ep, es, alpha, beta, gama + integer k + + pe1(1) = ptop + peln(1) = log(pe1(1)) + pe1(km+1) = p00 + peln(km+1) = log(pe1(km+1)) + + t0 = 270. + ztop = rdgas/grav*t0*(peln(km+1) - peln(1)) + + s_fac(km ) = 0.10 + s_fac(km-1) = 0.15 + s_fac(km-2) = 0.20 + s_fac(km-3) = 0.25 + s_fac(km-4) = 0.30 + s_fac(km-5) = 0.35 + s_fac(km-6) = 0.40 + s_fac(km-7) = 0.45 + s_fac(km-8) = 0.50 + s_fac(km-9) = 0.55 + s_fac(km-10) = 0.60 + s_fac(km-11) = 0.70 + s_fac(km-12) = 0.85 + s_fac(km-13) = 1.00 + + do k=km-14, 9, -1 + s_fac(k) = min(10.0, s_rate * s_fac(k+1) ) + enddo + + s_fac(8) = 0.5*(1.1+s_rate)*s_fac(9) + s_fac(7) = 1.1 *s_fac(8) + s_fac(6) = 1.15*s_fac(7) + s_fac(5) = 1.2 *s_fac(6) + s_fac(4) = 1.3 *s_fac(5) + s_fac(3) = 1.4 *s_fac(4) + s_fac(2) = 1.5 *s_fac(3) + s_fac(1) = 1.6 *s_fac(2) + + sum1 = 0. + do k=1,km + sum1 = sum1 + s_fac(k) + enddo + + dz0 = ztop / sum1 + + do k=1,km + dz(k) = s_fac(k) * dz0 + enddo + + ze(km+1) = 0. + do k=km,1,-1 + ze(k) = ze(k+1) + dz(k) + enddo + +! Re-scale dz with the stretched ztop + do k=1,km + dz(k) = dz(k) * (ztop/ze(1)) + enddo + + do k=km,1,-1 + ze(k) = ze(k+1) + dz(k) + enddo +! ze(1) = ztop + + if ( is_master() ) write(*,*) 'var55_dz: computed model top (m)=', ztop*0.001, ' bottom/top dz=', dz(km), dz(1) + call sm1_edge(1, 1, 1, 1, km, 1, 1, ze, 2) + +! Given z --> p + do k=1,km + dz(k) = ze(k) - ze(k+1) + dlnp(k) = grav*dz(k) / (rdgas*t0) + enddo + do k=2,km + peln(k) = peln(k-1) + dlnp(k-1) + pe1(k) = exp(peln(k)) + enddo + +! Pe(k) = ak(k) + bk(k) * PS +! Locate pint and KS + ks = 0 + do k=2,km + if ( pint < pe1(k)) then + ks = k-1 + exit + endif + enddo + if ( is_master() ) then + write(*,*) 'For (input) PINT=', 0.01*pint, ' KS=', ks, 'pint(computed)=', 0.01*pe1(ks+1) + endif + pint = pe1(ks+1) + +#ifdef NO_UKMO_HB + do k=1,ks+1 + ak(k) = pe1(k) + bk(k) = 0. + enddo + + do k=ks+2,km+1 + bk(k) = (pe1(k) - pint) / (pe1(km+1)-pint) ! bk == sigma + ak(k) = pe1(k) - bk(k) * pe1(km+1) + enddo + bk(km+1) = 1. + ak(km+1) = 0. +#else +! Problematic for non-hydrostatic + do k=1,km+1 + eta(k) = pe1(k) / pe1(km+1) + enddo + + ep = eta(ks+1) + es = eta(km) +! es = 1. + alpha = (ep**2-2.*ep*es) / (es-ep)**2 + beta = 2.*ep*es**2 / (es-ep)**2 + gama = -(ep*es)**2 / (es-ep)**2 + +! Pure pressure: + do k=1,ks+1 + ak(k) = eta(k)*1.e5 + bk(k) = 0. + enddo + + do k=ks+2, km + ak(k) = alpha*eta(k) + beta + gama/eta(k) + ak(k) = ak(k)*1.e5 + enddo + ak(km+1) = 0. + + do k=ks+2, km + bk(k) = (pe1(k) - ak(k))/pe1(km+1) + enddo + bk(km+1) = 1. +#endif + + if ( is_master() ) then + write(*,*) 'KS=', ks, 'PINT (mb)=', pint/100. + do k=1,km + write(*,*) k, 0.5*(pe1(k)+pe1(k+1))/100., dz(k) + enddo + tmp1 = ak(ks+1) + do k=ks+1,km + tmp1 = max(tmp1, (ak(k)-ak(k+1))/max(1.E-5, (bk(k+1)-bk(k))) ) + enddo + write(*,*) 'Hybrid Sigma-P: minimum allowable surface pressure (hpa)=', tmp1/100. + endif + + + end subroutine var55_dz + + subroutine hybrid_z_dz(km, dz, ztop, s_rate) + integer, intent(in):: km + real, intent(in):: s_rate ! between [1. 1.1] + real, intent(in):: ztop + real, intent(out):: dz(km) +! Local + real, parameter:: p00 = 1.E5 + real, dimension(km+1):: ze, pe1, peln, eta + real, dimension(km):: s_fac, dlnp + real t0, dz0, sum1, tmp1 + real ep, es, alpha, beta, gama + integer k + + s_fac(km ) = 0.12 + s_fac(km-1) = 0.20 + s_fac(km-2) = 0.30 + s_fac(km-3) = 0.40 + s_fac(km-4) = 0.50 + s_fac(km-5) = 0.60 + s_fac(km-6) = 0.70 + s_fac(km-7) = 0.80 + s_fac(km-8) = 0.90 + s_fac(km-9) = 1. + + do k=km-10, 9, -1 + s_fac(k) = min(4.0, s_rate * s_fac(k+1) ) + enddo + + s_fac(8) = 1.05*s_fac(9) + s_fac(7) = 1.1 *s_fac(8) + s_fac(6) = 1.15*s_fac(7) + s_fac(5) = 1.2 *s_fac(6) + s_fac(4) = 1.3 *s_fac(5) + s_fac(3) = 1.4 *s_fac(4) + s_fac(2) = 1.5 *s_fac(3) + s_fac(1) = 1.6 *s_fac(2) + + sum1 = 0. + do k=1,km + sum1 = sum1 + s_fac(k) + enddo + + dz0 = ztop / sum1 + + do k=1,km + dz(k) = s_fac(k) * dz0 + enddo + + ze(km+1) = 0. + do k=km,1,-1 + ze(k) = ze(k+1) + dz(k) + enddo + + ze(1) = ztop + + call sm1_edge(1, 1, 1, 1, km, 1, 1, ze, 2) + + do k=1,km + dz(k) = ze(k) - ze(k+1) + enddo + + end subroutine hybrid_z_dz + + + subroutine check_eta_levels(ak, bk) + real, intent(in) :: ak(:) + real, intent(in) :: bk(:) + !--- local variables + real :: ph1, tmp + integer :: nlev, k + logical :: monotonic + + nlev = size(ak(:)) + + monotonic = .true. + ph1 = ak(1) + do k=2,nlev + tmp = ak(k) + bk(k)*1000.E2 + if (tmp <= ph1) then + monotonic = .false. + exit + endif + ph1 = tmp + enddo + + if (.not. monotonic) then + if (is_master()) then + write(*, '(A4, A13, A13, A11)') 'klev', 'ak', 'bk', 'p_ref' + do k=1,nlev + write(*,'(I4, F13.5, F13.5, F11.2)') k, ak(k), bk(k), ak(k) + bk(k)*1000.E2 + enddo + endif + print*, 'FV3 check_eta_levels',"ak/bk pairs do not provide a monotonic vertical coordinate" + endif + + end subroutine check_eta_levels + + + subroutine get_eta_level(npz, p_s, pf, ph, ak, bk, pscale) + integer, intent(in) :: npz + real, intent(in) :: p_s ! unit: pascal + real, intent(in) :: ak(npz+1) + real, intent(in) :: bk(npz+1) + real, intent(in), optional :: pscale + real, intent(out) :: pf(npz) + real, intent(out) :: ph(npz+1) + integer k + + ph(1) = ak(1) + do k=2,npz+1 + ph(k) = ak(k) + bk(k)*p_s + enddo + + if ( present(pscale) ) then + do k=1,npz+1 + ph(k) = pscale*ph(k) + enddo + endif + + if( ak(1) > 1.E-8 ) then + pf(1) = (ph(2) - ph(1)) / log(ph(2)/ph(1)) + else + pf(1) = (ph(2) - ph(1)) * kappa/(kappa+1.) + endif + + do k=2,npz + pf(k) = (ph(k+1) - ph(k)) / log(ph(k+1)/ph(k)) + enddo + + end subroutine get_eta_level + + + + subroutine compute_dz(km, ztop, dz) + + integer, intent(in):: km + real, intent(in):: ztop ! try 50.E3 + real, intent(out):: dz(km) +!------------------------------ + real ze(km+1), dzt(km) + integer k + + +! ztop = 30.E3 + dz(1) = ztop / real(km) + dz(km) = 0.5*dz(1) + + do k=2,km-1 + dz(k) = dz(1) + enddo + +! Top: + dz(1) = 2.*dz(2) + + ze(km+1) = 0. + do k=km,1,-1 + ze(k) = ze(k+1) + dz(k) + enddo + + if ( is_master() ) then + write(*,*) 'Hybrid_z: dz, zm' + do k=1,km + dzt(k) = 0.5*(ze(k)+ze(k+1)) / 1000. + write(*,*) k, dz(k), dzt(k) + enddo + endif + + end subroutine compute_dz + + subroutine compute_dz_var(km, ztop, dz) + + integer, intent(in):: km + real, intent(in):: ztop ! try 50.E3 + real, intent(out):: dz(km) +!------------------------------ + real, parameter:: s_rate = 1.0 + real ze(km+1) + real s_fac(km) + real sum1, dz0 + integer k + + s_fac(km ) = 0.125 + s_fac(km-1) = 0.20 + s_fac(km-2) = 0.30 + s_fac(km-3) = 0.40 + s_fac(km-4) = 0.50 + s_fac(km-5) = 0.60 + s_fac(km-6) = 0.70 + s_fac(km-7) = 0.80 + s_fac(km-8) = 0.90 + s_fac(km-9) = 1. + + do k=km-10, 9, -1 + s_fac(k) = s_rate * s_fac(k+1) + enddo + + s_fac(8) = 1.05*s_fac(9) + s_fac(7) = 1.1 *s_fac(8) + s_fac(6) = 1.15*s_fac(7) + s_fac(5) = 1.2 *s_fac(6) + s_fac(4) = 1.3 *s_fac(5) + s_fac(3) = 1.4 *s_fac(4) + s_fac(2) = 1.5 *s_fac(3) + s_fac(1) = 1.6 *s_fac(2) + + sum1 = 0. + do k=1,km + sum1 = sum1 + s_fac(k) + enddo + + dz0 = ztop / sum1 + + do k=1,km + dz(k) = s_fac(k) * dz0 + enddo + + ze(1) = ztop + ze(km+1) = 0. + do k=km,2,-1 + ze(k) = ze(k+1) + dz(k) + enddo + +! Re-scale dz with the stretched ztop + do k=1,km + dz(k) = dz(k) * (ztop/ze(1)) + enddo + + do k=km,2,-1 + ze(k) = ze(k+1) + dz(k) + enddo + + call sm1_edge(1, 1, 1, 1, km, 1, 1, ze, 2) + + do k=1,km + dz(k) = ze(k) - ze(k+1) + enddo + + end subroutine compute_dz_var + + subroutine compute_dz_L32(km, ztop, dz) + + integer, intent(in):: km + real, intent(out):: dz(km) + real, intent(out):: ztop ! try 50.E3 +!------------------------------ + real dzt(km) + real ze(km+1) + real dz0, dz1, dz2 + real z0, z1, z2 + integer k, k0, k1, k2, n + +!------------------- + k2 = 8 + z2 = 30.E3 +!------------------- + k1 = 21 + z1 = 10.0E3 +!------------------- + k0 = 2 + z0 = 0. + dz0 = 75. ! meters +!------------------- +! Treat the surface layer as a special layer + ze(1) = z0 + dz(1) = dz0 + + ze(2) = dz(1) + dz0 = 1.5*dz0 + dz(2) = dz0 + + ze(3) = ze(2) + dz(2) + + dz1 = 2.*(z1-ze(3) - k1*dz0) / (k1*(k1-1)) + + do k=k0+1,k0+k1 + dz(k) = dz0 + (k-k0)*dz1 + ze(k+1) = ze(k) + dz(k) + enddo + + dz0 = dz(k1+k0) + dz2 = 2.*(z2-ze(k0+k1+1)-k2*dz0) / (k2*(k2-1)) + + do k=k0+k1+1,k0+k1+k2 + dz(k) = dz0 + (k-k0-k1)*dz2 + ze(k+1) = ze(k) + dz(k) + enddo + + dz(km) = 2.*dz(km-1) + ztop = ze(km) + dz(km) + ze(km+1) = ze(km) + dz(km) + + call zflip (dz, 1, km) + + ze(km+1) = 0. + do k=km,1,-1 + ze(k) = ze(k+1) + dz(k) + enddo + +! if ( is_master() ) then +! write(*,*) 'Hybrid_z: dz, zm' +! do k=1,km +! dzt(k) = 0.5*(ze(k)+ze(k+1)) / 1000. +! write(*,*) k, dz(k), dzt(k) +! enddo +! endif + + end subroutine compute_dz_L32 + + subroutine compute_dz_L101(km, ztop, dz) + + integer, intent(in):: km ! km==101 + real, intent(out):: dz(km) + real, intent(out):: ztop ! try 30.E3 +!------------------------------ + real ze(km+1) + real dz0, dz1 + real:: stretch_f = 1.16 + integer k, k0, k1 + + k1 = 2 + k0 = 25 + dz0 = 40. ! meters + + ze(km+1) = 0. + + do k=km, k0, -1 + dz(k) = dz0 + ze(k) = ze(k+1) + dz(k) + enddo + + do k=k0+1, k1, -1 + dz(k) = stretch_f * dz(k+1) + ze(k) = ze(k+1) + dz(k) + enddo + + dz(1) = 4.0*dz(2) + ze(1) = ze(2) + dz(1) + ztop = ze(1) + + if ( is_master() ) then + write(*,*) 'Hybrid_z: dz, ze' + do k=1,km + write(*,*) k, 0.001*dz(k), 0.001*ze(k) + enddo +! ztop (km) = 20.2859154 + write(*,*) 'ztop (km) =', ztop * 0.001 + endif + + end subroutine compute_dz_L101 + + subroutine set_hybrid_z(is, ie, js, je, ng, km, ztop, dz, rgrav, hs, ze, dz3) + + integer, intent(in):: is, ie, js, je, ng, km + real, intent(in):: rgrav, ztop + real, intent(in):: dz(km) ! Reference vertical resolution for zs=0 + real, intent(in):: hs(is-ng:ie+ng,js-ng:je+ng) + real, intent(inout):: ze(is:ie,js:je,km+1) + real, optional, intent(out):: dz3(is-ng:ie+ng,js-ng:je+ng,km) +! local + logical:: filter_xy = .false. + real, allocatable:: delz(:,:,:) + integer ntimes + real zint + real:: z1(is:ie,js:je) + real:: z(km+1) + real sig, z_rat + integer ks(is:ie,js:je) + integer i, j, k, ks_min, kint + + z(km+1) = 0. + do k=km,1,-1 + z(k) = z(k+1) + dz(k) + enddo + + do j=js,je + do i=is,ie + ze(i,j, 1) = ztop + ze(i,j,km+1) = hs(i,j) * rgrav + enddo + enddo + + do k=2,km + do j=js,je + do i=is,ie + ze(i,j,k) = z(k) + enddo + enddo + enddo + +! Set interface: +#ifndef USE_VAR_ZINT + zint = 12.0E3 + ntimes = 2 + kint = 2 + do k=2,km + if ( z(k)<=zint ) then + kint = k + exit + endif + enddo + + if ( is_master() ) write(*,*) 'Z_coord interface set at k=',kint, ' ZE=', z(kint) + + do j=js,je + do i=is,ie + z_rat = (ze(i,j,kint)-ze(i,j,km+1)) / (z(kint)-z(km+1)) + do k=km,kint+1,-1 + ze(i,j,k) = ze(i,j,k+1) + dz(k)*z_rat + enddo +!-------------------------------------- +! Apply vertical smoother locally to dz +!-------------------------------------- + call sm1_edge(is, ie, js, je, km, i, j, ze, ntimes) + enddo + enddo +#else +! ZINT is a function of local terrain + ntimes = 4 + do j=js,je + do i=is,ie + z1(i,j) = dim(ze(i,j,km+1), 2500.) + 7500. + enddo + enddo + + ks_min = km + do j=js,je + do i=is,ie + do k=km,2,-1 + if ( z(k)>=z1(i,j) ) then + ks(i,j) = k + ks_min = min(ks_min, k) + go to 555 + endif + enddo +555 continue + enddo + enddo + + do j=js,je + do i=is,ie + kint = ks(i,j) + 1 + z_rat = (ze(i,j,kint)-ze(i,j,km+1)) / (z(kint)-z(km+1)) + do k=km,kint+1,-1 + ze(i,j,k) = ze(i,j,k+1) + dz(k)*z_rat + enddo +!-------------------------------------- +! Apply vertical smoother locally to dz +!-------------------------------------- + call sm1_edge(is, ie, js, je, km, i, j, ze, ntimes) + enddo + enddo +#endif + +#ifdef DEV_ETA + if ( filter_xy ) then + allocate (delz(isd:ied, jsd:jed, km) ) + ntimes = 2 + do k=1,km + do j=js,je + do i=is,ie + delz(i,j,k) = ze(i,j,k+1) - ze(i,j,k) + enddo + enddo + enddo + call del2_cubed(delz, 0.2*da_min, npx, npy, km, ntimes) + do k=km,2,-1 + do j=js,je + do i=is,ie + ze(i,j,k) = ze(i,j,k+1) - delz(i,j,k) + enddo + enddo + enddo + deallocate ( delz ) + endif +#endif + if ( present(dz3) ) then + do k=1,km + do j=js,je + do i=is,ie + dz3(i,j,k) = ze(i,j,k+1) - ze(i,j,k) + enddo + enddo + enddo + endif + + end subroutine set_hybrid_z + + + subroutine sm1_edge(is, ie, js, je, km, i, j, ze, ntimes) + integer, intent(in):: is, ie, js, je, km + integer, intent(in):: ntimes, i, j + real, intent(inout):: ze(is:ie,js:je,km+1) +! local: + real, parameter:: df = 0.25 + real dz(km) + real flux(km+1) + integer k, n, k1, k2 + + k2 = km-1 + do k=1,km + dz(k) = ze(i,j,k+1) - ze(i,j,k) + enddo + + do n=1,ntimes + k1 = 2 + (ntimes-n) + + flux(k1 ) = 0. + flux(k2+1) = 0. + do k=k1+1,k2 + flux(k) = df*(dz(k) - dz(k-1)) + enddo + + do k=k1,k2 + dz(k) = dz(k) - flux(k) + flux(k+1) + enddo + enddo + + do k=km,1,-1 + ze(i,j,k) = ze(i,j,k+1) - dz(k) + enddo + + end subroutine sm1_edge + + + + subroutine gw_1d(km, p0, ak, bk, ptop, ztop, pt1) + integer, intent(in):: km + real, intent(in):: p0, ztop + real, intent(inout):: ptop + real, intent(inout):: ak(km+1), bk(km+1) + real, intent(out):: pt1(km) +! Local + logical:: isothermal + real, dimension(km+1):: ze, pe1, pk1 + real, dimension(km):: dz1 + real t0, n2, s0 + integer k + +! Set up vertical coordinare with constant del-z spacing: + isothermal = .false. + t0 = 300. + + if ( isothermal ) then + n2 = grav**2/(cp_air*t0) + else + n2 = 0.0001 + endif + + s0 = grav*grav / (cp_air*n2) + + ze(km+1) = 0. + do k=km,1,-1 + dz1(k) = ztop / real(km) + ze(k) = ze(k+1) + dz1(k) + enddo + +! Given z --> p + do k=1,km+1 + pe1(k) = p0*( (1.-s0/t0) + s0/t0*exp(-n2*ze(k)/grav) )**(1./kappa) + enddo + + ptop = pe1(1) +! if ( is_master() ) write(*,*) 'GW_1D: computed model top (pa)=', ptop + +! Set up "sigma" coordinate + ak(1) = pe1(1) + bk(1) = 0. + do k=2,km + bk(k) = (pe1(k) - pe1(1)) / (pe1(km+1)-pe1(1)) ! bk == sigma + ak(k) = pe1(1)*(1.-bk(k)) + enddo + ak(km+1) = 0. + bk(km+1) = 1. + + do k=1,km+1 + pk1(k) = pe1(k) ** kappa + enddo + +! Compute volume mean potential temperature with hydrostatic eqn: + do k=1,km + pt1(k) = grav*dz1(k) / ( cp_air*(pk1(k+1)-pk1(k)) ) + enddo + + end subroutine gw_1d + + subroutine mount_waves(km, ak, bk, ptop, ks, pint) + integer, intent(in):: km + real, intent(out):: ak(km+1), bk(km+1) + real, intent(out):: ptop, pint + integer, intent(out):: ks +! Local + real, parameter:: p00 = 1.E5 + real, dimension(km+1):: ze, pe1, peln, eta + real, dimension(km):: dz, dlnp + real ztop, t0, dz0, sum1, tmp1 + real ep, es, alpha, beta, gama, s_fac + integer k, k500 + + pint = 300.e2 +! s_fac = 1.05 +! dz0 = 500. + if ( km <= 60 ) then + s_fac = 1.0 + dz0 = 500. + else + s_fac = 1. + dz0 = 250. + endif + +! Basic parameters for HIWPP mountain waves + t0 = 300. +! ztop = 20.0e3; 500-m resolution in halft of the vertical domain +! ztop = real(km-1)*500. +!----------------------- +! Compute temp ptop based on isothermal atm +! ptop = p00*exp(-grav*ztop/(rdgas*t0)) + +! Lowest half has constant resolution + ze(km+1) = 0. + do k=km, km-19, -1 + ze(k) = ze(k+1) + dz0 + enddo + +! Stretching from 10-km and up: + do k=km-20, 3, -1 + dz0 = s_fac * dz0 + ze(k) = ze(k+1) + dz0 + enddo + ze(2) = ze(3) + sqrt(2.)*dz0 + ze(1) = ze(2) + 2.0*dz0 + +! call sm1_edge(1, 1, 1, 1, km, 1, 1, ze, 1) + +! Given z --> p + do k=1,km + dz(k) = ze(k) - ze(k+1) + dlnp(k) = grav*dz(k) / (rdgas*t0) + enddo + + pe1(km+1) = p00 + peln(km+1) = log(p00) + do k=km,1,-1 + peln(k) = peln(k+1) - dlnp(k) + pe1(k) = exp(peln(k)) + enddo + +! Comnpute new ptop + ptop = pe1(1) + +! Pe(k) = ak(k) + bk(k) * PS +! Locate pint and KS + ks = 0 + do k=2,km + if ( pint < pe1(k)) then + ks = k-1 + exit + endif + enddo + + if ( is_master() ) then + write(*,*) 'For (input) PINT=', 0.01*pint, ' KS=', ks, 'pint(computed)=', 0.01*pe1(ks+1) + write(*,*) 'Modified ptop =', ptop, ' ztop=', ze(1)/1000. + do k=1,km + write(*,*) k, 'ze =', ze(k)/1000. + enddo + endif + pint = pe1(ks+1) + +#ifdef NO_UKMO_HB + do k=1,ks+1 + ak(k) = pe1(k) + bk(k) = 0. + enddo + + do k=ks+2,km+1 + bk(k) = (pe1(k) - pint) / (pe1(km+1)-pint) ! bk == sigma + ak(k) = pe1(k) - bk(k) * pe1(km+1) + enddo + bk(km+1) = 1. + ak(km+1) = 0. +#else +! Problematic for non-hydrostatic + do k=1,km+1 + eta(k) = pe1(k) / pe1(km+1) + enddo + ep = eta(ks+1) + es = eta(km) +! es = 1. + alpha = (ep**2-2.*ep*es) / (es-ep)**2 + beta = 2.*ep*es**2 / (es-ep)**2 + gama = -(ep*es)**2 / (es-ep)**2 + +! Pure pressure: + do k=1,ks+1 + ak(k) = eta(k)*1.e5 + bk(k) = 0. + enddo + + do k=ks+2, km + ak(k) = alpha*eta(k) + beta + gama/eta(k) + ak(k) = ak(k)*1.e5 + enddo + ak(km+1) = 0. + + do k=ks+2, km + bk(k) = (pe1(k) - ak(k))/pe1(km+1) + enddo + bk(km+1) = 1. +#endif + + if ( is_master() ) then + tmp1 = ak(ks+1) + do k=ks+1,km + tmp1 = max(tmp1, (ak(k)-ak(k+1))/max(1.E-5, (bk(k+1)-bk(k))) ) + enddo + write(*,*) 'Hybrid Sigma-P: minimum allowable surface pressure (hpa)=', tmp1/100. + endif + + end subroutine mount_waves + + + subroutine zflip(q, im, km) + integer, intent(in):: im, km + real, intent(inout):: q(im,km) +!--- + integer i, k + real qtmp + + do i = 1, im + do k = 1, (km+1)/2 + qtmp = q(i,k) + q(i,k) = q(i,km+1-k) + q(i,km+1-k) = qtmp + end do + end do + + end subroutine zflip + + logical function is_master() + is_master = .false. + end function is_master + +end module fv_eta_mod diff --git a/docs/examples/FV3_level_transmogrifier/fv_eta.h b/docs/examples/FV3_level_transmogrifier/fv_eta.h new file mode 100644 index 000000000..83a7cc129 --- /dev/null +++ b/docs/examples/FV3_level_transmogrifier/fv_eta.h @@ -0,0 +1,1241 @@ +! -*-f90-*-* +!*********************************************************************** +!* GNU Lesser General Public License +!* +!* This file is part of the FV3 dynamical core. +!* +!* The FV3 dynamical core is free software: you can redistribute it +!* and/or modify it under the terms of the +!* GNU Lesser General Public License as published by the +!* Free Software Foundation, either version 3 of the License, or +!* (at your option) any later version. +!* +!* The FV3 dynamical core is distributed in the hope that it will be +!* useful, but WITHOUT ANY WARRANTY; without even the implied warranty +!* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. +!* See the GNU General Public License for more details. +!* +!* You should have received a copy of the GNU Lesser General Public +!* License along with the FV3 dynamical core. +!* If not, see . +!*********************************************************************** + +#ifndef _FV_ETA_ +#define _FV_ETA__ + + + +! local + real a24(25),b24(25) ! GFDL AM2L24 + real a26(27),b26(27) ! Jablonowski & Williamson 26-level + real a32old(33),b32old(33) + real a32(33),b32(33) + real a32w(33),b32w(33) + real a33(34),b33(34) ! miz: grid with enhanced surface-layer resolution + real a47(48),b47(48) + real a48(49),b48(49) + real a50(51),b50(51) ! kyc: HRRRv3 grid + real a52(53),b52(53) + real a54(55),b54(55) + real a56(57),b56(57) + real a60(61),b60(61) + real a60gfs(61),b60gfs(61) + real a63(64),b63(64) + real a63meso(64),b63meso(64) + real a64(65),b64(65) + real a64gfs(65),b64gfs(65) + real a65(66),b65(66) ! kgao: L65 with enhanced surface resolution by xi chen + real a68(69),b68(69) ! cjg: grid with enhanced PBL resolution + real a96(97),b96(97) ! cjg: grid with enhanced PBL resolution + real a88(89),b88(89) ! kgao: grid with enhanced PBL resolution + real a75(76),b75(76) ! kgao: emc grid with enhanced PBL resolution + real a100(101),b100(101) + real a104(105),b104(105) + real a125(126),b125(126) + real a127(128),b127(128) + +!----------------------------------------------- +! GFDL AM2-L24: modified by SJL at the model top +!----------------------------------------------- +! data a24 / 100.0000, 1050.0000, 3474.7942, 7505.5556, 12787.2428, & + data a24 / 100.0000, 903.4465, 3474.7942, 7505.5556, 12787.2428, & + 19111.3683, 21854.9274, 22884.1866, 22776.3058, 21716.1604, & + 20073.2963, 18110.5123, 16004.7832, 13877.6253, 11812.5452, & + 9865.8840, 8073.9726, 6458.0834, 5027.9899, 3784.6085, & + 2722.0086, 1828.9752, 1090.2396, 487.4595, 0.0000 / + + data b24 / 0.0000000, 0.0000000, 0.0000000, 0.0000000, 0.0000000, & + 0.0000000, 0.0435679, 0.1102275, 0.1922249, 0.2817656, & + 0.3694997, 0.4532348, 0.5316253, 0.6038733, 0.6695556, & + 0.7285176, 0.7808017, 0.8265992, 0.8662148, 0.9000406, & + 0.9285364, 0.9522140, 0.9716252, 0.9873523, 1.0000000 / + +! Jablonowski & Williamson 26-level setup + data a26 / 219.4067, 489.5209, 988.2418, 1805.2010, 2983.7240, 4462.3340, & + 6160.5870, 7851.2430, 7731.2710, 7590.1310, 7424.0860, & + 7228.7440, 6998.9330, 6728.5740, 6410.5090, 6036.3220, & + 5596.1110, 5078.2250, 4468.9600, 3752.1910, 2908.9490, & + 2084.739, 1334.443, 708.499, 252.1360, 0.0, 0.0 / + + data b26 / 0.0, 0.0, 0.0000000, 0.0000000, 0.0000000, 0.0000000, 0.0000000,& + 0.0000000, 0.01505309, 0.03276228, 0.05359622, 0.07810627, & + 0.1069411, 0.1408637, 0.1807720, 0.2277220, 0.2829562, & + 0.3479364, 0.4243822, 0.5143168, 0.6201202, 0.7235355, & + 0.8176768, 0.8962153, 0.9534761, 0.9851122, 1.0000000 / + + +! High-resolution troposphere setup +! Revised Apr 14, 2004: PINT = 245.027 mb + data a32old/100.00000, 400.00000, 818.60211, & + 1378.88653, 2091.79519, 2983.64084, & + 4121.78960, 5579.22148, 7419.79300, & + 9704.82578, 12496.33710, 15855.26306, & + 19839.62499, 24502.73262, 28177.10152, & + 29525.28447, 29016.34358, 27131.32792, & + 24406.11225, 21326.04907, 18221.18357, & + 15275.14642, 12581.67796, 10181.42843, & + 8081.89816, 6270.86956, 4725.35001, & + 3417.39199, 2317.75459, 1398.09473, & + 632.49506, 0.00000, 0.00000 / + + data b32old/0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.01711, & + 0.06479, 0.13730, 0.22693, & + 0.32416, 0.42058, 0.51105, & + 0.59325, 0.66628, 0.73011, & + 0.78516, 0.83217, 0.87197, & + 0.90546, 0.93349, 0.95685, & + 0.97624, 0.99223, 1.00000 / + +! SJL June 26, 2012 +! pint= 55.7922 + data a32/100.00000, 400.00000, 818.60211, & + 1378.88653, 2091.79519, 2983.64084, & + 4121.78960, 5579.22148, 6907.19063, & + 7735.78639, 8197.66476, 8377.95525, & + 8331.69594, 8094.72213, 7690.85756, & + 7139.01788, 6464.80251, 5712.35727, & + 4940.05347, 4198.60465, 3516.63294, & + 2905.19863, 2366.73733, 1899.19455, & + 1497.78137, 1156.25252, 867.79199, & + 625.59324, 423.21322, 254.76613, & + 115.06646, 0.00000, 0.00000 / + + data b32/0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00513, & + 0.01969, 0.04299, 0.07477, & + 0.11508, 0.16408, 0.22198, & + 0.28865, 0.36281, 0.44112, & + 0.51882, 0.59185, 0.65810, & + 0.71694, 0.76843, 0.81293, & + 0.85100, 0.88331, 0.91055, & + 0.93338, 0.95244, 0.96828, & + 0.98142, 0.99223, 1.00000 / + +!--------------------- +! Wilson's 32L settings: +!--------------------- +! Top changed to 0.01 mb + data a32w/ 1.00, 26.6378, 84.5529, 228.8592, & + 539.9597, 1131.7087, 2141.8082, 3712.0454, & + 5963.5317, 8974.1873, 12764.5388, 17294.5911, & + 20857.7007, 22221.8651, 22892.7202, 22891.1641, & + 22286.0724, 21176.0846, 19673.0671, 17889.0989, & + 15927.5060, 13877.6239, 11812.5474, 9865.8830, & + 8073.9717, 6458.0824, 5027.9893, 3784.6104, & + 2722.0093, 1828.9741, 1090.2397, 487.4575, & + 0.0000 / + + data b32w/ 0.0000, 0.0000, 0.0000, 0.0000, & + 0.0000, 0.0000, 0.0000, 0.0000, & + 0.0000, 0.0000, 0.0000, 0.0000, & + 0.0159, 0.0586, 0.1117, 0.1734, & + 0.2415, 0.3137, 0.3878, 0.4619, & + 0.5344, 0.6039, 0.6696, 0.7285, & + 0.7808, 0.8266, 0.8662, 0.9000, & + 0.9285, 0.9522, 0.9716, 0.9874, & + 1.0000 / + +!miz + data a33/100.00000, 400.00000, 818.60211, & + 1378.88653, 2091.79519, 2983.64084, & + 4121.78960, 5579.22148, 6907.19063, & + 7735.78639, 8197.66476, 8377.95525, & + 8331.69594, 8094.72213, 7690.85756, & + 7139.01788, 6464.80251, 5712.35727, & + 4940.05347, 4198.60465, 3516.63294, & + 2905.19863, 2366.73733, 1899.19455, & + 1497.78137, 1156.25252, 867.79199, & + 625.59324, 426.21322, 264.76613, & + 145.06646, 60.00000, 15.00000, & + 0.00000 / + + data b33/0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00513, & + 0.01969, 0.04299, 0.07477, & + 0.11508, 0.16408, 0.22198, & + 0.28865, 0.36281, 0.44112, & + 0.51882, 0.59185, 0.65810, & + 0.71694, 0.76843, 0.81293, & + 0.85100, 0.88331, 0.91055, & + 0.93331, 0.95214, 0.96750, & + 0.97968, 0.98908, 0.99575, & + 1.00000 / +!miz +#ifdef OLD_L47 +! QBO setting with ptop = 0.1 mb and p_full=0.17 mb; pint ~ 100 mb + data a47/ 10.00000, 24.45365, 48.76776, & + 85.39458, 133.41983, 191.01402, & + 257.94919, 336.63306, 431.52741, & + 548.18995, 692.78825, 872.16512, & + 1094.18467, 1368.11917, 1704.99489, & + 2117.91945, 2622.42986, 3236.88281, & + 3982.89623, 4885.84733, 5975.43260, & + 7286.29500, 8858.72424, 10739.43477, & + 12982.41110, 15649.68745, 18811.37629, & + 22542.71275, 25724.93857, 27314.36781, & + 27498.59474, 26501.79312, 24605.92991, & + 22130.51655, 19381.30274, 16601.56419, & + 13952.53231, 11522.93244, 9350.82303, & + 7443.47723, 5790.77434, 4373.32696, & + 3167.47008, 2148.51663, 1293.15510, & + 581.62429, 0.00000, 0.00000 / + + data b47/ 0.0000, 0.0000, 0.0000, & + 0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00000, & + 0.00000, 0.01188, 0.04650, & + 0.10170, 0.17401, 0.25832, & + 0.34850, 0.43872, 0.52448, & + 0.60307, 0.67328, 0.73492, & + 0.78834, 0.83418, 0.87320, & + 0.90622, 0.93399, 0.95723, & + 0.97650, 0.99223, 1.00000 / +#else +! Oct 23, 2012 +! QBO setting with ptop = 0.1 mb, pint ~ 60 mb + data a47/ 10.00000, 24.45365, 48.76776, & + 85.39458, 133.41983, 191.01402, & + 257.94919, 336.63306, 431.52741, & + 548.18995, 692.78825, 872.16512, & + 1094.18467, 1368.11917, 1704.99489, & + 2117.91945, 2622.42986, 3236.88281, & + 3982.89623, 4885.84733, 5975.43260, & + 7019.26669, 7796.15848, 8346.60209, & + 8700.31838, 8878.27554, 8894.27179, & + 8756.46404, 8469.60171, 8038.92687, & + 7475.89006, 6803.68067, 6058.68992, & + 5285.28859, 4526.01565, 3813.00206, & + 3164.95553, 2589.26318, 2085.96929, & + 1651.11596, 1278.81205, 962.38875, & + 695.07046, 470.40784, 282.61654, & + 126.92745, 0.00000, 0.00000 / + data b47/ 0.0000, 0.0000, 0.0000, & + 0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00000, & + 0.00267, 0.01063, 0.02393, & + 0.04282, 0.06771, 0.09917, & + 0.13786, 0.18444, 0.23925, & + 0.30193, 0.37100, 0.44379, & + 0.51695, 0.58727, 0.65236, & + 0.71094, 0.76262, 0.80757, & + 0.84626, 0.87930, 0.90731, & + 0.93094, 0.95077, 0.96733, & + 0.98105, 0.99223, 1.00000 / +#endif + + data a48/ & + 1.00000, 2.69722, 5.17136, & + 8.89455, 14.24790, 22.07157, & + 33.61283, 50.48096, 74.79993, & + 109.40055, 158.00460, 225.44108, & + 317.89560, 443.19350, 611.11558, & + 833.74392, 1125.83405, 1505.20759, & + 1993.15829, 2614.86254, 3399.78420, & + 4382.06240, 5600.87014, 7100.73115, & + 8931.78242, 11149.97021, 13817.16841, & + 17001.20930, 20775.81856, 23967.33875, & + 25527.64563, 25671.22552, 24609.29622, & + 22640.51220, 20147.13482, 17477.63530, & + 14859.86462, 12414.92533, 10201.44191, & + 8241.50255, 6534.43202, 5066.17865, & + 3815.60705, 2758.60264, 1870.64631, & + 1128.33931, 510.47983, 0.00000, & + 0.00000 / + + data b48/ & + 0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.01253, & + 0.04887, 0.10724, 0.18455, & + 0.27461, 0.36914, 0.46103, & + 0.54623, 0.62305, 0.69099, & + 0.75016, 0.80110, 0.84453, & + 0.88127, 0.91217, 0.93803, & + 0.95958, 0.97747, 0.99223, & + 1.00000 / + +! KYC: HRRRv3 vertical coordinate + + data a50/ 2.00000000e+03, 2.46060000e+03, 2.95060000e+03, & + 3.47980000e+03, 4.04820000e+03, 4.65580000e+03, & + 5.30260000e+03, 6.00820000e+03, 6.76280000e+03, & + 7.56640000e+03, 8.43860000e+03, 9.62440000e+03, & + 1.10062000e+04, 1.23880000e+04, 1.37698000e+04, & + 1.51516000e+04, 1.65334000e+04, 1.79152000e+04, & + 1.92970000e+04, 2.06788000e+04, 2.20530309e+04, & + 2.33224623e+04, 2.44604680e+04, 2.56437194e+04, & + 2.66933976e+04, 2.76478977e+04, 2.84633440e+04, & + 2.90796820e+04, 2.94284494e+04, 2.94337456e+04, & + 2.90084684e+04, 2.80761591e+04, 2.65243296e+04, & + 2.42850206e+04, 2.13118800e+04, 1.81350000e+04, & + 1.50098730e+04, 1.20805273e+04, 9.44285062e+03, & + 7.15256437e+03, 5.23262695e+03, 3.68006836e+03, & + 2.47225500e+03, 1.57258500e+03, 8.82770078e+02, & + 4.33565391e+02, 1.83056641e+02, 6.24538281e+01, & + 1.98243750e+01, 4.87312500e+00, 0.00000000e+00 / + + data b50/ 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, & + 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, & + 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, & + 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, & + 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, & + 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, & + 0.00000000e+00, 0.00000000e+00, 7.56910398e-05, & + 1.19937655e-03, 3.63732042e-03, 8.17080640e-03, & + 1.47260242e-02, 2.40950227e-02, 3.70105596e-02, & + 5.42691797e-02, 7.67515062e-02, 1.05608544e-01, & + 1.42005316e-01, 1.86608409e-01, 2.41816704e-01, & + 3.08309794e-01, 3.87041200e-01, 4.65850000e-01, & + 5.41201270e-01, 6.11654727e-01, 6.76251494e-01, & + 7.34434356e-01, 7.85973730e-01, 8.30899316e-01, & + 8.69437450e-01, 9.01954150e-01, 9.31392299e-01, & + 9.55484346e-01, 9.73669434e-01, 9.86635462e-01, & + 9.93921756e-01, 9.97991269e-01, 1.00000000e+00 / + +! High PBL resolution with top at 1 mb +! SJL modified May 7, 2013 to ptop ~ 100 mb + data a54/100.00000, 254.83931, 729.54278, & + 1602.41121, 2797.50667, 4100.18977, & + 5334.87140, 6455.24153, 7511.80944, & + 8580.26355, 9714.44293, 10938.62253, & + 12080.36051, 12987.13921, 13692.75084, & + 14224.92180, 14606.55444, 14856.69953, & + 14991.32121, 15023.90075, 14965.91493, & + 14827.21612, 14616.33505, 14340.72252, & + 14006.94280, 13620.82849, 13187.60470, & + 12711.98873, 12198.27003, 11650.37451, & + 11071.91608, 10466.23819, 9836.44706, & + 9185.43852, 8515.96231, 7831.01080, & + 7135.14301, 6436.71659, 5749.00215, & + 5087.67188, 4465.67510, 3889.86419, & + 3361.63433, 2879.51065, 2441.02496, & + 2043.41345, 1683.80513, 1359.31122, & + 1067.09135, 804.40101, 568.62625, & + 357.32525, 168.33263, 0.00000, & + 0.00000 / + + data b54/0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00000, & + 0.00180, 0.00694, 0.01510, & + 0.02601, 0.03942, 0.05515, & + 0.07302, 0.09288, 0.11459, & + 0.13803, 0.16307, 0.18960, & + 0.21753, 0.24675, 0.27716, & + 0.30866, 0.34115, 0.37456, & + 0.40879, 0.44375, 0.47935, & + 0.51551, 0.55215, 0.58916, & + 0.62636, 0.66334, 0.69946, & + 0.73395, 0.76622, 0.79594, & + 0.82309, 0.84780, 0.87020, & + 0.89047, 0.90876, 0.92524, & + 0.94006, 0.95336, 0.96529, & + 0.97596, 0.98551, 0.99400, & + 1.00000 / + + +! The 56-L setup + data a56/ 10.00000, 24.97818, 58.01160, & + 115.21466, 199.29210, 309.39897, & + 445.31785, 610.54747, 812.28518, & + 1059.80882, 1363.07092, 1732.09335, & + 2176.91502, 2707.68972, 3334.70962, & + 4068.31964, 4918.76594, 5896.01890, & + 7009.59166, 8268.36324, 9680.41211, & + 11252.86491, 12991.76409, 14901.95764, & + 16987.01313, 19249.15733, 21689.24182, & + 23845.11055, 25330.63353, 26243.52467, & + 26663.84998, 26657.94696, 26281.61371, & + 25583.05256, 24606.03265, 23393.39510, & + 21990.28845, 20445.82122, 18811.93894, & + 17139.59660, 15473.90350, 13850.50167, & + 12294.49060, 10821.62655, 9440.57746, & + 8155.11214, 6965.72496, 5870.70511, & + 4866.83822, 3949.90019, 3115.03562, & + 2357.07879, 1670.87329, 1051.65120, & + 495.51399, 0.00000, 0.00000 / + + data b56 /0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00000, & + 0.00462, 0.01769, 0.03821, & + 0.06534, 0.09834, 0.13659, & + 0.17947, 0.22637, 0.27660, & + 0.32929, 0.38343, 0.43791, & + 0.49162, 0.54361, 0.59319, & + 0.63989, 0.68348, 0.72391, & + 0.76121, 0.79545, 0.82679, & + 0.85537, 0.88135, 0.90493, & + 0.92626, 0.94552, 0.96286, & + 0.97840, 0.99223, 1.00000 / + + data a60gfs/300.0000, 430.00000, 558.00000, & + 700.00000, 863.05803, 1051.07995, & + 1265.75194, 1510.71101, 1790.05098, & + 2108.36604, 2470.78817, 2883.03811, & + 3351.46002, 3883.05187, 4485.49315, & + 5167.14603, 5937.04991, 6804.87379, & + 7780.84698, 8875.64338, 10100.20534, & + 11264.35673, 12190.64366, 12905.42546, & + 13430.87867, 13785.88765, 13986.77987, & + 14047.96335, 13982.46770, 13802.40331, & + 13519.33841, 13144.59486, 12689.45608, & + 12165.28766, 11583.57006, 10955.84778, & + 10293.60402, 9608.08306, 8910.07678, & + 8209.70131, 7516.18560, 6837.69250, & + 6181.19473, 5552.39653, 4955.72632, & + 4394.37629, 3870.38682, 3384.76586, & + 2937.63489, 2528.37666, 2155.78385, & + 1818.20722, 1513.68173, 1240.03585, & + 994.99144, 776.23591, 581.48797, & + 408.53400, 255.26520, 119.70243, 0. / + + data b60gfs/0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00000, & + 0.00201, 0.00792, 0.01755, & + 0.03079, 0.04751, 0.06761, & + 0.09097, 0.11746, 0.14690, & + 0.17911, 0.21382, 0.25076, & + 0.28960, 0.32994, 0.37140, & + 0.41353, 0.45589, 0.49806, & + 0.53961, 0.58015, 0.61935, & + 0.65692, 0.69261, 0.72625, & + 0.75773, 0.78698, 0.81398, & + 0.83876, 0.86138, 0.88192, & + 0.90050, 0.91722, 0.93223, & + 0.94565, 0.95762, 0.96827, & + 0.97771, 0.98608, 0.99347, 1./ + + data a60/ 1.7861000000e-01, 1.0805100000e+00, 3.9647100000e+00, & + 9.7516000000e+00, 1.9816580000e+01, 3.6695950000e+01, & + 6.2550570000e+01, 9.9199620000e+01, 1.4792505000e+02, & + 2.0947487000e+02, 2.8422571000e+02, 3.7241721000e+02, & + 4.7437835000e+02, 5.9070236000e+02, 7.2236063000e+02, & + 8.7076746000e+02, 1.0378138800e+03, 1.2258877300e+03, & + 1.4378924600e+03, 1.6772726600e+03, 1.9480506400e+03, & + 2.2548762700e+03, 2.6030909400e+03, 2.9988059200e+03, & + 3.4489952300e+03, 3.9616028900e+03, 4.5456641600e+03, & + 5.2114401700e+03, 5.9705644000e+03, 6.8361981800e+03, & + 7.8231906000e+03, 8.9482351000e+03, 1.0230010660e+04, & + 1.1689289750e+04, 1.3348986860e+04, 1.5234111060e+04, & + 1.7371573230e+04, 1.9789784580e+04, 2.2005564550e+04, & + 2.3550115120e+04, 2.4468583320e+04, 2.4800548800e+04, & + 2.4582445070e+04, 2.3849999620e+04, 2.2640519740e+04, & + 2.0994737150e+04, 1.8957848730e+04, 1.6579413230e+04, & + 1.4080071030e+04, 1.1753630920e+04, 9.6516996300e+03, & + 7.7938009300e+03, 6.1769062800e+03, 4.7874276000e+03, & + 3.6050497500e+03, 2.6059860700e+03, 1.7668328200e+03, & + 1.0656131200e+03, 4.8226201000e+02, 0.0000000000e+00, & + 0.0000000000e+00 / + + + data b60/ 0.0000000000e+00, 0.0000000000e+00, 0.0000000000e+00, & + 0.0000000000e+00, 0.0000000000e+00, 0.0000000000e+00, & + 0.0000000000e+00, 0.0000000000e+00, 0.0000000000e+00, & + 0.0000000000e+00, 0.0000000000e+00, 0.0000000000e+00, & + 0.0000000000e+00, 0.0000000000e+00, 0.0000000000e+00, & + 0.0000000000e+00, 0.0000000000e+00, 0.0000000000e+00, & + 0.0000000000e+00, 0.0000000000e+00, 0.0000000000e+00, & + 0.0000000000e+00, 0.0000000000e+00, 0.0000000000e+00, & + 0.0000000000e+00, 0.0000000000e+00, 0.0000000000e+00, & + 0.0000000000e+00, 0.0000000000e+00, 0.0000000000e+00, & + 0.0000000000e+00, 0.0000000000e+00, 0.0000000000e+00, & + 0.0000000000e+00, 0.0000000000e+00, 0.0000000000e+00, & + 0.0000000000e+00, 0.0000000000e+00, 5.0600000000e-03, & + 2.0080000000e-02, 4.4900000000e-02, 7.9360000000e-02, & + 1.2326000000e-01, 1.7634000000e-01, 2.3820000000e-01, & + 3.0827000000e-01, 3.8581000000e-01, 4.6989000000e-01, & + 5.5393000000e-01, 6.2958000000e-01, 6.9642000000e-01, & + 7.5458000000e-01, 8.0463000000e-01, 8.4728000000e-01, & + 8.8335000000e-01, 9.1368000000e-01, 9.3905000000e-01, & + 9.6020000000e-01, 9.7775000000e-01, 9.9223000000e-01, & + 1.0000000000e+00 / + +! This is activated by USE_GFSL63 +! The following L63 setting is the same as NCEP GFS's L64 except the top +! 3 layers + data a63/64.247, 137.790, 221.958, & + 318.266, 428.434, 554.424, & + 698.457, 863.05803, 1051.07995, & + 1265.75194, 1510.71101, 1790.05098, & + 2108.36604, 2470.78817, 2883.03811, & + 3351.46002, 3883.05187, 4485.49315, & + 5167.14603, 5937.04991, 6804.87379, & + 7780.84698, 8875.64338, 10100.20534, & + 11264.35673, 12190.64366, 12905.42546, & + 13430.87867, 13785.88765, 13986.77987, & + 14047.96335, 13982.46770, 13802.40331, & + 13519.33841, 13144.59486, 12689.45608, & + 12165.28766, 11583.57006, 10955.84778, & + 10293.60402, 9608.08306, 8910.07678, & + 8209.70131, 7516.18560, 6837.69250, & + 6181.19473, 5552.39653, 4955.72632, & + 4394.37629, 3870.38682, 3384.76586, & + 2937.63489, 2528.37666, 2155.78385, & + 1818.20722, 1513.68173, 1240.03585, & + 994.99144, 776.23591, 581.48797, & + 408.53400, 255.26520, 119.70243, 0. / + + data b63/0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00000, & + 0.00201, 0.00792, 0.01755, & + 0.03079, 0.04751, 0.06761, & + 0.09097, 0.11746, 0.14690, & + 0.17911, 0.21382, 0.25076, & + 0.28960, 0.32994, 0.37140, & + 0.41353, 0.45589, 0.49806, & + 0.53961, 0.58015, 0.61935, & + 0.65692, 0.69261, 0.72625, & + 0.75773, 0.78698, 0.81398, & + 0.83876, 0.86138, 0.88192, & + 0.90050, 0.91722, 0.93223, & + 0.94565, 0.95762, 0.96827, & + 0.97771, 0.98608, 0.99347, 1./ + + data a63meso/ 64.247, 234.14925, 444.32075, & + 719.10698, 1077.83197, 1545.21700, & + 2152.6203, 2939.37353, 3954.07197, & + 5255.55443, 6913.13424, 8955.12932, & + 10898.75012, 12137.76737, 12858.09331, & + 13388.26761, 13747.35846, 13951.85268, & + 14016.29356, 13953.82551, 13776.65318, & + 13496.41874, 13124.49605, 12672.19867, & + 12150.90036, 11572.06889, 10947.21741, & + 10287.78472, 9604.96173, 8909.48448, & + 8211.41625, 7519.94125, 6843.19133, & + 6188.11962, 5560.42852, 4964.55636, & + 4403.71643, 3879.97894, 3394.38835, & + 2996.77033, 2730.02573, 2530.11329, & + 2339.36720, 2157.57530, 1984.53745, & + 1820.00086, 1663.72705, 1515.43668, & + 1374.86622, 1241.72259, 1115.72934, & + 996.58895, 884.02079, 777.73138, & + 677.44387, 582.87349, 493.75161, & + 409.80694, 330.78356, 256.42688, & + 186.49670, 120.75560, 58.97959, 0. / + + data b63meso/ 0. , 0. , 0. , & + 0. , 0. , 0. , & + 0. , 0. , 0. , & + 0. , 0. , 0.0005 , & + 0.00298, 0.00885, 0.01845, & + 0.03166, 0.04836, 0.06842, & + 0.09175, 0.1182 , 0.14759, & + 0.17974, 0.21438, 0.25123, & + 0.28997, 0.33022, 0.37157, & + 0.41359, 0.45584, 0.49791, & + 0.53936, 0.57981, 0.61894, & + 0.65645, 0.6921 , 0.72571, & + 0.75717, 0.78642, 0.81343, & + 0.83547, 0.85023, 0.86128, & + 0.8718 , 0.88182, 0.89135, & + 0.9004 , 0.90898, 0.91712, & + 0.92483, 0.93213, 0.93904, & + 0.94556, 0.95172, 0.95754, & + 0.96302, 0.96819, 0.97306, & + 0.97764, 0.98196, 0.98601, & + 0.98983, 0.99341, 0.99678, 1. / + + data a64gfs/20.00000, 68.00000, 137.79000, & + 221.95800, 318.26600, 428.43400, & + 554.42400, 698.45700, 863.05803, & + 1051.07995, 1265.75194, 1510.71101, & + 1790.05098, 2108.36604, 2470.78817, & + 2883.03811, 3351.46002, 3883.05187, & + 4485.49315, 5167.14603, 5937.04991, & + 6804.87379, 7780.84698, 8875.64338, & + 9921.40745, 10760.99844, 11417.88354, & + 11911.61193, 12258.61668, 12472.89642, & + 12566.58298, 12550.43517, 12434.26075, & + 12227.27484, 11938.39468, 11576.46910, & + 11150.43640, 10669.41063, 10142.69482, & + 9579.72458, 8989.94947, 8382.67090, & + 7766.85063, 7150.91171, 6542.55077, & + 5948.57894, 5374.81094, 4825.99383, & + 4305.79754, 3816.84622, 3360.78848, & + 2938.39801, 2549.69756, 2194.08449, & + 1870.45732, 1577.34218, 1313.00028, & + 1075.52114, 862.90778, 673.13815, & + 504.22118, 354.22752, 221.32110, & + 103.78014, 0./ + data b64gfs/0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00000, & + 0.00179, 0.00705, 0.01564, & + 0.02749, 0.04251, 0.06064, & + 0.08182, 0.10595, 0.13294, & + 0.16266, 0.19492, 0.22950, & + 0.26615, 0.30455, 0.34435, & + 0.38516, 0.42656, 0.46815, & + 0.50949, 0.55020, 0.58989, & + 0.62825, 0.66498, 0.69987, & + 0.73275, 0.76351, 0.79208, & + 0.81845, 0.84264, 0.86472, & + 0.88478, 0.90290, 0.91923, & + 0.93388, 0.94697, 0.95865, & + 0.96904, 0.97826, 0.98642, & + 0.99363, 1./ + + data a64/1.00000, 3.90000, 8.70000, & + 15.42000, 24.00000, 34.50000, & + 47.00000, 61.50000, 78.60000, & + 99.13500, 124.12789, 154.63770, & + 191.69700, 236.49300, 290.38000, & + 354.91000, 431.82303, 523.09300, & + 630.92800, 757.79000, 906.45000, & + 1079.85000, 1281.00000, 1515.00000, & + 1788.00000, 2105.00000, 2470.00000, & + 2889.00000, 3362.00000, 3890.00000, & + 4475.00000, 5120.00000, 5830.00000, & + 6608.00000, 7461.00000, 8395.00000, & + 9424.46289, 10574.46880, 11864.80270, & + 13312.58890, 14937.03710, 16759.70700, & + 18804.78710, 21099.41210, 23674.03710, & + 26562.82810, 29804.11720, 32627.31640, & + 34245.89840, 34722.28910, 34155.19920, & + 32636.50390, 30241.08200, 27101.44920, & + 23362.20700, 19317.05270, 15446.17090, & + 12197.45210, 9496.39941, 7205.66992, & + 5144.64307, 3240.79346, 1518.62134, & + 0.00000, 0.00000 / + + data b64/0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00813, & + 0.03224, 0.07128, 0.12445, & + 0.19063, 0.26929, 0.35799, & + 0.45438, 0.55263, 0.64304, & + 0.71703, 0.77754, 0.82827, & + 0.87352, 0.91502, 0.95235, & + 0.98511, 1.00000 / + + data a65/1.00000000, 5.13470268, 14.04240036, & + 30.72783852, 53.79505539, 82.45489502, & + 117.05598450, 158.62843323, 208.79000854, & + 270.02725220, 345.50848389, 438.41940308, & + 551.85266113, 689.25054932, 854.40936279, & + 1051.47802734, 1284.95031738, 1559.65148926, & + 1880.71691895, 2253.56542969, 2683.86547852, & + 3177.49560547, 3740.49951172, 4379.03613281, & + 5099.32617188, 5907.59326172, 6810.00781250, & + 7812.62353516, 8921.31933594, 10141.73632812,& + 11285.93066406, 12188.79101562, 12884.30078125,& + 13400.11523438, 13758.84960938, 13979.10351562,& + 14076.26074219, 14063.13085938, 13950.45507812,& + 13747.31445312, 13461.45410156, 13099.54199219,& + 12667.38183594, 12170.08203125, 11612.18847656,& + 10997.79980469, 10330.65039062, 9611.05468750, & + 8843.30371094, 8045.85009766, 7236.31152344, & + 6424.55712891, 5606.50927734, 4778.05908203, & + 3944.97241211, 3146.77514648, 2416.63354492, & + 1778.22607422, 1246.21462402, 826.51950684, & + 511.21385254, 290.74072876, 150.00000000, & + 68.89300000, 14.99899865, 0.00000000 / + + data b65/0.00000000, 0.00000000, 0.00000000, & + 0.00000000, 0.00000000, 0.00000000, & + 0.00000000, 0.00000000, 0.00000000, & + 0.00000000, 0.00000000, 0.00000000, & + 0.00000000, 0.00000000, 0.00000000, & + 0.00000000, 0.00000000, 0.00000000, & + 0.00000000, 0.00000000, 0.00000000, & + 0.00000000, 0.00000000, 0.00000000, & + 0.00000000, 0.00000000, 0.00000000, & + 0.00000000, 0.00000000, 0.00000000, & + 0.00193294, 0.00749994, 0.01640714, & + 0.02841953, 0.04334756, 0.06103661, & + 0.08135860, 0.10420541, 0.12948355, & + 0.15711005, 0.18700911, 0.21910952, & + 0.25334257, 0.28964061, 0.32793567, & + 0.36815873, 0.41023913, 0.45429301, & + 0.50016892, 0.54688859, 0.59356427, & + 0.63976413, 0.68518244, 0.72950502, & + 0.77231618, 0.81251526, 0.84921405, & + 0.88174411, 0.90978803, 0.93327247, & + 0.95249488, 0.96783525, 0.97980107, & + 0.98896214, 0.99575002, 1.00000000 / +!-->cjg + data a68/1.00000, 2.68881, 5.15524, & + 8.86683, 14.20349, 22.00278, & + 33.50807, 50.32362, 74.56680, & + 109.05958, 157.51214, 224.73844, & + 316.90481, 441.81219, 609.21090, & + 831.14537, 1122.32514, 1500.51628, & + 1986.94617, 2606.71274, 3389.18802, & + 4368.40473, 5583.41379, 7078.60015, & + 8903.94455, 11115.21886, 13774.60566, & + 16936.82070, 20340.47045, 23193.71492, & + 24870.36141, 25444.59363, 25252.57081, & + 24544.26211, 23474.29096, 22230.65331, & + 20918.50731, 19589.96280, 18296.26682, & + 17038.02866, 15866.85655, 14763.18943, & + 13736.83624, 12794.11850, 11930.72442, & + 11137.17217, 10404.78946, 9720.03954, & + 9075.54055, 8466.72650, 7887.12346, & + 7333.90490, 6805.43028, 6297.33773, & + 5805.78227, 5327.94995, 4859.88765, & + 4398.63854, 3942.81761, 3491.08449, & + 3043.04531, 2598.71608, 2157.94527, & + 1720.87444, 1287.52805, 858.02944, & + 432.71276, 8.10905, 0.00000 / + + data b68/0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00000, & + 0.00000, 0.00283, 0.01590, & + 0.04412, 0.08487, 0.13284, & + 0.18470, 0.23828, 0.29120, & + 0.34211, 0.39029, 0.43518, & + 0.47677, 0.51536, 0.55091, & + 0.58331, 0.61263, 0.63917, & + 0.66333, 0.68552, 0.70617, & + 0.72555, 0.74383, 0.76117, & + 0.77765, 0.79335, 0.80838, & + 0.82287, 0.83693, 0.85069, & + 0.86423, 0.87760, 0.89082, & + 0.90392, 0.91689, 0.92973, & + 0.94244, 0.95502, 0.96747, & + 0.97979, 0.99200, 1.00000 / + + data a96/1.00000, 2.35408, 4.51347, & + 7.76300, 12.43530, 19.26365, & + 29.33665, 44.05883, 65.28397, & + 95.48274, 137.90344, 196.76073, & + 277.45330, 386.81095, 533.37018, & + 727.67600, 982.60677, 1313.71685, & + 1739.59104, 2282.20281, 2967.26766, & + 3824.58158, 4888.33404, 6197.38450, & + 7795.49158, 9731.48414, 11969.71024, & + 14502.88894, 17304.52434, 20134.76139, & + 22536.63814, 24252.54459, 25230.65591, & + 25585.72044, 25539.91412, 25178.87141, & + 24644.84493, 23978.98781, 23245.49366, & + 22492.11600, 21709.93990, 20949.64473, & + 20225.94258, 19513.31158, 18829.32485, & + 18192.62250, 17589.39396, 17003.45386, & + 16439.01774, 15903.91204, 15396.39758, & + 14908.02140, 14430.65897, 13967.88643, & + 13524.16667, 13098.30227, 12687.56457, & + 12287.08757, 11894.41553, 11511.54106, & + 11139.22483, 10776.01912, 10419.75711, & + 10067.11881, 9716.63489, 9369.61967, & + 9026.69066, 8687.29884, 8350.04978, & + 8013.20925, 7677.12187, 7343.12994, & + 7011.62844, 6681.98102, 6353.09764, & + 6025.10535, 5699.10089, 5375.54503, & + 5053.63074, 4732.62740, 4413.38037, & + 4096.62775, 3781.79777, 3468.45371, & + 3157.19882, 2848.25306, 2541.19150, & + 2236.21942, 1933.50628, 1632.83741, & + 1334.35954, 1038.16655, 744.22318, & + 452.71094, 194.91899, 0.00000, & + 0.00000 / + + data b96/0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00193, & + 0.00974, 0.02538, 0.04876, & + 0.07817, 0.11081, 0.14514, & + 0.18007, 0.21486, 0.24866, & + 0.28088, 0.31158, 0.34030, & + 0.36701, 0.39210, 0.41554, & + 0.43733, 0.45774, 0.47707, & + 0.49540, 0.51275, 0.52922, & + 0.54495, 0.56007, 0.57459, & + 0.58850, 0.60186, 0.61471, & + 0.62715, 0.63922, 0.65095, & + 0.66235, 0.67348, 0.68438, & + 0.69510, 0.70570, 0.71616, & + 0.72651, 0.73675, 0.74691, & + 0.75700, 0.76704, 0.77701, & + 0.78690, 0.79672, 0.80649, & + 0.81620, 0.82585, 0.83542, & + 0.84492, 0.85437, 0.86375, & + 0.87305, 0.88229, 0.89146, & + 0.90056, 0.90958, 0.91854, & + 0.92742, 0.93623, 0.94497, & + 0.95364, 0.96223, 0.97074, & + 0.97918, 0.98723, 0.99460, & + 1.00000 / +!<--cjg + +!---> kgao: remove top layers from l96 + data a88/65.28397, & + 95.48274, 137.90344, 196.76073, & + 277.45330, 386.81095, 533.37018, & + 727.67600, 982.60677, 1313.71685, & + 1739.59104, 2282.20281, 2967.26766, & + 3824.58158, 4888.33404, 6197.38450, & + 7795.49158, 9731.48414, 11969.71024, & + 14502.88894, 17304.52434, 20134.76139, & + 22536.63814, 24252.54459, 25230.65591, & + 25585.72044, 25539.91412, 25178.87141, & + 24644.84493, 23978.98781, 23245.49366, & + 22492.11600, 21709.93990, 20949.64473, & + 20225.94258, 19513.31158, 18829.32485, & + 18192.62250, 17589.39396, 17003.45386, & + 16439.01774, 15903.91204, 15396.39758, & + 14908.02140, 14430.65897, 13967.88643, & + 13524.16667, 13098.30227, 12687.56457, & + 12287.08757, 11894.41553, 11511.54106, & + 11139.22483, 10776.01912, 10419.75711, & + 10067.11881, 9716.63489, 9369.61967, & + 9026.69066, 8687.29884, 8350.04978, & + 8013.20925, 7677.12187, 7343.12994, & + 7011.62844, 6681.98102, 6353.09764, & + 6025.10535, 5699.10089, 5375.54503, & + 5053.63074, 4732.62740, 4413.38037, & + 4096.62775, 3781.79777, 3468.45371, & + 3157.19882, 2848.25306, 2541.19150, & + 2236.21942, 1933.50628, 1632.83741, & + 1334.35954, 1038.16655, 744.22318, & + 452.71094, 194.91899, 0.00000, & + 0.00000 / + + data b88/0.00000, & + 0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00193, & + 0.00974, 0.02538, 0.04876, & + 0.07817, 0.11081, 0.14514, & + 0.18007, 0.21486, 0.24866, & + 0.28088, 0.31158, 0.34030, & + 0.36701, 0.39210, 0.41554, & + 0.43733, 0.45774, 0.47707, & + 0.49540, 0.51275, 0.52922, & + 0.54495, 0.56007, 0.57459, & + 0.58850, 0.60186, 0.61471, & + 0.62715, 0.63922, 0.65095, & + 0.66235, 0.67348, 0.68438, & + 0.69510, 0.70570, 0.71616, & + 0.72651, 0.73675, 0.74691, & + 0.75700, 0.76704, 0.77701, & + 0.78690, 0.79672, 0.80649, & + 0.81620, 0.82585, 0.83542, & + 0.84492, 0.85437, 0.86375, & + 0.87305, 0.88229, 0.89146, & + 0.90056, 0.90958, 0.91854, & + 0.92742, 0.93623, 0.94497, & + 0.95364, 0.96223, 0.97074, & + 0.97918, 0.98723, 0.99460, & + 1.00000 / +!<--- kgao: end of a88/b88 + +!---> kgao: EMC L75 config + + data a75/200.0, 572.419, 1104.437, & + 1760.239, 2499.052, 3300.438, & + 4161.36, 5090.598, 6114.272, & + 7241.963, 8489.481, 9855.825, & + 11338.34, 12682.56, 13688.97, & + 14422.61, 14934.2, 15263.88, & + 15443.77, 15499.9, 15453.61, & + 15322.6, 15121.64, 14863.23, & + 14557.97, 14214.93, 13841.91, & + 13445.62, 13031.86, 12605.65, & + 12171.31, 11732.57, 11292.65, & + 10854.29, 10419.82, 9991.243, & + 9570.207, 9158.088, 8756.019, & + 8364.893, 7985.424, 7618.15, & + 7263.452, 6921.581, 6592.674, & + 6276.763, 5963.31, 5652.806, & + 5345.765, 5042.658, 4743.966, & + 4450.172, 4161.769, 3879.194, & + 3602.911, 3333.365, 3071.016, & + 2816.274, 2569.556, 2331.264, & + 2101.816, 1881.57, 1670.887, & + 1470.119, 1279.627, 1099.702, & + 930.651, 772.757, 626.305, & + 491.525, 368.641, 257.862, & + 159.399, 73.396, 0.001, & + 0.0/ + data b75/0.0, 0.0, 0.0, & + 0.0, 0.0, 0.0, & + 0.0, 0.0, 0.0, & + 0.0, 0.0, 0.0, & + 0.0, 0.00250213, 0.00944449,& + 0.02010732, 0.03390246, 0.0503391, & + 0.06899972, 0.08952269, 0.1115907, & + 0.134922, 0.1592647, 0.1843923, & + 0.2101002, 0.2362043, 0.2625384, & + 0.2889538, 0.3153166, 0.3415084, & + 0.3674242, 0.3929729, 0.4180741, & + 0.4426602, 0.4666739, 0.4900666, & + 0.5127994, 0.5348418, 0.5561699, & + 0.5767674, 0.5966232, 0.6157322, & + 0.6340936, 0.6517111, 0.668592, & + 0.6847468, 0.7007225, 0.7164985, & + 0.7320531, 0.7473667, 0.7624187, & + 0.7771889, 0.7916558, 0.8058007, & + 0.819604, 0.8330461, 0.8461072, & + 0.8587694, 0.8710147, 0.8828254, & + 0.8941834, 0.9050727, 0.9154776, & + 0.9253828, 0.9347721, 0.9436326, & + 0.9519511, 0.9597148, 0.966911, & + 0.9735298, 0.9795609, 0.9849954, & + 0.9898235, 0.9940391, 0.9976355, & + 1.0/ +! <--- kgao: end of a75/b75 + +! +! Ultra high troposphere resolution + data a100/100.00000, 300.00000, 800.00000, & + 1762.35235, 3106.43596, 4225.71874, & + 4946.40525, 5388.77387, 5708.35540, & + 5993.33124, 6277.73673, 6571.49996, & + 6877.05339, 7195.14327, 7526.24920, & + 7870.82981, 8229.35361, 8602.30193, & + 8990.16936, 9393.46399, 9812.70768, & + 10248.43625, 10701.19980, 11171.56286, & + 11660.10476, 12167.41975, 12694.11735, & + 13240.82253, 13808.17600, 14396.83442, & + 15007.47066, 15640.77407, 16297.45067, & + 16978.22343, 17683.83253, 18415.03554, & + 19172.60771, 19957.34218, 20770.05022, & + 21559.14829, 22274.03147, 22916.87519, & + 23489.70456, 23994.40187, 24432.71365, & + 24806.25734, 25116.52754, 25364.90190, & + 25552.64670, 25680.92203, 25750.78675, & + 25763.20311, 25719.04113, 25619.08274, & + 25464.02630, 25254.49482, 24991.06137, & + 24674.32737, 24305.11235, 23884.79781, & + 23415.77059, 22901.76510, 22347.84738, & + 21759.93950, 21144.07284, 20505.73136, & + 19849.54271, 19179.31412, 18498.23400, & + 17809.06809, 17114.28232, 16416.10343, & + 15716.54833, 15017.44246, 14320.43478, & + 13627.01116, 12938.50682, 12256.11762, & + 11580.91062, 10913.83385, 10255.72526, & + 9607.32122, 8969.26427, 8342.11044, & + 7726.33606, 7122.34405, 6530.46991, & + 5950.98721, 5384.11279, 4830.01153, & + 4288.80090, 3760.55514, 3245.30920, & + 2743.06250, 2253.78294, 1777.41285, & + 1313.88054, 863.12371, 425.13088, & + 0.00000, 0.00000 / + + + data b100/0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00000, & + 0.00052, 0.00209, 0.00468, & + 0.00828, 0.01288, 0.01849, & + 0.02508, 0.03266, 0.04121, & + 0.05075, 0.06126, 0.07275, & + 0.08521, 0.09866, 0.11308, & + 0.12850, 0.14490, 0.16230, & + 0.18070, 0.20009, 0.22042, & + 0.24164, 0.26362, 0.28622, & + 0.30926, 0.33258, 0.35605, & + 0.37958, 0.40308, 0.42651, & + 0.44981, 0.47296, 0.49591, & + 0.51862, 0.54109, 0.56327, & + 0.58514, 0.60668, 0.62789, & + 0.64872, 0.66919, 0.68927, & + 0.70895, 0.72822, 0.74709, & + 0.76554, 0.78357, 0.80117, & + 0.81835, 0.83511, 0.85145, & + 0.86736, 0.88286, 0.89794, & + 0.91261, 0.92687, 0.94073, & + 0.95419, 0.96726, 0.97994, & + 0.99223, 1.00000 / + + data a104/ & + 1.8827062944e-01, 7.7977549145e-01, 2.1950593583e+00, & + 4.9874566624e+00, 9.8041418997e+00, 1.7019717163e+01, & + 2.7216579591e+01, 4.0518628401e+01, 5.6749646818e+01, & + 7.5513868331e+01, 9.6315093333e+01, 1.1866706195e+02, & + 1.4216835396e+02, 1.6653733709e+02, 1.9161605772e+02, & + 2.1735580129e+02, 2.4379516604e+02, 2.7103771847e+02, & + 2.9923284173e+02, 3.2856100952e+02, 3.5922338766e+02, & + 3.9143507908e+02, 4.2542117983e+02, 4.6141487902e+02, & + 4.9965698106e+02, 5.4039638379e+02, 5.8389118154e+02, & + 6.3041016829e+02, 6.8023459505e+02, 7.3366009144e+02, & + 7.9099869949e+02, 8.5258099392e+02, 9.1875827946e+02, & + 9.8990486716e+02, 1.0664204381e+03, 1.1487325074e+03, & + 1.2372990044e+03, 1.3326109855e+03, 1.4351954993e+03, & + 1.5456186222e+03, 1.6644886848e+03, 1.7924597105e+03, & + 1.9302350870e+03, 2.0785714934e+03, 2.2382831070e+03, & + 2.4102461133e+03, 2.5954035462e+03, 2.7947704856e+03, & + 3.0094396408e+03, 3.2405873512e+03, 3.4894800360e+03, & + 3.7574811281e+03, 4.0460585279e+03, 4.3567926151e+03, & + 4.6913848588e+03, 5.0516670674e+03, 5.4396113207e+03, & + 5.8573406270e+03, 6.3071403487e+03, 6.7914704368e+03, & + 7.3129785102e+03, 7.8745138115e+03, 8.4791420557e+03, & + 9.1301611750e+03, 9.8311179338e+03, 1.0585825354e+04, & + 1.1398380836e+04, 1.2273184781e+04, 1.3214959424e+04, & + 1.4228767429e+04, 1.5320029596e+04, 1.6494540743e+04, & + 1.7758482452e+04, 1.9118430825e+04, 2.0422798801e+04, & + 2.1520147587e+04, 2.2416813461e+04, 2.3118184510e+04, & + 2.3628790785e+04, 2.3952411814e+04, 2.4092209011e+04, & + 2.4050892106e+04, 2.3830930156e+04, 2.3434818358e+04, & + 2.2865410898e+04, 2.2126326004e+04, 2.1222420323e+04, & + 2.0160313690e+04, 1.8948920926e+04, 1.7599915822e+04, & + 1.6128019809e+04, 1.4550987232e+04, 1.2889169132e+04, & + 1.1164595563e+04, 9.4227665517e+03, 7.7259097899e+03, & + 6.1538244381e+03, 4.7808126007e+03, 3.5967415552e+03, & + 2.5886394104e+03, 1.7415964865e+03, 1.0393721271e+03, & + 4.6478852032e+02, 7.0308342481e-13, 0.0000000000e+00 / + + + data b104/ & + 0.0000000000e+00, 0.0000000000e+00, 0.0000000000e+00, & + 0.0000000000e+00, 0.0000000000e+00, 0.0000000000e+00, & + 0.0000000000e+00, 0.0000000000e+00, 0.0000000000e+00, & + 0.0000000000e+00, 0.0000000000e+00, 0.0000000000e+00, & + 0.0000000000e+00, 0.0000000000e+00, 0.0000000000e+00, & + 0.0000000000e+00, 0.0000000000e+00, 0.0000000000e+00, & + 0.0000000000e+00, 0.0000000000e+00, 0.0000000000e+00, & + 0.0000000000e+00, 0.0000000000e+00, 0.0000000000e+00, & + 0.0000000000e+00, 0.0000000000e+00, 0.0000000000e+00, & + 0.0000000000e+00, 0.0000000000e+00, 0.0000000000e+00, & + 0.0000000000e+00, 0.0000000000e+00, 0.0000000000e+00, & + 0.0000000000e+00, 0.0000000000e+00, 0.0000000000e+00, & + 0.0000000000e+00, 0.0000000000e+00, 0.0000000000e+00, & + 0.0000000000e+00, 0.0000000000e+00, 0.0000000000e+00, & + 0.0000000000e+00, 0.0000000000e+00, 0.0000000000e+00, & + 0.0000000000e+00, 0.0000000000e+00, 0.0000000000e+00, & + 0.0000000000e+00, 0.0000000000e+00, 0.0000000000e+00, & + 0.0000000000e+00, 0.0000000000e+00, 0.0000000000e+00, & + 0.0000000000e+00, 0.0000000000e+00, 0.0000000000e+00, & + 0.0000000000e+00, 0.0000000000e+00, 0.0000000000e+00, & + 0.0000000000e+00, 0.0000000000e+00, 0.0000000000e+00, & + 0.0000000000e+00, 0.0000000000e+00, 0.0000000000e+00, & + 0.0000000000e+00, 0.0000000000e+00, 0.0000000000e+00, & + 0.0000000000e+00, 0.0000000000e+00, 0.0000000000e+00, & + 0.0000000000e+00, 0.0000000000e+00, 1.5648447298e-03, & + 6.2617046389e-03, 1.4104157933e-02, 2.5118187415e-02, & + 3.9340510972e-02, 5.6816335609e-02, 7.7596328431e-02, & + 1.0173255472e-01, 1.2927309709e-01, 1.6025505622e-01, & + 1.9469566981e-01, 2.3258141217e-01, 2.7385520518e-01, & + 3.1840233814e-01, 3.6603639170e-01, 4.1648734767e-01, & + 4.6939496013e-01, 5.2431098738e-01, 5.8071350676e-01, & + 6.3803478105e-01, 6.9495048840e-01, 7.4963750338e-01, & + 7.9975208897e-01, 8.4315257576e-01, 8.8034012292e-01, & + 9.1184389721e-01, 9.3821231526e-01, 9.6000677644e-01, & + 9.7779792223e-01, 9.9216315122e-01, 1.0000000000e+00 / + +! IFS-like L125(top 12 levels removed from IFSL137) + data a125/ 64., & + 86.895882, 107.415741, 131.425507, 159.279404, 191.338562, & + 227.968948, 269.539581, 316.420746, 368.982361, 427.592499, 492.616028, & + 564.413452, 643.339905, 729.744141, 823.967834, 926.344910, 1037.201172, & + 1156.853638, 1285.610352, 1423.770142, 1571.622925, 1729.448975, 1897.519287, & + 2076.095947, 2265.431641, 2465.770508, 2677.348145, 2900.391357, 3135.119385, & + 3381.743652, 3640.468262, 3911.490479, 4194.930664, 4490.817383, 4799.149414, & + 5119.895020, 5452.990723, 5798.344727, 6156.074219, 6526.946777, 6911.870605, & + 7311.869141, 7727.412109, 8159.354004, 8608.525391, 9076.400391, 9562.682617, & + 10065.978516, 10584.631836, 11116.662109, 11660.067383, 12211.547852, 12766.873047, & + 13324.668945, 13881.331055, 14432.139648, 14975.615234, 15508.256836, 16026.115234, & + 16527.322266, 17008.789063, 17467.613281, 17901.621094, 18308.433594, 18685.718750, & + 19031.289063, 19343.511719, 19620.042969, 19859.390625, 20059.931641, 20219.664063, & + 20337.863281, 20412.308594, 20442.078125, 20425.718750, 20361.816406, 20249.511719, & + 20087.085938, 19874.025391, 19608.572266, 19290.226563, 18917.460938, 18489.707031, & + 18006.925781, 17471.839844, 16888.687500, 16262.046875, 15596.695313, 14898.453125, & + 14173.324219, 13427.769531, 12668.257813, 11901.339844, 11133.304688, 10370.175781, & + 9617.515625, 8880.453125, 8163.375000, 7470.343750, 6804.421875, 6168.531250, & + 5564.382813, 4993.796875, 4457.375000, 3955.960938, 3489.234375, 3057.265625, & + 2659.140625, 2294.242188, 1961.500000, 1659.476563, 1387.546875, 1143.250000, & + 926.507813, 734.992188, 568.062500, 424.414063, 302.476563, 202.484375, & + 122.101563, 62.781250, 22.835938, 3.757813, 0.000000, 0.000000 / + + data b125/ 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, & + 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, & + 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, & + 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, & + 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, & + 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, & + 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, & + 0.000000, 0.000007, 0.000024, 0.000059, 0.000112, 0.000199, & + 0.000340, 0.000562, 0.000890, 0.001353, 0.001992, 0.002857, & + 0.003971, 0.005378, 0.007133, 0.009261, 0.011806, 0.014816, & + 0.018318, 0.022355, 0.026964, 0.032176, 0.038026, 0.044548, & + 0.051773, 0.059728, 0.068448, 0.077958, 0.088286, 0.099462, & + 0.111505, 0.124448, 0.138313, 0.153125, 0.168910, 0.185689, & + 0.203491, 0.222333, 0.242244, 0.263242, 0.285354, 0.308598, & + 0.332939, 0.358254, 0.384363, 0.411125, 0.438391, 0.466003, & + 0.493800, 0.521619, 0.549301, 0.576692, 0.603648, 0.630036, & + 0.655736, 0.680643, 0.704669, 0.727739, 0.749797, 0.770798, & + 0.790717, 0.809536, 0.827256, 0.843881, 0.859432, 0.873929, & + 0.887408, 0.899900, 0.911448, 0.922096, 0.931881, 0.940860, & + 0.949064, 0.956550, 0.963352, 0.969513, 0.975078, 0.980072, & + 0.984542, 0.988500, 0.991984, 0.995003, 0.997630, 1.000000 / + + + data a127/ & + 0.99900, 1.60500, 2.53200, 3.92400, & + 5.97600, 8.94700, 13.17700, 19.09600, & + 27.24300, 38.27600, 52.98400, 72.29300, & + 97.26900, 129.11000, 169.13500, 218.76700, & + 279.50600, 352.89400, 440.48100, 543.78200, & + 664.23600, 803.16400, 961.73400, 1140.93100, & + 1341.53800, 1564.11900, 1809.02800, 2076.41500, & + 2366.25200, 2678.37200, 3012.51000, 3368.36300, & + 3745.64600, 4144.16400, 4563.88100, 5004.99500, & + 5468.01700, 5953.84800, 6463.86400, 7000.00000, & + 7563.49400, 8150.66100, 8756.52900, 9376.14100, & + 10004.55300, 10636.85100, 11268.15700, 11893.63900, & + 12508.51900, 13108.09100, 13687.72700, 14242.89000, & + 14769.15300, 15262.20200, 15717.85900, 16132.09000, & + 16501.01800, 16820.93800, 17088.32400, 17299.85200, & + 17453.08400, 17548.35000, 17586.77100, 17569.69700, & + 17498.69700, 17375.56100, 17202.29900, 16981.13700, & + 16714.50400, 16405.02000, 16055.48500, 15668.86000, & + 15248.24700, 14796.86800, 14318.04000, 13815.15000, & + 13291.62900, 12750.92400, 12196.46800, 11631.65900, & + 11059.82700, 10484.20800, 9907.92700, 9333.96700, & + 8765.15500, 8204.14200, 7653.38700, 7115.14700, & + 6591.46800, 6084.17600, 5594.87600, 5124.94900, & + 4675.55400, 4247.63300, 3841.91800, 3458.93300, & + 3099.01000, 2762.29700, 2448.76800, 2158.23800, & + 1890.37500, 1644.71200, 1420.66100, 1217.52800, & + 1034.52400, 870.77800, 725.34800, 597.23500, & + 485.39200, 388.73400, 306.14900, 236.50200, & + 178.65100, 131.44700, 93.74000, 64.39200, & + 42.27400, 26.27400, 15.30200, 8.28700, & + 4.19000, 1.99400, 0.81000, 0.23200, & + 0.02900, 0.00000, 0.00000, 0.00000 / + + + data b127/ & + 0.000000000, 0.000000000, 0.000000000, 0.000000000, & + 0.000000000, 0.000000000, 0.000000000, 0.000000000, & + 0.000000000, 0.000000000, 0.000000000, 0.000000000, & + 0.000000000, 0.000000000, 0.000000000, 0.000000000, & + 0.000000000, 0.000000000, 0.000000000, 0.000000000, & + 0.000000000, 0.000000000, 0.000000000, 0.000000000, & + 0.000000000, 0.000000000, 0.000000000, 0.000000000, & + 0.000000000, 0.000000000, 0.000000000, 0.000000000, & + 0.000000000, 0.000000000, 0.000000000, 0.000000000, & + 0.000000000, 0.000000000, 0.000000000, 0.000000000, & + 0.000010180, 0.000081410, 0.000274690, 0.000650780, & + 0.001270090, 0.002192480, 0.003477130, 0.005182280, & + 0.007365040, 0.010081200, 0.013384920, 0.017328570, & + 0.021962390, 0.027334280, 0.033489540, 0.040470560, & + 0.048316610, 0.057063580, 0.066743720, 0.077385480, & + 0.089006290, 0.101593970, 0.115126180, 0.129576220, & + 0.144912940, 0.161100800, 0.178099890, 0.195866050, & + 0.214351120, 0.233503070, 0.253266330, 0.273582160, & + 0.294388980, 0.315622900, 0.337218050, 0.359107230, & + 0.381222370, 0.403495070, 0.425857160, 0.448241260, & + 0.470581260, 0.492812960, 0.514874340, 0.536706210, & + 0.558252450, 0.579460500, 0.600281540, 0.620670740, & + 0.640587510, 0.659995680, 0.678863350, 0.697163110, & + 0.714872000, 0.731971260, 0.748446460, 0.764287110, & + 0.779486660, 0.794042170, 0.807954130, 0.821226300, & + 0.833865170, 0.845880090, 0.857282640, 0.868086640, & + 0.878307700, 0.887963240, 0.897071780, 0.905653240, & + 0.913728360, 0.921318710, 0.928446350, 0.935133760, & + 0.941403690, 0.947278860, 0.952782090, 0.957935990, & + 0.962762950, 0.967285100, 0.971524000, 0.975500880, & + 0.979236420, 0.982750770, 0.986062530, 0.989185090, & + 0.992129920, 0.994907680, 0.997528200, 1.000000000 / + + +#endif _FV_ETA_ diff --git a/docs/examples/FV3_level_transmogrifier/std_atmos_1976.txt b/docs/examples/FV3_level_transmogrifier/std_atmos_1976.txt new file mode 100644 index 000000000..8d54d5033 --- /dev/null +++ b/docs/examples/FV3_level_transmogrifier/std_atmos_1976.txt @@ -0,0 +1,861 @@ +0.00000 288.150 101325 340.294 +100.000 287.500 100129 339.910 +200.000 286.850 98945.3 339.526 +300.000 286.200 97772.6 339.141 +400.000 285.550 96611.1 338.755 +500.000 284.900 95460.8 338.370 +600.000 284.250 94321.7 337.983 +700.000 283.600 93193.6 337.597 +800.000 282.950 92076.4 337.210 +900.000 282.300 90970.1 336.822 +1000.00 281.650 89874.6 336.434 +1100.00 281.000 88789.8 336.046 +1200.00 280.350 87715.6 335.657 +1300.00 279.700 86651.9 335.267 +1400.00 279.050 85598.8 334.878 +1500.00 278.400 84556.0 334.487 +1600.00 277.750 83523.5 334.097 +1700.00 277.100 82501.3 333.705 +1800.00 276.450 81489.2 333.314 +1900.00 275.800 80487.2 332.922 +2000.00 275.150 79495.2 332.529 +2100.00 274.500 78513.1 332.136 +2200.00 273.850 77540.9 331.743 +2300.00 273.200 76578.4 331.349 +2400.00 272.550 75625.7 330.954 +2500.00 271.900 74682.5 330.560 +2600.00 271.250 73748.9 330.164 +2700.00 270.600 72824.8 329.768 +2800.00 269.950 71910.1 329.372 +2900.00 269.300 71004.7 328.975 +3000.00 268.650 70108.5 328.578 +3100.00 268.000 69221.6 328.180 +3200.00 267.350 68343.7 327.782 +3300.00 266.700 67474.9 327.383 +3400.00 266.050 66615.0 326.984 +3500.00 265.400 65764.1 326.584 +3600.00 264.750 64921.9 326.184 +3700.00 264.100 64088.6 325.784 +3800.00 263.450 63263.9 325.382 +3900.00 262.800 62447.8 324.981 +4000.00 262.150 61640.2 324.579 +4100.00 261.500 60841.2 324.176 +4200.00 260.850 60050.5 323.773 +4300.00 260.200 59268.2 323.369 +4400.00 259.550 58494.2 322.965 +4500.00 258.900 57728.3 322.560 +4600.00 258.250 56970.6 322.155 +4700.00 257.600 56221.0 321.750 +4800.00 256.950 55479.4 321.343 +4900.00 256.300 54745.7 320.937 +5000.00 255.650 54019.9 320.529 +5100.00 255.000 53301.9 320.122 +5200.00 254.350 52591.7 319.713 +5300.00 253.700 51889.1 319.305 +5400.00 253.050 51194.2 318.895 +5500.00 252.400 50506.8 318.486 +5600.00 251.750 49826.9 318.075 +5700.00 251.100 49154.5 317.664 +5800.00 250.450 48489.4 317.253 +5900.00 249.800 47831.6 316.841 +6000.00 249.150 47181.0 316.428 +6100.00 248.500 46537.7 316.015 +6200.00 247.850 45901.4 315.602 +6300.00 247.200 45272.3 315.188 +6400.00 246.550 44650.1 314.773 +6500.00 245.900 44034.8 314.358 +6600.00 245.250 43426.5 313.942 +6700.00 244.600 42825.0 313.526 +6800.00 243.950 42230.2 313.109 +6900.00 243.300 41642.2 312.692 +7000.00 242.650 41060.7 312.274 +7100.00 242.000 40485.9 311.855 +7200.00 241.350 39917.6 311.436 +7300.00 240.700 39355.8 311.016 +7400.00 240.050 38800.4 310.596 +7500.00 239.400 38251.4 310.175 +7600.00 238.750 37708.7 309.754 +7700.00 238.100 37172.2 309.332 +7800.00 237.450 36642.0 308.909 +7900.00 236.800 36117.8 308.486 +8000.00 236.150 35599.8 308.063 +8100.00 235.500 35087.8 307.638 +8200.00 234.850 34581.8 307.214 +8300.00 234.200 34081.7 306.788 +8400.00 233.550 33587.5 306.362 +8500.00 232.900 33099.0 305.935 +8600.00 232.250 32616.4 305.508 +8700.00 231.600 32139.5 305.080 +8800.00 230.950 31668.2 304.652 +8900.00 230.300 31202.6 304.223 +9000.00 229.650 30742.5 303.793 +9100.00 229.000 30287.9 303.363 +9200.00 228.350 29838.7 302.932 +9300.00 227.700 29395.0 302.501 +9400.00 227.050 28956.7 302.069 +9500.00 226.400 28523.6 301.636 +9600.00 225.750 28095.8 301.203 +9700.00 225.100 27673.2 300.769 +9800.00 224.450 27255.8 300.334 +9900.00 223.800 26843.5 299.899 +10000.0 223.150 26436.3 299.463 +10100.0 222.500 26034.0 299.027 +10200.0 221.850 25636.8 298.590 +10300.0 221.200 25244.5 298.152 +10400.0 220.550 24857.0 297.714 +10500.0 219.900 24474.4 297.275 +10600.0 219.250 24096.5 296.835 +10700.0 218.600 23723.4 296.395 +10800.0 217.950 23355.0 295.954 +10900.0 217.300 22991.2 295.512 +11000.0 216.650 22632.1 295.070 +11100.0 216.650 22278.0 295.070 +11200.0 216.650 21929.4 295.070 +11300.0 216.650 21586.3 295.070 +11400.0 216.650 21248.6 295.070 +11500.0 216.650 20916.2 295.070 +11600.0 216.650 20589.0 295.070 +11700.0 216.650 20266.8 295.070 +11800.0 216.650 19949.8 295.070 +11900.0 216.650 19637.6 295.070 +12000.0 216.650 19330.4 295.070 +12100.0 216.650 19028.0 295.070 +12200.0 216.650 18730.3 295.070 +12300.0 216.650 18437.2 295.070 +12400.0 216.650 18148.8 295.070 +12500.0 216.650 17864.8 295.070 +12600.0 216.650 17585.4 295.070 +12700.0 216.650 17310.2 295.070 +12800.0 216.650 17039.4 295.070 +12900.0 216.650 16772.8 295.070 +13000.0 216.650 16510.4 295.070 +13100.0 216.650 16252.1 295.070 +13200.0 216.650 15997.8 295.070 +13300.0 216.650 15747.5 295.070 +13400.0 216.650 15501.2 295.070 +13500.0 216.650 15258.7 295.070 +13600.0 216.650 15019.9 295.070 +13700.0 216.650 14784.9 295.070 +13800.0 216.650 14553.6 295.070 +13900.0 216.650 14325.9 295.070 +14000.0 216.650 14101.8 295.070 +14100.0 216.650 13881.2 295.070 +14200.0 216.650 13664.0 295.070 +14300.0 216.650 13450.2 295.070 +14400.0 216.650 13239.8 295.070 +14500.0 216.650 13032.7 295.070 +14600.0 216.650 12828.8 295.070 +14700.0 216.650 12628.1 295.070 +14800.0 216.650 12430.5 295.070 +14900.0 216.650 12236.0 295.070 +15000.0 216.650 12044.6 295.070 +15100.0 216.650 11856.1 295.070 +15200.0 216.650 11670.6 295.070 +15300.0 216.650 11488.1 295.070 +15400.0 216.650 11308.3 295.070 +15500.0 216.650 11131.4 295.070 +15600.0 216.650 10957.2 295.070 +15700.0 216.650 10785.8 295.070 +15800.0 216.650 10617.1 295.070 +15900.0 216.650 10451.0 295.070 +16000.0 216.650 10287.5 295.070 +16100.0 216.650 10126.5 295.070 +16200.0 216.650 9968.08 295.070 +16300.0 216.650 9812.13 295.070 +16400.0 216.650 9658.61 295.070 +16500.0 216.650 9507.50 295.070 +16600.0 216.650 9358.76 295.070 +16700.0 216.650 9212.34 295.070 +16800.0 216.650 9068.21 295.070 +16900.0 216.650 8926.34 295.070 +17000.0 216.650 8786.68 295.070 +17100.0 216.650 8649.21 295.070 +17200.0 216.650 8513.89 295.070 +17300.0 216.650 8380.69 295.070 +17400.0 216.650 8249.58 295.070 +17500.0 216.650 8120.51 295.070 +17600.0 216.650 7993.46 295.070 +17700.0 216.650 7868.40 295.070 +17800.0 216.650 7745.30 295.070 +17900.0 216.650 7624.13 295.070 +18000.0 216.650 7504.84 295.070 +18100.0 216.650 7387.43 295.070 +18200.0 216.650 7271.85 295.070 +18300.0 216.650 7158.08 295.070 +18400.0 216.650 7046.09 295.070 +18500.0 216.650 6935.86 295.070 +18600.0 216.650 6827.34 295.070 +18700.0 216.650 6720.53 295.070 +18800.0 216.650 6615.39 295.070 +18900.0 216.650 6511.89 295.070 +19000.0 216.650 6410.01 295.070 +19100.0 216.650 6309.72 295.070 +19200.0 216.650 6211.00 295.070 +19300.0 216.650 6113.83 295.070 +19400.0 216.650 6018.18 295.070 +19500.0 216.650 5924.03 295.070 +19600.0 216.650 5831.34 295.070 +19700.0 216.650 5740.11 295.070 +19800.0 216.650 5650.31 295.070 +19900.0 216.650 5561.91 295.070 +20000.0 216.650 5474.89 295.070 +20100.0 216.750 5389.25 295.138 +20200.0 216.850 5304.99 295.206 +20300.0 216.950 5222.09 295.274 +20400.0 217.050 5140.52 295.342 +20500.0 217.150 5060.26 295.410 +20600.0 217.250 4981.29 295.478 +20700.0 217.350 4903.59 295.546 +20800.0 217.450 4827.14 295.614 +20900.0 217.550 4751.91 295.682 +21000.0 217.650 4677.89 295.750 +21100.0 217.750 4605.05 295.818 +21200.0 217.850 4533.38 295.886 +21300.0 217.950 4462.86 295.954 +21400.0 218.050 4393.47 296.021 +21500.0 218.150 4325.18 296.089 +21600.0 218.250 4257.99 296.157 +21700.0 218.350 4191.87 296.225 +21800.0 218.450 4126.81 296.293 +21900.0 218.550 4062.79 296.361 +22000.0 218.650 3999.79 296.428 +22100.0 218.750 3937.79 296.496 +22200.0 218.850 3876.79 296.564 +22300.0 218.950 3816.75 296.632 +22400.0 219.050 3757.68 296.699 +22500.0 219.150 3699.54 296.767 +22600.0 219.250 3642.33 296.835 +22700.0 219.350 3586.03 296.903 +22800.0 219.450 3530.62 296.970 +22900.0 219.550 3476.09 297.038 +23000.0 219.650 3422.43 297.105 +23100.0 219.750 3369.63 297.173 +23200.0 219.850 3317.66 297.241 +23300.0 219.950 3266.51 297.308 +23400.0 220.050 3216.18 297.376 +23500.0 220.150 3166.65 297.443 +23600.0 220.250 3117.90 297.511 +23700.0 220.350 3069.92 297.579 +23800.0 220.450 3022.70 297.646 +23900.0 220.550 2976.23 297.714 +24000.0 220.650 2930.49 297.781 +24100.0 220.750 2885.48 297.849 +24200.0 220.850 2841.18 297.916 +24300.0 220.950 2797.58 297.983 +24400.0 221.050 2754.66 298.051 +24500.0 221.150 2712.42 298.118 +24600.0 221.250 2670.85 298.186 +24700.0 221.350 2629.94 298.253 +24800.0 221.450 2589.67 298.320 +24900.0 221.550 2550.03 298.388 +25000.0 221.650 2511.02 298.455 +25100.0 221.750 2472.63 298.522 +25200.0 221.850 2434.83 298.590 +25300.0 221.950 2397.63 298.657 +25400.0 222.050 2361.02 298.724 +25500.0 222.150 2324.98 298.791 +25600.0 222.250 2289.51 298.859 +25700.0 222.350 2254.59 298.926 +25800.0 222.450 2220.22 298.993 +25900.0 222.550 2186.39 299.060 +26000.0 222.650 2153.09 299.128 +26100.0 222.750 2120.32 299.195 +26200.0 222.850 2088.05 299.262 +26300.0 222.950 2056.29 299.329 +26400.0 223.050 2025.03 299.396 +26500.0 223.150 1994.26 299.463 +26600.0 223.250 1963.97 299.530 +26700.0 223.350 1934.15 299.597 +26800.0 223.450 1904.80 299.664 +26900.0 223.550 1875.90 299.732 +27000.0 223.650 1847.46 299.799 +27100.0 223.750 1819.46 299.866 +27200.0 223.850 1791.89 299.933 +27300.0 223.950 1764.76 300.000 +27400.0 224.050 1738.05 300.067 +27500.0 224.150 1711.75 300.133 +27600.0 224.250 1685.87 300.200 +27700.0 224.350 1660.39 300.267 +27800.0 224.450 1635.30 300.334 +27900.0 224.550 1610.60 300.401 +28000.0 224.650 1586.29 300.468 +28100.0 224.750 1562.35 300.535 +28200.0 224.850 1538.79 300.602 +28300.0 224.950 1515.59 300.669 +28400.0 225.050 1492.75 300.735 +28500.0 225.150 1470.27 300.802 +28600.0 225.250 1448.13 300.869 +28700.0 225.350 1426.34 300.936 +28800.0 225.450 1404.89 301.003 +28900.0 225.550 1383.76 301.069 +29000.0 225.650 1362.96 301.136 +29100.0 225.750 1342.49 301.203 +29200.0 225.850 1322.33 301.269 +29300.0 225.950 1302.48 301.336 +29400.0 226.050 1282.94 301.403 +29500.0 226.150 1263.70 301.469 +29600.0 226.250 1244.76 301.536 +29700.0 226.350 1226.11 301.603 +29800.0 226.450 1207.75 301.669 +29900.0 226.550 1189.67 301.736 +30000.0 226.650 1171.87 301.803 +30100.0 226.750 1154.34 301.869 +30200.0 226.850 1137.08 301.936 +30300.0 226.950 1120.09 302.002 +30400.0 227.050 1103.36 302.069 +30500.0 227.150 1086.88 302.135 +30600.0 227.250 1070.66 302.202 +30700.0 227.350 1054.69 302.268 +30800.0 227.450 1038.97 302.335 +30900.0 227.550 1023.48 302.401 +31000.0 227.650 1008.23 302.468 +31100.0 227.750 993.218 302.534 +31200.0 227.850 978.434 302.600 +31300.0 227.950 963.876 302.667 +31400.0 228.050 949.541 302.733 +31500.0 228.150 935.425 302.800 +31600.0 228.250 921.526 302.866 +31700.0 228.350 907.838 302.932 +31800.0 228.450 894.360 302.999 +31900.0 228.550 881.088 303.065 +32000.0 228.650 868.019 303.131 +32100.0 228.930 855.154 303.317 +32200.0 229.210 842.495 303.502 +32300.0 229.490 830.038 303.688 +32400.0 229.770 817.781 303.873 +32500.0 230.050 805.719 304.058 +32600.0 230.330 793.849 304.243 +32700.0 230.610 782.168 304.428 +32800.0 230.890 770.674 304.612 +32900.0 231.170 759.361 304.797 +33000.0 231.450 748.228 304.982 +33100.0 231.730 737.272 305.166 +33200.0 232.010 726.489 305.350 +33300.0 232.290 715.876 305.535 +33400.0 232.570 705.431 305.719 +33500.0 232.850 695.150 305.903 +33600.0 233.130 685.032 306.086 +33700.0 233.410 675.072 306.270 +33800.0 233.690 665.269 306.454 +33900.0 233.970 655.620 306.637 +34000.0 234.250 646.122 306.821 +34100.0 234.530 636.773 307.004 +34200.0 234.810 627.570 307.187 +34300.0 235.090 618.511 307.370 +34400.0 235.370 609.593 307.553 +34500.0 235.650 600.814 307.736 +34600.0 235.930 592.172 307.919 +34700.0 236.210 583.664 308.102 +34800.0 236.490 575.288 308.284 +34900.0 236.770 567.042 308.467 +35000.0 237.050 558.924 308.649 +35100.0 237.330 550.931 308.831 +35200.0 237.610 543.062 309.013 +35300.0 237.890 535.314 309.195 +35400.0 238.170 527.686 309.377 +35500.0 238.450 520.175 309.559 +35600.0 238.730 512.780 309.741 +35700.0 239.010 505.498 309.922 +35800.0 239.290 498.329 310.104 +35900.0 239.570 491.269 310.285 +36000.0 239.850 484.317 310.467 +36100.0 240.130 477.471 310.648 +36200.0 240.410 470.730 310.829 +36300.0 240.690 464.092 311.010 +36400.0 240.970 457.555 311.191 +36500.0 241.250 451.118 311.371 +36600.0 241.530 444.778 311.552 +36700.0 241.810 438.535 311.733 +36800.0 242.090 432.386 311.913 +36900.0 242.370 426.331 312.093 +37000.0 242.650 420.367 312.274 +37100.0 242.930 414.494 312.454 +37200.0 243.210 408.709 312.634 +37300.0 243.490 403.011 312.814 +37400.0 243.770 397.399 312.993 +37500.0 244.050 391.872 313.173 +37600.0 244.330 386.427 313.353 +37700.0 244.610 381.065 313.532 +37800.0 244.890 375.783 313.712 +37900.0 245.170 370.580 313.891 +38000.0 245.450 365.455 314.070 +38100.0 245.730 360.406 314.249 +38200.0 246.010 355.433 314.428 +38300.0 246.290 350.534 314.607 +38400.0 246.570 345.708 314.786 +38500.0 246.850 340.954 314.965 +38600.0 247.130 336.270 315.143 +38700.0 247.410 331.656 315.322 +38800.0 247.690 327.111 315.500 +38900.0 247.970 322.632 315.678 +39000.0 248.250 318.220 315.856 +39100.0 248.530 313.874 316.034 +39200.0 248.810 309.591 316.212 +39300.0 249.090 305.372 316.390 +39400.0 249.370 301.214 316.568 +39500.0 249.650 297.118 316.746 +39600.0 249.930 293.082 316.923 +39700.0 250.210 289.105 317.101 +39800.0 250.490 285.187 317.278 +39900.0 250.770 281.326 317.455 +40000.0 251.050 277.522 317.633 +40100.0 251.330 273.773 317.810 +40200.0 251.610 270.079 317.987 +40300.0 251.890 266.438 318.164 +40400.0 252.170 262.851 318.340 +40500.0 252.450 259.316 318.517 +40600.0 252.730 255.832 318.694 +40700.0 253.010 252.399 318.870 +40800.0 253.290 249.016 319.047 +40900.0 253.570 245.682 319.223 +41000.0 253.850 242.395 319.399 +41100.0 254.130 239.157 319.575 +41200.0 254.410 235.965 319.751 +41300.0 254.690 232.819 319.927 +41400.0 254.970 229.719 320.103 +41500.0 255.250 226.663 320.279 +41600.0 255.530 223.651 320.454 +41700.0 255.810 220.683 320.630 +41800.0 256.090 217.757 320.805 +41900.0 256.370 214.873 320.981 +42000.0 256.650 212.030 321.156 +42100.0 256.930 209.228 321.331 +42200.0 257.210 206.466 321.506 +42300.0 257.490 203.743 321.681 +42400.0 257.770 201.059 321.856 +42500.0 258.050 198.413 322.030 +42600.0 258.330 195.805 322.205 +42700.0 258.610 193.234 322.380 +42800.0 258.890 190.700 322.554 +42900.0 259.170 188.201 322.729 +43000.0 259.450 185.738 322.903 +43100.0 259.730 183.309 323.077 +43200.0 260.010 180.915 323.251 +43300.0 260.290 178.555 323.425 +43400.0 260.570 176.228 323.599 +43500.0 260.850 173.934 323.773 +43600.0 261.130 171.672 323.947 +43700.0 261.410 169.442 324.120 +43800.0 261.690 167.243 324.294 +43900.0 261.970 165.075 324.467 +44000.0 262.250 162.937 324.641 +44100.0 262.530 160.830 324.814 +44200.0 262.810 158.751 324.987 +44300.0 263.090 156.702 325.160 +44400.0 263.370 154.682 325.333 +44500.0 263.650 152.689 325.506 +44600.0 263.930 150.724 325.679 +44700.0 264.210 148.787 325.851 +44800.0 264.490 146.877 326.024 +44900.0 264.770 144.993 326.197 +45000.0 265.050 143.135 326.369 +45100.0 265.330 141.303 326.541 +45200.0 265.610 139.496 326.714 +45300.0 265.890 137.714 326.886 +45400.0 266.170 135.957 327.058 +45500.0 266.450 134.224 327.230 +45600.0 266.730 132.515 327.402 +45700.0 267.010 130.829 327.574 +45800.0 267.290 129.167 327.745 +45900.0 267.570 127.527 327.917 +46000.0 267.850 125.910 328.088 +46100.0 268.130 124.315 328.260 +46200.0 268.410 122.742 328.431 +46300.0 268.690 121.191 328.602 +46400.0 268.970 119.660 328.774 +46500.0 269.250 118.151 328.945 +46600.0 269.530 116.662 329.116 +46700.0 269.810 115.193 329.287 +46800.0 270.090 113.745 329.457 +46900.0 270.370 112.316 329.628 +47000.0 270.650 110.906 329.799 +47100.0 270.650 109.515 329.799 +47200.0 270.650 108.141 329.799 +47300.0 270.650 106.785 329.799 +47400.0 270.650 105.446 329.799 +47500.0 270.650 104.123 329.799 +47600.0 270.650 102.817 329.799 +47700.0 270.650 101.527 329.799 +47800.0 270.650 100.254 329.799 +47900.0 270.650 98.9962 329.799 +48000.0 270.650 97.7545 329.799 +48100.0 270.650 96.5283 329.799 +48200.0 270.650 95.3176 329.799 +48300.0 270.650 94.1220 329.799 +48400.0 270.650 92.9414 329.799 +48500.0 270.650 91.7756 329.799 +48600.0 270.650 90.6244 329.799 +48700.0 270.650 89.4877 329.799 +48800.0 270.650 88.3652 329.799 +48900.0 270.650 87.2568 329.799 +49000.0 270.650 86.1623 329.799 +49100.0 270.650 85.0815 329.799 +49200.0 270.650 84.0143 329.799 +49300.0 270.650 82.9605 329.799 +49400.0 270.650 81.9199 329.799 +49500.0 270.650 80.8924 329.799 +49600.0 270.650 79.8777 329.799 +49700.0 270.650 78.8758 329.799 +49800.0 270.650 77.8864 329.799 +49900.0 270.650 76.9095 329.799 +50000.0 270.650 75.9448 329.799 +50100.0 270.650 74.9922 329.799 +50200.0 270.650 74.0515 329.799 +50300.0 270.650 73.1227 329.799 +50400.0 270.650 72.2055 329.799 +50500.0 270.650 71.2998 329.799 +50600.0 270.650 70.4054 329.799 +50700.0 270.650 69.5223 329.799 +50800.0 270.650 68.6503 329.799 +50900.0 270.650 67.7892 329.799 +51000.0 270.650 66.9389 329.799 +51100.0 270.370 66.0988 329.628 +51200.0 270.090 65.2684 329.457 +51300.0 269.810 64.4476 329.287 +51400.0 269.530 63.6363 329.116 +51500.0 269.250 62.8344 328.945 +51600.0 268.970 62.0418 328.774 +51700.0 268.690 61.2583 328.602 +51800.0 268.410 60.4840 328.431 +51900.0 268.130 59.7186 328.260 +52000.0 267.850 58.9622 328.088 +52100.0 267.570 58.2145 327.917 +52200.0 267.290 57.4756 327.745 +52300.0 267.010 56.7453 327.574 +52400.0 266.730 56.0235 327.402 +52500.0 266.450 55.3101 327.230 +52600.0 266.170 54.6051 327.058 +52700.0 265.890 53.9084 326.886 +52800.0 265.610 53.2198 326.714 +52900.0 265.330 52.5393 326.541 +53000.0 265.050 51.8668 326.369 +53100.0 264.770 51.2022 326.197 +53200.0 264.490 50.5454 326.024 +53300.0 264.210 49.8964 325.851 +53400.0 263.930 49.2551 325.679 +53500.0 263.650 48.6213 325.506 +53600.0 263.370 47.9950 325.333 +53700.0 263.090 47.3761 325.160 +53800.0 262.810 46.7646 324.987 +53900.0 262.530 46.1603 324.814 +54000.0 262.250 45.5632 324.641 +54100.0 261.970 44.9731 324.467 +54200.0 261.690 44.3902 324.294 +54300.0 261.410 43.8141 324.120 +54400.0 261.130 43.2449 323.947 +54500.0 260.850 42.6826 323.773 +54600.0 260.570 42.1269 323.599 +54700.0 260.290 41.5779 323.425 +54800.0 260.010 41.0354 323.251 +54900.0 259.730 40.4995 323.077 +55000.0 259.450 39.9700 322.903 +55100.0 259.170 39.4469 322.729 +55200.0 258.890 38.9300 322.554 +55300.0 258.610 38.4194 322.380 +55400.0 258.330 37.9149 322.205 +55500.0 258.050 37.4166 322.030 +55600.0 257.770 36.9242 321.856 +55700.0 257.490 36.4378 321.681 +55800.0 257.210 35.9573 321.506 +55900.0 256.930 35.4826 321.331 +56000.0 256.650 35.0137 321.156 +56100.0 256.370 34.5504 320.981 +56200.0 256.090 34.0928 320.805 +56300.0 255.810 33.6408 320.630 +56400.0 255.530 33.1943 320.454 +56500.0 255.250 32.7532 320.279 +56600.0 254.970 32.3175 320.103 +56700.0 254.690 31.8871 319.927 +56800.0 254.410 31.4620 319.751 +56900.0 254.130 31.0421 319.575 +57000.0 253.850 30.6274 319.399 +57100.0 253.570 30.2178 319.223 +57200.0 253.290 29.8131 319.047 +57300.0 253.010 29.4135 318.870 +57400.0 252.730 29.0188 318.694 +57500.0 252.450 28.6290 318.517 +57600.0 252.170 28.2439 318.340 +57700.0 251.890 27.8637 318.164 +57800.0 251.610 27.4881 317.987 +57900.0 251.330 27.1172 317.810 +58000.0 251.050 26.7509 317.633 +58100.0 250.770 26.3891 317.455 +58200.0 250.490 26.0318 317.278 +58300.0 250.210 25.6790 317.101 +58400.0 249.930 25.3306 316.923 +58500.0 249.650 24.9865 316.746 +58600.0 249.370 24.6467 316.568 +58700.0 249.090 24.3112 316.390 +58800.0 248.810 23.9798 316.212 +58900.0 248.530 23.6526 316.034 +59000.0 248.250 23.3296 315.856 +59100.0 247.970 23.0105 315.678 +59200.0 247.690 22.6955 315.500 +59300.0 247.410 22.3844 315.322 +59400.0 247.130 22.0773 315.143 +59500.0 246.850 21.7740 314.965 +59600.0 246.570 21.4746 314.786 +59700.0 246.290 21.1789 314.607 +59800.0 246.010 20.8870 314.428 +59900.0 245.730 20.5988 314.249 +60000.0 245.450 20.3143 314.070 +60100.0 245.170 20.0333 313.891 +60200.0 244.890 19.7559 313.712 +60300.0 244.610 19.4821 313.532 +60400.0 244.330 19.2117 313.353 +60500.0 244.050 18.9448 313.173 +60600.0 243.770 18.6813 312.993 +60700.0 243.490 18.4212 312.814 +60800.0 243.210 18.1644 312.634 +60900.0 242.930 17.9109 312.454 +61000.0 242.650 17.6606 312.274 +61100.0 242.370 17.4136 312.093 +61200.0 242.090 17.1697 311.913 +61300.0 241.810 16.9290 311.733 +61400.0 241.530 16.6913 311.552 +61500.0 241.250 16.4568 311.371 +61600.0 240.970 16.2252 311.191 +61700.0 240.690 15.9967 311.010 +61800.0 240.410 15.7711 310.829 +61900.0 240.130 15.5485 310.648 +62000.0 239.850 15.3287 310.467 +62100.0 239.570 15.1118 310.285 +62200.0 239.290 14.8977 310.104 +62300.0 239.010 14.6864 309.922 +62400.0 238.730 14.4778 309.741 +62500.0 238.450 14.2720 309.559 +62600.0 238.170 14.0689 309.377 +62700.0 237.890 13.8684 309.195 +62800.0 237.610 13.6705 309.013 +62900.0 237.330 13.4753 308.831 +63000.0 237.050 13.2826 308.649 +63100.0 236.770 13.0924 308.467 +63200.0 236.490 12.9047 308.284 +63300.0 236.210 12.7196 308.102 +63400.0 235.930 12.5368 307.919 +63500.0 235.650 12.3565 307.736 +63600.0 235.370 12.1785 307.553 +63700.0 235.090 12.0029 307.370 +63800.0 234.810 11.8297 307.187 +63900.0 234.530 11.6587 307.004 +64000.0 234.250 11.4900 306.821 +64100.0 233.970 11.3235 306.637 +64200.0 233.690 11.1593 306.454 +64300.0 233.410 10.9973 306.270 +64400.0 233.130 10.8374 306.086 +64500.0 232.850 10.6796 305.903 +64600.0 232.570 10.5240 305.719 +64700.0 232.290 10.3704 305.535 +64800.0 232.010 10.2189 305.350 +64900.0 231.730 10.0695 305.166 +65000.0 231.450 9.92203 304.982 +65100.0 231.170 9.77656 304.797 +65200.0 230.890 9.63306 304.612 +65300.0 230.610 9.49149 304.428 +65400.0 230.330 9.35183 304.243 +65500.0 230.050 9.21406 304.058 +65600.0 229.770 9.07816 303.873 +65700.0 229.490 8.94410 303.688 +65800.0 229.210 8.81186 303.502 +65900.0 228.930 8.68141 303.317 +66000.0 228.650 8.55275 303.131 +66100.0 228.370 8.42583 302.946 +66200.0 228.090 8.30064 302.760 +66300.0 227.810 8.17717 302.574 +66400.0 227.530 8.05538 302.388 +66500.0 227.250 7.93526 302.202 +66600.0 226.970 7.81679 302.016 +66700.0 226.690 7.69994 301.829 +66800.0 226.410 7.58470 301.643 +66900.0 226.130 7.47104 301.456 +67000.0 225.850 7.35895 301.269 +67100.0 225.570 7.24841 301.083 +67200.0 225.290 7.13939 300.896 +67300.0 225.010 7.03187 300.709 +67400.0 224.730 6.92585 300.522 +67500.0 224.450 6.82130 300.334 +67600.0 224.170 6.71819 300.147 +67700.0 223.890 6.61652 299.959 +67800.0 223.610 6.51626 299.772 +67900.0 223.330 6.41740 299.584 +68000.0 223.050 6.31992 299.396 +68100.0 222.770 6.22380 299.208 +68200.0 222.490 6.12902 299.020 +68300.0 222.210 6.03557 298.832 +68400.0 221.930 5.94343 298.644 +68500.0 221.650 5.85259 298.455 +68600.0 221.370 5.76302 298.266 +68700.0 221.090 5.67470 298.078 +68800.0 220.810 5.58764 297.889 +68900.0 220.530 5.50180 297.700 +69000.0 220.250 5.41717 297.511 +69100.0 219.970 5.33374 297.322 +69200.0 219.690 5.25149 297.133 +69300.0 219.410 5.17041 296.943 +69400.0 219.130 5.09047 296.754 +69500.0 218.850 5.01168 296.564 +69600.0 218.570 4.93400 296.374 +69700.0 218.290 4.85743 296.184 +69800.0 218.010 4.78196 295.994 +69900.0 217.730 4.70756 295.804 +70000.0 217.450 4.63422 295.614 +70100.0 217.170 4.56194 295.423 +70200.0 216.890 4.49069 295.233 +70300.0 216.610 4.42046 295.042 +70400.0 216.330 4.35125 294.852 +70500.0 216.050 4.28303 294.661 +70600.0 215.770 4.21579 294.470 +70700.0 215.490 4.14952 294.279 +70800.0 215.210 4.08422 294.087 +70900.0 214.930 4.01985 293.896 +71000.0 214.650 3.95642 293.704 +71100.0 214.450 3.89392 293.568 +71200.0 214.250 3.83235 293.431 +71300.0 214.050 3.77170 293.294 +71400.0 213.850 3.71195 293.157 +71500.0 213.650 3.65310 293.019 +71600.0 213.450 3.59512 292.882 +71700.0 213.250 3.53801 292.745 +71800.0 213.050 3.48176 292.608 +71900.0 212.850 3.42634 292.470 +72000.0 212.650 3.37176 292.333 +72100.0 212.450 3.31800 292.195 +72200.0 212.250 3.26505 292.058 +72300.0 212.050 3.21289 291.920 +72400.0 211.850 3.16152 291.783 +72500.0 211.650 3.11092 291.645 +72600.0 211.450 3.06109 291.507 +72700.0 211.250 3.01200 291.369 +72800.0 211.050 2.96366 291.231 +72900.0 210.850 2.91605 291.093 +73000.0 210.650 2.86917 290.955 +73100.0 210.450 2.82299 290.817 +73200.0 210.250 2.77751 290.679 +73300.0 210.050 2.73272 290.540 +73400.0 209.850 2.68861 290.402 +73500.0 209.650 2.64518 290.264 +73600.0 209.450 2.60240 290.125 +73700.0 209.250 2.56028 289.987 +73800.0 209.050 2.51880 289.848 +73900.0 208.850 2.47795 289.709 +74000.0 208.650 2.43773 289.570 +74100.0 208.450 2.39812 289.432 +74200.0 208.250 2.35912 289.293 +74300.0 208.050 2.32071 289.154 +74400.0 207.850 2.28290 289.015 +74500.0 207.650 2.24567 288.876 +74600.0 207.450 2.20900 288.737 +74700.0 207.250 2.17291 288.597 +74800.0 207.050 2.13737 288.458 +74900.0 206.850 2.10237 288.319 +75000.0 206.650 2.06792 288.179 +75100.0 206.450 2.03400 288.040 +75200.0 206.250 2.00060 287.900 +75300.0 206.050 1.96772 287.761 +75400.0 205.850 1.93535 287.621 +75500.0 205.650 1.90348 287.481 +75600.0 205.450 1.87210 287.341 +75700.0 205.250 1.84121 287.201 +75800.0 205.050 1.81081 287.061 +75900.0 204.850 1.78087 286.921 +76000.0 204.650 1.75140 286.781 +76100.0 204.450 1.72240 286.641 +76200.0 204.250 1.69384 286.501 +76300.0 204.050 1.66573 286.361 +76400.0 203.850 1.63806 286.220 +76500.0 203.650 1.61082 286.080 +76600.0 203.450 1.58401 285.939 +76700.0 203.250 1.55762 285.799 +76800.0 203.050 1.53165 285.658 +76900.0 202.850 1.50608 285.517 +77000.0 202.650 1.48092 285.377 +77100.0 202.450 1.45615 285.236 +77200.0 202.250 1.43177 285.095 +77300.0 202.050 1.40778 284.954 +77400.0 201.850 1.38416 284.813 +77500.0 201.650 1.36092 284.672 +77600.0 201.450 1.33805 284.530 +77700.0 201.250 1.31554 284.389 +77800.0 201.050 1.29338 284.248 +77900.0 200.850 1.27158 284.106 +78000.0 200.650 1.25012 283.965 +78100.0 200.450 1.22901 283.823 +78200.0 200.250 1.20823 283.682 +78300.0 200.050 1.18778 283.540 +78400.0 199.850 1.16766 283.398 +78500.0 199.650 1.14786 283.256 +78600.0 199.450 1.12837 283.114 +78700.0 199.250 1.10920 282.972 +78800.0 199.050 1.09034 282.830 +78900.0 198.850 1.07177 282.688 +79000.0 198.650 1.05351 282.546 +79100.0 198.450 1.03554 282.404 +79200.0 198.250 1.01785 282.262 +79300.0 198.050 1.00045 282.119 +79400.0 197.850 0.983336 281.977 +79500.0 197.650 0.966494 281.834 +79600.0 197.450 0.949924 281.691 +79700.0 197.250 0.933621 281.549 +79800.0 197.050 0.917582 281.406 +79900.0 196.850 0.901803 281.263 +80000.0 196.650 0.886280 281.120 +80100.0 196.450 0.871008 280.977 +80200.0 196.250 0.855984 280.834 +80300.0 196.050 0.841205 280.691 +80400.0 195.850 0.826666 280.548 +80500.0 195.650 0.812363 280.405 +80600.0 195.450 0.798294 280.261 +80700.0 195.250 0.784455 280.118 +80800.0 195.050 0.770842 279.974 +80900.0 194.850 0.757451 279.831 +81000.0 194.650 0.744280 279.687 +81100.0 194.450 0.731324 279.543 +81200.0 194.250 0.718581 279.399 +81300.0 194.050 0.706047 279.256 +81400.0 193.850 0.693720 279.112 +81500.0 193.650 0.681595 278.968 +81600.0 193.450 0.669670 278.824 +81700.0 193.250 0.657941 278.679 +81800.0 193.050 0.646406 278.535 +81900.0 192.850 0.635062 278.391 +82000.0 192.650 0.623905 278.246 +82100.0 192.450 0.612933 278.102 +82200.0 192.250 0.602143 277.957 +82300.0 192.050 0.591532 277.813 +82400.0 191.850 0.581097 277.668 +82500.0 191.650 0.570835 277.523 +82600.0 191.450 0.560745 277.378 +82700.0 191.250 0.550822 277.234 +82800.0 191.050 0.541065 277.089 +82900.0 190.850 0.531471 276.943 +83000.0 190.650 0.522037 276.798 +83100.0 190.450 0.512761 276.653 +83200.0 190.250 0.503640 276.508 +83300.0 190.050 0.494672 276.362 +83400.0 189.850 0.485855 276.217 +83500.0 189.650 0.477186 276.071 +83600.0 189.450 0.468662 275.926 +83700.0 189.250 0.460282 275.780 +83800.0 189.050 0.452044 275.634 +83900.0 188.850 0.443944 275.489 +84000.0 188.650 0.435981 275.343 +84100.0 188.450 0.428153 275.197 +84200.0 188.250 0.420457 275.051 +84300.0 188.050 0.412891 274.904 +84400.0 187.850 0.405454 274.758 +84500.0 187.650 0.398143 274.612 +84600.0 187.450 0.390956 274.466 +84700.0 187.250 0.383892 274.319 +84800.0 187.050 0.376948 274.173 +84900.0 186.946 0.370123 274.096 +85000.0 186.946 0.363420 274.096 +85100.0 186.946 0.356839 274.096 +85200.0 186.946 0.350378 274.096 +85300.0 186.946 0.344033 274.096 +85400.0 186.946 0.337803 274.096 +85500.0 186.946 0.331686 274.096 +85600.0 186.946 0.325680 274.096 +85700.0 186.946 0.319782 274.096 +85800.0 186.946 0.313991 274.096 +85900.0 186.946 0.308305 274.096 +86000.0 186.946 0.302723 274.096 diff --git a/docs/examples/HSzuritasuperrotation.ipynb b/docs/examples/HSzuritasuperrotation.ipynb new file mode 100644 index 000000000..d5a52e440 --- /dev/null +++ b/docs/examples/HSzuritasuperrotation.ipynb @@ -0,0 +1,1036 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "989ec497", + "metadata": {}, + "source": [ + "This is a C96 Held-Suarez simulation with moisture to demonstrate stability and large-scale characteristics in a climate-like model run. This test is useful to diagnose the effect of dynamics settings on the behavior of the simulated climate, especially how mid-latitude variability is simulated. Note that since Held-Suarez has sinks of heat and potential vorticity it is much more useful for testing dynamical core design than the Baroclinic wave test, which lacks any diabatic physical processes.\n", + "\n", + "We also investigate the " + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "36c385f0", + "metadata": {}, + "outputs": [], + "source": [ + "import xarray as xa\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from matplotlib import cm\n", + "import dask #Chunking will be necessary for the larger datasets\n", + "import cartopy.crs as ccrs\n", + "import cartopy.feature as cfeature\n", + "from matplotlib import ticker, cm, colors\n", + "import os\n", + "import pandas as pd\n", + "import dask\n", + "from glob import glob\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "3ac02a9a", + "metadata": {}, + "outputs": [], + "source": [ + "large = 24; med = 20; small = 16\n", + "params = {'axes.titlesize': large,\n", + " 'legend.fontsize': med,\n", + " 'figure.figsize': (8, 4),\n", + " 'axes.labelsize': med,\n", + " 'axes.titlesize': large,\n", + " 'xtick.labelsize': small,\n", + " 'ytick.labelsize': small,\n", + " 'figure.titlesize': large,\n", + " 'axes.titlepad': 6}\n", + "plt.rcParams.update(params)" + ] + }, + { + "cell_type": "markdown", + "id": "89e2c70d", + "metadata": { + "tags": [] + }, + "source": [ + "# H-S Equilibrium States" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "1dc792eb", + "metadata": {}, + "outputs": [], + "source": [ + "isigl=np.linspace(0.01,1,32)\n", + "ilat=np.linspace(-90,90,90)*np.pi/180.\n", + "lat,sigl= np.meshgrid(ilat,isigl)\n", + "\n", + "sigb=0.7\n", + "p0=1.e5\n", + "kappa=2./7.\n", + "ap0k=1./np.power(p0,kappa)\n", + "algpk=np.log(ap0k)" + ] + }, + { + "cell_type": "markdown", + "id": "91d718be", + "metadata": {}, + "source": [ + "Classic Held-Suarez Form:\n", + "\n", + "$$T_{eq} = p^\\kappa \\left [ T_0 - 60\\sin^2\\phi - \\frac{10}{p_0^\\kappa} \\cos^2\\phi \\log\\sigma \\right ] $$" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "36a9c149", + "metadata": {}, + "outputs": [], + "source": [ + "#Classic H-S form\n", + "tey=ap0k*(315.0 - 60.0*np.power(np.sin(lat),2))\n", + "tez=10.0*(ap0k/kappa)*np.power(np.cos(lat),2)\n", + "teq_hs=np.power(sigl*p0,kappa)*(tey - tez*(kappa*np.log(sigl*p0)+algpk))" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "06ab4e7d", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + ":1: MatplotlibDeprecationWarning: shading='flat' when X and Y have the same dimensions as C is deprecated since 3.3. Either specify the corners of the quadrilaterals with X and Y, or pass shading='auto', 'nearest' or 'gouraud', or set rcParams['pcolor.shading']. This will become an error two minor releases later.\n", + " plt.pcolormesh(lat,sigl,teq_hs,vmax=315,vmin=200)\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.pcolormesh(lat,sigl,teq_hs,vmax=315,vmin=200)\n", + "plt.gca().invert_yaxis()\n", + "plt.colorbar()" + ] + }, + { + "cell_type": "markdown", + "id": "b1bf20fa", + "metadata": {}, + "source": [ + "Zurita-Gotor et al. (2022) Form:\n", + "\n", + "$$T_{eq} = \\sigma^\\kappa T_0 \\left [ 1.0 - 0.19\\left (1-e^{-\\left(\\phi/\\phi_0\\right)^2} \\right ) + \\frac{0.1}{\\kappa}(1-\\sigma^\\kappa) \\right ]$$\n", + "\n", + "$\\phi_0$ is a free parameter ``rd_zur`` which controls the latitude of peak baroclinicity; I find $\\phi_0 = 40$ most closely reproduces the Held-Suarez $T_{eq}$." + ] + }, + { + "cell_type": "code", + "execution_count": 113, + "id": "e14fe8b4", + "metadata": {}, + "outputs": [], + "source": [ + "#Z-G 22 Form\n", + "rd_zur=40.*np.pi/180. #Parameter: 40 gets closes to traditional H-S\n", + "tey= 1.0 - 0.19*(1-np.exp(-np.power(lat/rd_zur,2)))\n", + "tmp=np.power(sigl,kappa)\n", + "tez=0.1*(1.-tmp)/kappa\n", + "teq_z=tmp*315.0*(tey+tez)" + ] + }, + { + "cell_type": "code", + "execution_count": 114, + "id": "cb4255a5", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + ":1: MatplotlibDeprecationWarning: shading='flat' when X and Y have the same dimensions as C is deprecated since 3.3. Either specify the corners of the quadrilaterals with X and Y, or pass shading='auto', 'nearest' or 'gouraud', or set rcParams['pcolor.shading']. This will become an error two minor releases later.\n", + " plt.pcolormesh(lat,sigl,teq_z,vmax=315,vmin=200)\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 114, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.pcolormesh(lat,sigl,teq_z,vmax=315,vmin=200)\n", + "plt.gca().invert_yaxis()\n", + "plt.colorbar()" + ] + }, + { + "cell_type": "code", + "execution_count": 115, + "id": "187b8697", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 115, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(ilat*180./np.pi,teq_hs[-1,:])\n", + "plt.plot(ilat*180./np.pi,teq_z[-1,:])" + ] + }, + { + "cell_type": "markdown", + "id": "d431165c", + "metadata": {}, + "source": [ + "In HS94 the temperature is relaxed back to $T_{eq}$ **implicit-in-time** using a spatially-dependent timescale.\n", + "\n", + "$$\\frac{T^{n+1} - T^n}{\\Delta t} = -k \\left(T^{n+1} - T_{eq} \\right)$$\n", + "\n", + "$$\\Rightarrow \\frac{\\partial T}{\\partial t} = \\frac{1}{\\Delta t} \\frac{k}{1+k} \\left ( T_{eq} - T^n\\right )$$\n", + "\n", + "where \n", + "\n", + "$$k = k_a + \\left(k_s - k_a\\right) \\max\\left(0,\\frac{ \\sigma - \\sigma_b}{1 - \\sigma_b}\\right) \\cos^4\\phi $$\n", + "\n", + "for $k_a = \\Delta t/ 40~\\mathrm{d}$, $k_s = \\Delta t/4~\\mathrm{d}$, and $\\sigma_b = 0.7$.\n", + "\n", + "In the Zurita-Gotor et al. (2022) tests we replace $k$ **with a uniform value** of $1/40$ d$^{-1}$, ie a 40-day damping timescale." + ] + }, + { + "cell_type": "code", + "execution_count": 132, + "id": "8808e96b", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'Relaxation timescale in days')" + ] + }, + "execution_count": 132, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "ka=1./40.\n", + "ks=1./4.\n", + "sigb=0.7\n", + "ds=(sigl-sigb)/(1.-sigb)\n", + "ds[np.where(ds<0)] = 0\n", + "k=ka + (ks-ka)*ds*np.power(np.cos(lat),4)\n", + "plt.contourf(lat,sigl,1./k,vmin=0,levels=np.linspace(4,40,11),extend='both')\n", + "plt.gca().invert_yaxis()\n", + "plt.colorbar()\n", + "plt.title(\"Relaxation timescale in days\")" + ] + }, + { + "cell_type": "code", + "execution_count": 167, + "id": "e894998c", + "metadata": {}, + "outputs": [], + "source": [ + "def HSplots(infile,dayrange,name):\n", + " daHS=xa.open_dataset(infile,decode_times=False,chunks={\"time\":1}) # xarray is confused by solo_core's NO_CALENDAR\n", + " daHS_mean=daHS.sel(time=dayrange).mean(dim=(\"lon\",\"time\"))\n", + " \n", + " #First plot\n", + " fig,ax=plt.subplots(nrows=1,ncols=1,figsize=(20,8),sharey=True)\n", + " daHS_mean.temp.plot(yincrease=False,ax=ax,vmin=200,vmax=315)\n", + " cn=daHS_mean.temp.plot.contour(ax=ax,levels=np.arange(200,321,10),colors='red',linewidths=0.5)\n", + " plt.clabel(cn,fmt='%3d')\n", + " daHS_mean.ucomp.plot.contour(yincrease=False,ax=ax,levels=np.arange(5,51,5),colors='k')\n", + " daHS_mean.sel(lat=slice(-88,88)).ucomp.plot.contour(yincrease=False,ax=ax,levels=(0,),colors='k',linewidths=3)\n", + " daHS_mean.ucomp.plot.contour(yincrease=False,ax=ax,levels=np.arange(-50,0,5),linestyles='--',colors='k');\n", + " plt.title(name+\"\\nEquilibrum $\\overline{U}$, $\\overline{T}$\")\n", + " \n", + " #Second plot\n", + " plt.figure(figsize=(20,5))\n", + " daHS_ts=daHS.sel(pfull=150,method=\"nearest\").mean(dim=\"lon\")\n", + " daHS_ts.ucomp.T.plot(vmin=-50,vmax=50,cmap=cm.get_cmap(\"RdBu_r\"))\n", + " daHS_ts.ucomp.T.plot.contour(levels=(0,),colors='k',linewidths=3)\n", + " plt.title(\"150-mb $\\overline{U}$\")\n", + "\n", + " #Third plot\n", + " plt.figure(figsize=(20,5))\n", + " daHS_eqts=daHS.sel(lat=0,method=\"nearest\").mean(dim=\"lon\")\n", + " daHS_eqts.ucomp.T.plot(vmin=-30,vmax=30,cmap=cm.get_cmap(\"RdBu_r\"),yincrease=False)\n", + " daHS_eqts.ucomp.T.plot.contour(levels=(0,),colors='k',linewidths=3,yincrease=False)\n", + " plt.title(\"Equatorial $\\overline{U}$\")\n", + "\n", + " return daHS" + ] + }, + { + "cell_type": "markdown", + "id": "a5fa221c", + "metadata": {}, + "source": [ + "# H-S Results" + ] + }, + { + "cell_type": "code", + "execution_count": 146, + "id": "9a7ed389", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "infileHS=\"/archive/lmh/SHiELD/202108/C96.L63.solo.HS/history/0000000000/atmos_30day_ave.nc\"\n", + "#daHS=xa.open_dataset(infileHS,decode_times=False,chunks={'time': 1}) \n", + "daHS_mean = HSplots(infileHS,slice(300,1400),'Control H-S')" + ] + }, + { + "cell_type": "markdown", + "id": "d46d8212", + "metadata": {}, + "source": [ + "Here's a cool trick: FV3 can write out products as a standard diagnostic. This makes it **easy** to compute time-mean eddy fluxes *without* needing to write out data every six hours or whatever:\n", + "$$ \\overline{u'v'} = \\overline{\\left(u - \\overline{u}\\right) \\left(v - \\overline{v}\\right)} = \\overline{uv} - \\left(\\overline{u}\\right) \\left(\\overline{v}\\right)$$\n", + "since $\\overline{u'} = 0$ and so $\\overline{ \\overline{u}v} = \\overline{u} \\overline{v} + \\overline{u}\\overline{v'} = \\overline{u}\\overline{v}$." + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "id": "27e2a3ba", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 52, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig,ax=plt.subplots(nrows=1,ncols=2,figsize=(35,8))\n", + "\n", + "uveddy=daHS_mean.uv - daHS_mean.ucomp*daHS_mean.vcomp\n", + "uveddy.plot.contourf(yincrease=False,ax=ax[0],levels=np.arange(-100,101,10))\n", + "\n", + "Tveddy=daHS_mean.vt - daHS_mean.temp*daHS_mean.vcomp\n", + "Tveddy.plot.contourf(yincrease=False,ax=ax[1],levels=np.arange(-30,31,2))" + ] + }, + { + "cell_type": "markdown", + "id": "39301588", + "metadata": {}, + "source": [ + "# Zurita-Gotor et al. 2022 tests\n", + "\n", + "This form starts with the parameter $\\phi_0=40$ which comes closest to the traditional Held-Suarez setup" + ] + }, + { + "cell_type": "code", + "execution_count": 198, + "id": "26999d6a", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "infileHSz40=\"/archive/lmh/SHiELD/202108/C96.L63.solo.HSzurita40.tau40/history/0000000000/atmos_30day_ave.nc\"\n", + "daHSz40_mean=HSplots(infileHSz40,slice(300,1400),'Zurita $\\phi_0 = 40$ ($\\\\tau = 40$)')" + ] + }, + { + "cell_type": "markdown", + "id": "14d3d65d", + "metadata": {}, + "source": [ + "# $\\phi_0 = 20$\n", + "\n", + "As in Zurita-Gotor et al. (2022) we see equatorial superrotation and significantly accelerated subtropical jets. We also see superrotation in the stratosphere. " + ] + }, + { + "cell_type": "code", + "execution_count": 202, + "id": "f1af3bad", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'Equatorial stratospheric $\\\\overline{U}$')" + ] + }, + "execution_count": 202, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABEsAAAGCCAYAAAAYB02gAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAACHbElEQVR4nOzdd3xkZdn/8c+Vtskm2c32zhYQpOyCLB2BpauwoIKPgA1UUJ/H8tj1sWH3ZwO7YAOVoqAii4AgsHSkd0GB7b1kd9PLzPX745zJzmZnkpnJnWSSfN+v13mdmXPuc5/7lGnX3MXcHRERERERERERiZQMdgFERERERERERIqJgiUiIiIiIiIiImkULBERERERERERSaNgiYiIiIiIiIhIGgVLRERERERERETSKFgiIiIiIiIiIpJGwRIRERERERERkTQKloiIiIiIiIiIpFGwREREREREREQkTdlgF0BEREREipeZecj83N1C5iciItIfzD3o55+IiIiIiIiIyJCmZjgiIiIiIiIiImkULBEREQHMbKmZuZmdX8x5ysAys+XxNVw02GXJRPeYiIhI/1CwRESkyJjZFfGPn1ym/x3s8vaVmZ1vZheb2UGDXZahrFjOY7GUQ/qHmV0Qv/e0mVl5L2nfEaftMLNRA1VGERGRENTBq4hI8eoAtvaSpmkgCtLPzgeOA5YDTw5iOVYCLwLbB7EMfXE+xXEei6UcI8VA37cHxfNn3b2jl7Svief/cve2/iuSiIhIeAqWiIgUrwfcfdFgF2KkcPd3DnYZRPI1CPdtKgDyRA5pD84jrYiISFFRMxwRERER6ZWZGXBg/PTxHDY5KJ4rWCIiIkOOgiUiIsOMmZWY2YfM7CkzazGzTWa2xMyOjNen+juZ0227jMvT1s9JpcmwbryZvcvM/mRmL5hZg5k1mdnzZvZ9M5ueYZvz47yOixf9plt/LMszbPNmM7s1PqY2M1ttZleZ2cHd06Zt09VBp5nNMLOfmtkr8fZPpqXL2FFmIcfWV2ZWYWYfMbMHzGxb3OfDhvia/iR1LeO0OZ/HPM5FMV/PnM9NluPew8x+aWarzKzVzJaZ2XfNbGwO12V8fPzL4vKuMbNfmNm0XrY7wMx+HW/XGpf7fjN7v2Xp96Ov923a+n3N7Odm9u/4Gm4zs2fM7IdmtrC3Y+5mHjAmftxjAMTM9gTG5pJWRESkGKkZjojIMGJmZcD1wJnxok6i9/rTgdeZ2Vv7adf/B3w87fkOoArYN57ebmYnufvTaWlagA3AeKA83qYlbf2m1AMzKwF+A6SaHCSABmAGcB5wjpl90N1/1kMZ9wauAyYCzUR9wvTXsRUsvoa3sTPo4ET9UUwAJgML4scPxutzPo9pejsXRXk9Czg33e0F/BGYBDTG28+Jj/VMMzvW3ddl2XYmcAUwm+icOTAdeC9wkpkd7O713Tcysw8CP2DnH1RNQA1wVDy91cxOc/fmLPst9L7FzD4EXAKUpu27AjggnhYAi3LNj501RZLAU72kfU3a4yfz2IeIiEhRUM0SEZHh5dNEgZIk8ElgrLuPI/pH+B/Ar/tpv2uAbxH1UVDr7mOBUcAhwN+JfpxebWaW2sDd/+DuU4EH4kUfcfepadOhafl/iuiHtQNfAMbFxzWT6IdkCfBjMzu2hzJ+D1gHHO3u1e5eA5zdH8fWR+cRBQOagXcAo+NjHUX0Q/2DpP1QzfM8pvR2Lor1euZ1bjL4LlFw5Rh3rwWqgTcCm4kCKVf2sO2PgHrgKHevJgp4nAlsIwq4fLb7BmZ2ZrxdC1EAakp8rquAU4g6Zl1EFNDIpqD71szeAvyQKFByPbBfvG01UZDn7cBjveXTTSoA8mIPwZ3uaV9x96HaabKIiIxk7q5JkyZNmopoIvr32oF2YH0v05i07aqJfgg6cHGGfEcBz8XrHZjTbX3G5Wnr56TS5Hk86fs9LsP6pfG687Nsn35c38ywvhS4N15/T4b1y+N19UQ/VrOVs8dy9MexZcnzp/E2P8vzPPe6r1zPRbFezz6cm9RxtwB7ZVh/fNr9/9os264HJmTY9uPx+lcyHEdq2zdlKddcohouHcC0UPctUc2eVfHyqwu5zln29bc4z6tySHtLnPb6UPvXpEmTJk2aBnJSzRIRkeJVDkzpZUp/Hz+FqD+BNjL8U+3R0J3f7d8i7y7e7+3x06MLyCJ1XO3AtzPknwC+Gj89xsymZsnnt+6+oYD9ZxXg2DLZEc977Aejjwo+F4N8Pft6bv7o7i9l2Odd7KwRk63WxuXuviXD8hvi+Vwzq05bvoiotstyd/9LpgzdfRnwEFFTuUVZ9lvItTqRqJZOgqiGWSgHxfNcOnfNZ9QcERGRoqNgiYhI8brb3a2XaVta+lSnmE969mrvd/dXYc3s1Wb2YzN72sx2mFnSdnYI+5E4WSGdoaaO6ynP0CdE7B6i/lnS03eXrR+LXvXjsWVySzw/08xujDtBnRAo75Rez0WRXs++npulPaxLvTay3T+PZFm+Ju1xXdrjo+L5dDNbn21iZ8BpVpb8C7lvj4jnT7n7mh5T5sjMJrHzevfWuet0omBur2lFRESKlTp4FREZPibF87U9pAnyw6k7MzsH+C1RbRiI+kzZTlTLBaL+HarjKV+p48padndvNbMtRD/QJmVJlqmj017187Htxt3vNrMvAl8EFscTZvYCUTOIy9z9P33cTY/nolivZ4Bz09P9n1qX7f5p6KGsqafpI9ukar9UsDNw0JPRWZYXct+m9reygG2zSe+wtbcASD5pRUREipJqloiISJ/E/zj/guiH4h+IOgGtdPdxHnfuyc5mQX3pBHVU30pKIt8NBvDYduHuXyUaBeWzRB2q7gBeTdQ/xvNm9s4eNs9F1nNR7NezH89NsOsXS33H+ksONcTM3S/Okk/e9y3hjwWi0XMA1vdQIyjltfF8pWcfXUhERKSoKVgiIjJ8pP6B7qlpRE/rUj/KKrOsH5tl+euJaho8D5zn7o+5e/fhTXP5Zz2b1HHNzpbAzCqJhoxNTx9Cfx9bVu6+zN2/5e6vIxqO93ii5illwE/NbHJ/7JchcD37cG56uv9TNUFC3T+pfkb2C5RfPtbH86znuABz4vnGHNKeEc/vCLh/ERGRAaVgiYjI8JHqdPEgMxuTJc1xPWy/LZ7PzLI+0xC06emfdvdk95Xx8LIn9LDf1DbZ/g1PHderzGxGljTHsrNpaS6dT+aqr8cWhLsn3H0pcDrRyCnVRDU+0vV2HnM1pK5njucmpaf7P7Uu1P2T6mtkHzPbP1CeuXooni/o4RwXqsf8zOxkdgaIfht43yIiIgNGwRIRkeEj1SRhFDs74OxiZhVETRWyeSaen5lh21HA/2bZLtWZ7AGW1nlDmguBPXvYb2qEk7os62+L05STYWQPMysFvhA/vdfd13dP0wd9Pba8xdcpm3Z21gDq3oylt/OYq6K9nn04NylvNbN5GfZ5LDs7Wr2uh33k4w529hlySXxcGZnZuED7TN/3GqLhi78TKM/n4vkEMzslU4K4Rs/P46f3x0EsERGRIUnBEhGRYcLdm9k5FOuXzOxjZlYFYGZzgL+QfcQNgD/G8wvN7II4QEL8r/jNZG/C8A/Aifo0+KGZ1cXbjTGzTwI/ATINuZqS+hH2ZjPbramPuzcB34ifftjMPmdmNfE+ZgDXEPWRkAQ+38N+CtHXYyvEb83sN2Z2qpnVphbG1/BKomZSLcC93bbr8TzmoZivZ6HnJqUduMXMjoq3KzGzxcD18frb3f3+Ho4tZ3HTpQ8RncuTgdvM7PBUAMrMysxsoZl9C3glxD677TsVGD3XzP5oZq9OrTezaWZ2oZn9MI9srwNSfZVcFW8/y8wq4vmFwGPAvDjdewMcioiIyOBxd02aNGnSVEQTcAXRD6x2or4Hepp+0G3bMuCGeHsnapZQn/b4zWnr5nTbtpyo+n76ttvjx1uIapx49NGxW5m/n7adA1uJhn514Fbga/HjKzJs+2qiUVZS+1wDLAfuS0tTSvRjOJV/Z7yPZPw8Afx3lvO5PE6zqJfzvjROd37AY8uYZy/lSL9+yfj6NXU79ncUeB5zPRdFeT37cG5Sx/1eoj43nGh0m+a0bf8DTCvk/knLY06GdReknQ8nCuZsTjuf2V5TuV6rrPcY8LH4XKb20/2Yl+b53nQiUa0g72F6GVhY6PufJk2aNGnSVCyTapaIiBSvcqKONHuadvnn3t07gbOADwNPE/0gSxANq3qcu/852848+jf6ZKJq+8uJfow2EQVvFgJP9bDtx4CLiIYJbSMK2jxJ1HTntLgc2bZ9Id7vrUTBmalEHVPOTEuTcPd3AWcTNePYRtQJ6TqimgiHuftPs+2jL/pybAX6DPApovPxCtHQs6VEP0J/Axzs7r/LUM5ez2Ouivh6FnRu0rxE1J/Jr+OylRLd698DDvF+GLnF3X8D7ANcSlTrppPodbsFuAv4BDs7Tw297+8TDeP7G6LjLAdaid4bfgB8NM/87gDmx9u+QBT4aScarvxmoiZaB7j7Y2GOQEREZPCYuw92GUREZACZWeqNf667Lx/MsogMBDNbThSwOd7Vj4aIiIjkQDVLRERERERERETSKFgiIiIiIiIiIpJGwRIRERERERERkTQKloiIiIiIiIiIpFEHryIiIiIiIiIiaVSzREREREREREQkjYIlIiIiIiIiIiJpyga7AMVi4vhxPmfm9CB5ddZvDpIPQMvWpmB5ASTaE8HyCt2AKxGwSVipWbi8SsLlBRCy5Vt7MhkuMyARsGzF3MLPA969ycDHGTK70JcgaHQ94Msq9L1WzNcgpNKwb21BhbymoQ8z5EdC0HfwIn4dlAX8TIbivneLVdhvC2E/+4r5ciYCvhJCf1aFPG8hvzdD2PePZOA3tw3evtndJwXNtIjMsipvzfMVv5n2v7v76/qpSEOagiWxOTOn88+/XRskry1/+GWQfACev/bhYHkB7FjTECyvlkTYj97GznD51ZSF+1k3tnZUsLwgbMBqTWN7sLwAtneEuwbtoaMIAbUGDDK1hIwwEfa8hQxAAlSVhntdhfyxE/peC3sNgmUV3NiA75OhhbwGoX8EVAW8eYv5XgtZtokVpcHyAhhbHi6/kO9Fxfx6D/2drTXg/VG870TQFPC8hf6sCvneNibw50HIuy30vfvtjmUrgmZYZFpJchbT8trmMlZM7KfiDHkKloiIiIiIiIgMcUYBQeAiDvQONgVLRERERERERIa4KFiSZ7REwZKsRnywxMwWA4v3nD1rsIsiIiIiIiIiUjD16xRO1mCJmR0bIP/l7r4yQD79xt2XAEsOWbD/hYNdFhEREREREZFCFFSzRLLqqWbJUvpeKefLwFf6mIeIiIiIiIiI9MRUsySk3prh3B1P+TLgiwVsJyIiIiIiIiJ5Us2SsHoLlix194JqhpiZgiUiIiIiIiIiA6Cg0XAkq56CJc8BG/uQd1+3FxEREREREZGcmGqWBJQ1WOLu8/uScV+3FxEREREREZHcGFAy2IUYRkb80MEiIiIiIiIiw4FqloRTcLDEzMYAY4Ht7r4jXJEGlpktBhbvOXvWYBdFREREREREpCCm0XCCyquWjplVmNnnzOxloB5YDtSb2cvx8or+KGR/cvcl7n5R3ZjawS6KiIiIiIiISMFKzfKaJLuca5aYWS1wB7AQcGAlsB6YCswGvgKcYWYnuntjP5RVRERERERERDLQaDhh5VOz5MvAIcBfgFe5+1x3P9Ld5wKvAm4ADo3TiYiIiIiIiMgAiYIlqlkSSj7BkrcAT7r72e6+LH1F/Pxs4CngvwKWT0RERERERERyUGr5TZJdPsGSicDfs610d4/XT+hroUREREREREQkd1EHr6pZEko+wZLlQF0vacbG6UREREREREREhqR8giW/AP7LzGZmWmlmewBvjdOJiIiIiIiIyABSM5xwso6GEwc/0v0ZOBZ43MwuBe4BNgBTgOOAjwB3E3UAO2SY2WJg8Z6zZw12UUREREREREQKotFwwupp6ODlREMEd2fAV7MsPxNY3Eu+RcXdlwBLDlmw/4WDXRYRERERERGRQhgD0w+Jmd0KnAp83d0/n7Z8HPAd4I1AFfAg8FF3f6bfC9UPegpq/JbMwRIRERERERERKTL9XbPEzM4FDsyw3IAbgbnAh4B64LPAXWZ2kLuv7t+ShZc1WOLu5w9gOURERERERESkQKnRcPovf6sDLgE+ClzdbfUZwGuBE9z9rjj9g8Ay4FPAh/utYP0knw5eRURERERERKQIpfos6ccOXr8NPOfu12RYdwawNhUoAXD37cASou46hpwh07eIiIiIiIiIiGTXXzVLzOy1wDvJ0AQntj/wbIblzwHvNLMad2/sl8L1k7yCJWY2GngPcBAwEyjPkMzd/cS+F60wZrYncCUwGWgCLnT3RwerPCIiIiIiIiL9rb9GwzGzcuAy4Lvu/mKWZOOJBonpbms8HwcMz2CJmS0AbgMmEV2HbAa7U9ifA1e4+y/N7GTgKjN7tbtnLJeGDhYREREREZHhoICaJRPNLL1yweXufnm3NJ8mGt3m6z3kY2QfTXdIyqfPkkuJAiVfAuYA5e5ekmEqzacAZjbTzH5kZg+aWbOZuZnNyZJ2lpldb2bbzWyHmf3ZzPZIWz8JOIKoZgnufnu8amG2/bv7Ene/qG5MbT7FFhERERERESkaZlBiltcEbHb3Q9Kmy3fN0/YAPgd8ARhlZnVxR6+kPS8lqkEyPkOxxsXz+n456H6UT7DkCOBP7v41d1/p7olAZdgL+C+ik3dvtkRxE6A7gVcD7wLeAbyKaCii6jjZHkSdynSkbboiXi4iIiIiIiIyTBlWmt+Ug3lAJfB7ot/sqQngE/Hj+UR9k+yfYfv9gJVDrb8SyK/PkkaiwENo97j7FAAzey9wSpZ0FxJdqH3c/aU4/dPAf4D3Ad/Pst2QrfYjIiIiIiIikhODkvCdljwJHJ9h+V1EAZRfAS8BNwIXmNlx7n43gJmNARaz+zDDQ0I+wZI7gcNDF8DdkzkmPQN4KBUoibddZmb3Ew1F9H1gJTDdzMrTapfMjpeLiIiIiIiIDEsGWGk+jUd65+7bgKW77StqwrPC3ZfGz28EHgR+b2afJKpx8tm4WN8OWqgBks+Z/D9gXzP7jFk/jUfUs56GItoPwN03AQ8D5wPEHbwa8NjAFFFERERERERkEBj90QwnJ3EliNOB24GfAn8BEsDx7r4q2I4GUM41S9z9lXhs5QeAC83sSWB75qT+nkDlSzeezJ3CbGVnpzEA7weujKNZzcDbehgJ5yLgIoA9ZkwLW1oRERERERGRgWLWH81wMnL33Xbk7luBd8fTkJfP0MEzgb8SBSbGAXOzJHWgP4Ilqbx3K9ouCdz/AxyVU2ZRT7+XAxyyYP/BHvJYREREREREpGBWErYZzkiWT58llwJ7A78mGpp3LdDZD2XKpp7sQxENuWGIRERERERERKQ45RMsOQH4u7u/t78K04uehiJ6foDLIiIiIiIiIlI0rH9Gwxmx8qmjUwI8018FycGNwBFmNi+1wMzmAEfH60RERERERERGrMHq4HU4yqdmyUPAAf1RCDM7O364MJ6/3sw2AZtSYzQDvwA+CPzVzD5P1H/JV4FVwGX9US4RERERERGRIcEs+NDBI1k+wZLPAfea2Tnufm3gclzX7flP4/ndwCIAd28ysxOAS4DfEXXsegfwv+7eGLg8IiIiIiIiIkOGoWY4IeUTLDkNuBO4yszeDzxG9qGDv5pPITINO5Ql3UrgrHzyFhERERERERn2DKxEwZJQ8gmWXJz2+Nh4yiTVPEZEREREREREBoRRomY4weQTLDm+30ohIiIiIiIiIoUz1GlrQDkHS9I6WhURERERERGRImIKlgSVT80SERERERERESlSaoYTjoIlIiIiIiIiIkOdmWqWBJQ17GRmzWb22UIz7uv2IiIiIiIiIpIbA0pKLK9JsuupZkklUN6HvPu6vYiIiIiIiIjkwsDUDCeY3prhvNHM5hSYtxe4nYiIiIiIiIjkqUTNcILpLVhyUDyJiIiIiIiISLFSnyVB9RQsmRsg/20B8hgQXlJKompckLzGHnRQkHwAZq3aECwvgIbV9cHySrQng+UF0NnaGSyviupwLcDKA+YFkOgId97q1jYGywugvak9WF6h7w9PhsuvsyXcvRb6OFsT4fJLeNgKfhVF2q41EbgeY0vQaxAsKwBCfv8ZW14aLK/Q91p7Mlx+pRb2vg35Ogh53kLfayGvwdjKsOMJVNSE+1y2knDV1UN+ToUW8nMPoKMtESyv0rLibTLQ3hHuOEO+pkKrGRX2NeoB35BCfi8CYGPY7IqNqRlOUFlfGe6+YiALIiKSTTF/ARURERERKRZqhhOOwk4iIiIiIiIiImnC1rkSERERERERkYFnYEXabHooUrBEREREREREZIgzjBL1WRKMgiUiIiIiIiIiQ52h0XACUrBEREREREREZKjTaDhBKVgiIiIiIiIiMuRZ0CHRRzoFS0RERERERESGODPUZ0lACpaIiIiIiIiIDHmmZjgBZQ2WmNkrBebp7r5ngduKiIiIiIiISL7UZ0lQPdUsKQG8gDzV/a6IiIiIiIjIgFKfJSFlDZa4+5wBLIeIiIiIiIiIFMrASksHuxTDhvosERERERERERniTH2WBFVwsMTMxgE17r4qYHlEREREREREJF8GJWqGE0xeZ9LMaszse2a2HtgMLEtbd7iZ3WxmB4cupIiIiIiIiIj0zEpL8poku5xrlpjZWOA+YH/gSaJgyb5pSZ4BjgHOBR4PV0QRERERERER6ZGpGU5I+ZzJzxEFSs5394OB69JXunszcDdwYrjiiYiIiIiIiEhvDLCSkrwmyS6fPkveDPzd3X/bQ5oVwKF9K5KIiIiIiIiI5EU1S4LK50zOBJ7uJU0jMLbw4oiIiIiIiIiIDK58apY0AJN7STOXqC8TERERERERERkohmqWBJRPsOQR4HQzq3X3hu4rzWwa8AbgplCFExEREREREZHclChYEkw+Z/IHwATgZjNLHwWH+Pl1QCXww3DF639mttjMLt++Y8dgF0VERERERESkIGamDl4Dyrlmibv/3cwuBi4GngU6AMxsMzCOqPPdT7v7A+GL2X/cfQmwZOFBCy4c7LKIiIiIiIiIFErNcMLJ60y6+1eIhga+EagHEoADNwMnuft3gpdQRERERERERHoWj4aTzyTZ5dNnCQDufhdwVz+URUREREREREQKFLppjZmdDZwLHEI04MtK4M/AN9L7MjWzccB3gDcCVcCDwEfd/ZmgBRpAOZ9JM6vrx3KIiIiIiIiISIHMjJLS0rymHHyCqEXJ/wGvA34GfAC43cxK4v0aUeuT1wEfAs4CyoG7zGxm+CMdGPnULFlnZjcCVwK3unuyn8o0OErKSFZPCJPVIacFyQeg9PalwfICGLNHmGME8GTYW6CkvDxYXonWtmB5eSLscYas7lZemXflsAGT6EgEza+9sSNofqGEvj/am8IdZ2drZ7C8AJIJD5pfKMn2sPdayHs30V68H5VWaoNdhKwqA17TYr4GJRbuGpR62NdnyNujPfDnQWJbuGsa8hqElgx4TROB74+QHwelge+PkIr0Yy+4xraw3xdCGinXIKR+aFqz2N03pT2/28y2EsUFFgF3AmcArwVOiFuiYGYPAsuATwEfDl2ogZDPmVwOvAVYAqwxs++Y2fx+KZWISJpiDZSIiIiIiBQNI3ifJd0CJSmPxPMZ8fwMYG0qUBJvt50odnBmH49q0OQcLHH3fYHDgZ8TVan5OPCkmT1mZh82s4n9VEYRERERERER6dGADR18XDz/Vzzfn2jE3O6eA/Yws5pCdzSY8h0N5xF3/x9gGlEtk78B84FLiWqb3GBmbwxdSBERERERERHJzvqhZsnu+7AZwFeAf7j7o/Hi8USj5Xa3NZ6PK+iABllBHR64ewfwJ+BPcY2StwPvIKp+c3qh+YqIiIiIiIhIAeKhg/M00cweTXt+ubtfnjl7qwH+CnQCF6SvAjL1MFO8HUPlIERQYwtR9Zp/AQcEylNERERERERE8lBA05rN7n5Ir/maVRKNeDMPOM7dV6et3kpUu6S7VI2STLVOil7BgQ0zezXwLqJaJdOJokYvEfWKKyIiIiIiIiIDxQwryWk44DyztXKiliWHASe5+zPdkjwHnJJh0/2Ale7eGLxQAyCvYImZjQPOJQqSHEIUINkB/Aq4wt0fCF5CEREREREREeld4GCJmZUAVwEnAqe5+0MZkt0IXGBmx7n73fF2Y4DFwNVBCzSAcg6WmNn1RP2RlBO1R/oHcAXwF3dv7ZfSiYiIiIiIiEgODAof4SabnxAN7vJ1oMnMjkhbtzpujnMj8CDwezP7JFGzm89GBeLboQs0UPKpWfJm4EWiZja/c/c1/VMkEREREREREcmLgZUGb4bz+nj+uXhK92XgYndPmtnpwHeBnwKVRMGT4919VegCDZR8giVHZalyIyIiIiIiIiLDjLvPyTHdVuDd8TQs5BwsUaBEREREREREpFhZ8D5LRrK8R8Mxs8XA24B9gWp33ytevi9RBy5XqYmOiIiIiIiIyAAyFCwJKJ8OXo2oQ9e3x4tagKq0JPXAN4gu0f8LVD4RERERERER6YVhWPgOXkesfM7kfwPvAH4DjCfqvKWLu68H7gdOC1Y6EREREREREeldqmZJPpNklU8znPcATwEXurubmWdI8x/g1CAlExEREREREZEcqc+SkPIJluwDXObumYIkKRuBSX0rkoiIiIiIiIjkS81wwsknWNJJNF5yT2YAjYUXR0RERERERETyZqpZElI+wZLngUVmZplql5hZJXAC8ESowg2EeHSfxfPmzRvsooiIiIiIiIgUSMGSkPKpo/M74NXAJWa2y3ZmVgp8H5hONGLOkOHuS9z9orqxYwe7KCIiIiIiIiKFMbDS0rwmyS6fmiWXAWcAHwbeAjQAmNn1wBFEgZK/uvtVoQspIiIiIiIiIj0xUJ8lweQcLHH3hJmdDnwe+B9g73jVm4FtwFfjacTz8qpgeZVVVgTLC2DU1PHB8iqvDnecAOW1o4PllezoDJZXorU9WF4AFePqguWVaGkOlhdA2ZjirWGVaGoIl1fAa9rR1BIsL4C2+nDdPrVtC3fOovzClS3RngiWV2t9a7C8ADpaw71/dLaEywvAkz31sZ6fZCJgXgGvJ0BH0NzCCnneEp3JcHn12P9+IfmFzCts2SB0fmGEPGdRfgHvteI8ZUUv/L1bnIr5/ijmshWl1NDBEkQ+NUtw907gYjP7MlGwZAKwHXjB3cN+UxIRiYUMlIiIiIiIDE+GKVgSTF7BkpS4g9cXA5dFRERERERERAqlZjjBFBQsEREREREREZEiYqpZElLWYImZ3Vlgnu7uJxa4rYiIiIiIiIjkTUMHh9RTzZJFBeapbnhEREREREREBpKhZjgBZQ2WuLvOsoiIiIiIiIiMOOqzRERERERERGSIMwwrVTMcMysH9gXGEo3e+y9378g3HwVLRERERERERIY6Y0T3WWJmE4BvAecBlWmrWs3sauCz7r451/wULBEREREREREZ8kZuB69mNgW4H5hHVJvkYWA9MBU4CHgPcLyZHe3uG3LJU/2SiIiIiIiIiAwDVlKS1zSMfIMoUHIpMNvdj3f3c939eGA28IN4/ddzzVA1S0RERERERESGOhu5NUuA04F73f1j3Ve4+w7go2Z2CLA41wyHVShJREREREREZMSykvym4aMWuK+XNPcCNblmOOJrlpjZYmDxvHnzBrsoIiIiIiIiIgWy4RYAyccLwLRe0kwDXsw1wxF7JlPcfYm7X1Q3duxgF0VERERERESkYG4leU3DyA+At5rZgkwrzewg4L+I+jTJSd41S8xsEnAW0bjF1e7+3rTlc4Fn3L0l33xFREREREREpEDGSK5Zsgy4HXjYzH4L3ANsAKYAxwHvAG4BlpvZsekbuvs9mTLMK1hiZu8Bfkg0ZrEBDrw3Xj0FeBC4CPhVPvmKiIiIiIiISF9Y1MnryLSUKD5hRDGK96StS52UM+Kpu4y94uYcLDGzk4HLgaeBLwGnAu9PrXf3Z83sOeCNjPBgScjqTLV7TAmWF8CoWXOD5VU2aUawvABsfG9NzPIQchiszo5weUHYHqqb6sPlBVhZebC8kk0NwfIqB5KN24Lll9i+JVhe5U07guUFUFY5KlheJRVhu6UqqQh3f3Q2FW8FxLLWzmB5tVeEff/whAfLK9GeCJZXZ2nYL2bJgMdZErhsifZk0PyC6QxdrnDXYOd31DASHrJsUghdg/wFfFsLrrjLVsSFK1bDazjgfHyFsB9eedUs+TSwDjjO3XeY2WsypHkaODJIyUREYiEDJSIiIiIiw5ET9o/7ocTdLw6dZz7BkkOAa+MxirNZDUztW5FEREREREREJC82okfDCS6fYEkF0NRLmjogXL1eEREREREREcmNgiXB5BMsWQ4s7CXN4eQxbrGIiIiIiIiIhDCya5aY2Uzgo8BBwEyirg+7c3ffM5f88jmTfwWOMbO3ZCnYBcAC4E955CkiIiIiIiIiAbiV5DUNF2a2CPg3UbDkGGA08WDK3aacDzqfmiXfBs4BrjGzs4GxcaE+GBfmzcB/gB/lkaeIiIiIiIiISF98m2gI4HcCV7t7n4eJyzlY4u71cbTmSiC9dskP4/m9wHnu3lu/JiIiIiIiIiIS2jCqLZKn+cA17v77UBnmU7MEd18BLDKzBURDBE8AtgMPuftjoQolIiIiIiIiInkwi6aRqR7YGjLDnIMlZnYncL+7f8HdnwaeDlmQwWJmi4HF8+bNG+yiiIiIiIiIiBRu5NYsuQk4LmSG+ZzJI4jaAA0r7r7E3S+qGzt2sIsiIiIiIiIiUrCR2sEr8H/AWDP7iZlVh8gwn2Y4/wFmhdipiIiIiIiIiIRkUDKsAiA5c/fNZvY64J/AO83s30RdhmRI6ifmkmc+wZJfAl82sz3cfWUe24mIiIiIiIhIfzJGbDMcM9sfuAsYFy96TZaknmue+QRLlgAnA/eb2f8DHgHWZ9qZgikiIiIiIiIiA8lGbLAE+D7RADRfJBrBd627J/qSYT7BkleIAiMG/KCHdJ5nvsOO9X1I5y6V53ya5O2/DJZf2ZRwLamsbkqwvAC8YnSwvKy1IVheAL5tY7C8Etu3BMsrGbBcAN7WGiyvjsawo4h3NLUEyyvR2h4sr46mcOcMINneGSyvjuZw5wygsyXceUt2hDtOT+b8B0Fu+SXC5jcSlFWW0dka7pqWVoT7opcId9sCYKXh7o+S0nAjFpSUlpJoD/f9I+HhjjPgYcaKc6SHUgt73kIeZ9hyhVU6YkbuCHsNQn5UhX6Nhi3bSLk/Ahq5wZIjgT+7+9dCZZhPUOO3hH6VS69CBkqkMCEDJVKYkIESEQkvZKBEChMyUCKFKeaAhIiMHP3RaauZzQIuIWppYsA/gP8tshYl7cDykBnmHCxx9/ND7lhEREREREREArHwzXDMbDRwJ9AGvIuoAsXXgLvMbIG7h61OXrilwGEhMxyxdXREREREREREhhWz/KbeXQjMA97o7je4+1+BM4DZwPv68Ujy9SlgPzP7jFmY9lsjum8RERERERERkeGhXzp4PQN4yN1fSi1w92Vmdj9wJlHHqsXg88CzwNeBC83sSbIPHfyeXDLMOVhiZr/OMWnOOy8GZrYYWDxv3rzBLoqIiIiIiIhIwfqhz5L9gb9mWP4c8JbQO+uD89Mez42nTBwIGyzptvNsO7V8dl4M3H0JsGThwQdfONhlERERERERESlY+GDJeKA+w/KtwLjQO+uDbMGRguUTLMm28zrgUOALwAPAZ/pYJhERERERERHJg5vh+XfXMdHMHk17frm7X9496wzbFdW4zu6+InSe+YyGk23nK4CnzOzvwNNEwwj9KkDZRERERERERCQXDgWMYr7Z3Q/pYX09Ue2S7saRucbJsBGsjo67rwKWAB8JlaeIiIiIiIiIDJrniPot6W4/4PkBLkuvzOwIM/ulmT1mZi+b2eNm9gszOyrfvEI3aNoAvCpwniIiIiIiIiLSIyfp+U05uBE4wsy6RkQxsznA0fG6omFmXwPuB94NvIaoK5GDiPpUvdfMvpFPfsGCJWZWCpxA5uF5RERERERERKQfeZ5TDn4BLAf+amZnmtkZRKPjrAIuC1r4PjCztwD/B6wE3gvMA6ri+Xvj5Z82s//KNc98hg4+toc8ZgEXEEVtfplrniIiIiIiIiLSdw4k8++zpOc83ZvM7ATgEuB3RB273gH8r7s3ht1bn3yIqKXLoe6+OW35cuDXZnYj8CzwP8Afc8kwn9FwltJz8MmAe4BP5pGniIiIiIiIiATgBfTwmkOeK4Gzgmcc1oHAb7sFSrq4+2Yzuw54Z64Z5hMs+QqZgyVJol5wH3b3h/PIryiY2WJg8bx583pNOxiSLU1B80vUbwqXWci8AG9vDZZXsiFcx8yJprAB07ZtDcHyat2yI1heAMn2zmB5JTrC5QWQ7OgIlldnS3uwvJKBj9MT4T7gEh2JYHkBJAOWzRPJYHkl2sPlBWHPW8jrCZAMeN5Cly2kkGUrKQ07sqEnw+XnpeG6jiutCJZVJNzbZK5t4vMQLr/S/IfYzCr0S6o94N/DFSWhR/gsqhFDh4Qifsst6rJJfvqjZskQUgY095KmmTxiIPkMHXxxrmmHEndfAixZePDBFw52WUQks5CBEhERERGR4Wrkxkp4CTjdzD7r7rv9u2RmJcAbgJdzzTD0aDgiIiIiIiIiMtA8qlmSzzSMXAPsS9QR7S4j9JrZnsD1RMMdX51rhvl08DoOmAa87O5tacsvAN4INAGXDsWmOCIiIiIiIiJDXX/0WTJEfB94HXAa8HozWwusA6YCM4gqitwXp8tJPn2WfAN4OzA5tcDMPgRcys6Gi280s0Pc/fk88hURERERERGRPnCiDkVHIndvN7OTgU8A7wb2BGbGq18Gfg18191zbt+fTzOco4E73L0lbdkngDXAsUBqvOKP5ZGniIiIiIiIiATgnt80nLh7h7t/091fBYwBZgFj3P1V8fK8OkLMp2bJDKLxlAEws/3inX/a3e+Ll72FKHAiIiIiIiIiIgNomPVDUjB3bwT6NKxpPjVLqoD0sV2PJqrp84+0ZS8TBVVEREREREREZIBEtUU8r2m4MLOFZvZFM5uSZf3UeP1BueaZT7BkDfDqtOenAjuAp9KWjQPSm+kUPTNbbGaXb9u+fbCLIiIiIiIiIlKwZJ7TMPJx4L3AxizrNwDvIY9uQ/IJltwFvMHMPmhm7wXOAG7tNobxXsCqPPIcdO6+xN0vqhs7drCLIiIiIiIiIlKwEdxnyZHAXZ6luky8/E6iFjI5yafPkm8CZwE/IBr9phG4OLXSzCYDxwG/yCNPEREREREREekjB5LDLAKSh6nA6l7SrAWm5ZphzsESd19mZvsDZ8eLbnT3lWlJZgM/Aa7ONU8RERERERERCWPEhkqgGZjUS5pJQFuuGeZTswR3Xw/8OMu6R4BH8slPelf/woqg+dU2t/aeaJAk2zuD5dXe0BQurx3NwfKC4i6blebTMq+XvErC5QWQaM1rpK8eJRPF20LTA3ZhnkyM4I/LIlHM91pIpeWlQfMLee964GtgiXDvbaUVwbIiv5bVvbPScOct9DUoLdL3tpLg5Qp33or0lAFQaqHzC5dhIuA/9AkPfKAi0t2TwJlm9rF4JJxdmNkY4Mw4XU76/MlqZhPN7E1mdqqZhf22VFh5/s/MXjSzpJm9cbDLIyJ9FzJQIiIiIiIyXCU9v2kYuZyo5sjtZrYgfYWZHQjcBkyM0+Uk52CJmX3AzP5pZuPTli0E/gVcD9wMPGBm1bnm2U/uAN4A3JNLYo2GIyIiIiIiIsPBSO3g1d3/APwWOBx4wszWmtkjZrYWeBw4DPitu1+Ta5751Cx5a1QG35q27DtEwwX/hihYcijw/jzyxMxmmtmPzOxBM2s2MzezOVnSzjKz681su5ntMLM/m9ke6Wnc/Z/u/nKu+9doOCIiIiIiIjLUOU4yz2k4cffzieIRzxN1+Lownj8HXOTuF+STXz7BklcBT6eemNlEotFvfuXu73X3xUR9lpyXTwGIhhv+L6AeuDdbIjMbTTTUz6uBdwHviMt0VxHUZhEREREREREZPHnWKhlONUtS3P1yd58P1AAzgRp3X+Duv8w3r3w6eJ0AbEx7nhqf+C9py+4Fzs+zDPe4+xQAM3svcEqWdBcC84B93P2lOP3TwH+A9wHfz3O/IiIiIiIiIsPGMOuHpGDu3kw0Qk7B8gmWbCXqECXlOKJuuh9ILxNQmU8B3D3Xrr7PAB5KBUribZeZ2f1EvdoqWCIiIiIiIiIjkjM8a4vkwsxeyTGpu/ueuSTMpxnOv4DFZjbBzOqI+jB5xN13pKWZA6zPI8987A88m2H5c8B+/bRPERERERERkSFhBPdZUgJYhqmOKE4xB6ggjxhIPjVLfgDcAKwGOoHRwKdTK+Nhg1/LrjVNQhpP1K9Jd1uJOplNlePzRJ26TAIOMLMfA4e4+25BHDO7CLgIYNasWf1RZhEREREREZEBMVJrlrj7nGzrzGwv4IdANXBqrnnmHFVx9xuJghDPAS8Cn3D336clOYmoCc7fc82zAJkuve2SwP1r7j7T3Ue5+8T4ccbaLnHnL4e4+yGTJk7MlERERERERESk6DmQdM9rGgnirjzeDMwAvpTrdvnULMHdLwcuz7Lu76TV8OgH9US1S7obR+YaJyIiIiIiIiIjg0Mi1x5BRxh3bzWz24Fzgc/msk1ewZJB9hxRvyXd7Uc0jvKw1LhmU9D8KieMCZaXleTT5c3AaqtvDJZX86awsbjS8nAvOysNew3Kq/Pqn3nAlFVVBM2vmO/dkDqaWge7CFklOzqD5ZVoTwTLC6CjqSNYXqXlpcHyAvCQ34CK8+UOQElFuNdoZ0u4ey3OMWBe4Y4z9OdBWWW4e80TYf+5TAbML9ER7v0j9HFawPe24GUrtd4T5agkYF4Q9rUQ9D1XZACkapZIVp3A1FwT5/1uYmaLzexaM3vKzF5KW76vmX3KzGbkm2eObgSOMLN5afucQzSE8Y39tE8RERERERGRIcBJeH7TSGFmE4E3Aaty3Sbnv7jNzIArgLfHi1qAqrQk9cA3iPoQ+X+55hvnfXb8cGE8f72ZbQI2ufvd8bJfAB8E/hp34urAV4kO9rJ89iciIiIiIiIynIzkmiVm9sUsq8qAWcCZwFhybIKT2jBX/w28A/g18HHgo8AXUivdfb2Z3Q+cRp7BEuC6bs9/Gs/vBhbF+TeZ2QnAJcDviIIydwD/6+7h2lyIiIiIiIiIDDUju8+Si3tZvwP4mrt/O9cM8wmWvAd4CrjQ3d3MMoWs/kMeQ/GkuHtOjRXdfSVwVr75i4iIiIiIiAxnI7lmCXB8luVJolYwL7h7Xh2P5RMs2Qe4zL3Hs78RmJRPAURERERERESk70ZSPyTp0rrvCCafYEknvfedPwNQkxgRERERERGRARTVLBnsUgwf+YyG8zywKO7odTdmVgmcADwRomAiIiIiIiIiIoMhn2DJ74BXA5eY2S7bmVkp8H1gOtGIOSIiIiIiIiIyUBwSSc9rkuzyaYZzGXAG8GHgLUADgJldDxxBFCj5q7tfFbqQIiIiIiIiIpKd4yO5g9fgcg6WuHvCzE4HPg/8D7B3vOrNwDbgq/E04rnlU2GnZ7WzpgTLC6B6j5nhMispDZdXYJ4MN2ZWMmBeANVTxwfNL6TKCWOD5ZXsyKuz6V55wHHQSsrziRP3zErDvd4BOptag+XV3tAULK/QOgIeZ8i8ANq2NQTLK+R9G+UX7guQleY0EF1OQpYLoL2pPVhebaXh8gIoCfiaL6kIl1d5Zbj3NYBkwH8bE+2JYHlB2PutszXsZ1XIYw1dtpCsJNy9WxrwdRBasb7nQnGXLeR3o2Tg94+RIPBH8oiW1ydrPNTOxWb2ZaJgyQRgO9EwPLqTRaRfhP7BKSIiElrooJCISL5G+NDBweUcLDGzBPAHdz8vHj74xf4rloiIiIiIiIjkLO6zRMLIp2ZJA7CivwoiIiIiIiIiIoVRzZKw8gmWPAHs118FEREREREREZHCqc+ScPLpfef/AW8ws5P7qzAiIiIiIiIikr9UzZJ8Jskun5olk4FbgVvM7AbgEWA90TXZhbv/NkjpRERERERERKR37kFHMxvp8gmWXEEUGDGi4YLfHC9PvxoWP1ewRERERERERGSAOGqGE1I+wZIL+q0UIiIiIiIiItInaloTTs7BEne/sj8LIiIiIiIiIiKFiWqWDH6wxMz2Bv4HOB6YRzSy7iPAF9z9qQzpLwQ+DswFlgOXuPvPB6zAWeRTs0RyZJ4Mltf4A18dLC+Air0WBMvLqmqD5QXgpRXB8qqYtyVYXjVrlwfLC6BsyqxgeXl7a7C8AErHTQ6Wl3d2BMsLwFuawmWWTATLygPmBZDcHu7erWxtDpYXEPa8Bbye7dsbguUF0LyxPmh+I0GitT1ofh1NLcHyat64PVheAB6wLXhFbWWwvMqrw+UFkOzoDJZXR1PYz6pEe9j33ZDadoR7LXS2hrsGyUS476YA5ZXhfkIUc/8KHrA9g5VasLxCKykp3rJ1BHwdjAheNK+pU4gCJVcCjwN1wKeAf5rZ0e7+WCphHCi5DPgm8A/gROCnZmbu/rOBLni6vN/pzKwGeBPwGmAssJ1oWOG/uHtj2OKJiAQOlIiIiPSDkIESEZFCFFGfJdcCP3HfWc3FzO4kqjXyEeCd8bIy4OvA79z9c3HSu8xsOvBVM/ulu4f9BzYPeQVLzOwtwM+JIkPpIUgHLjWz97n79eGKJyIiIiIiIiK5KIY+S9x9c4Zl283s38CMtMVHApOA33dL/juiPlNfC9zVX+XsTc7BEjM7GbgGSBKNdrOUaOjgqURVbM4DrjGzbe7+j/BFFREREREREZFMHC+KPksyMbPxwAHAb9IW7x/Pn+2W/Ll4vh9DIVgCfBFoA45x98e7rbvSzH4M3BOnU7BEREREREREpLhNNLNH055f7u6X98N+fkTUOuXStGXj43n3DuO2dls/KPIJlrwG+EOGQAkA7v6omf0RODtIyUREREREREQkNw6J/Dt43ezuh/SUwMxOAm7PIa+73X1Rhu0/S9QS5T3u/lL6qnhelNVh8gmWtAHrekmzNk4nIiIiIiIiIgPEKShYkosHgH1zSLfbUIxm9n7gG8Dn3f3X3Van1yBJjzWM77Z+UOQTLLmXqIOVnhxN1BRHRERERERERAaIF1azJId8vRl4Id/tzOwdwE+B77n71zMkSfVNsj+7Bkv2i+fP57vPkErySPtpYL6ZfcvMqtNXmFm1mX2bqMOWz4QsoIiIiIiIiIj0LpH0vKb+YmZvIurM9Zfu/oksyR4ENgNv67b87US1Su7vtwLmIJ+aJZ8GngY+CVxkZo8DG4ApwMHAWKJaJZ82Sx9VGHf394QproiIiIiIiIh05/RvACRXZnYs0Ui6TwNXmNkRaavb3P0JAHfvMLMvAD81szVEA8WcALwb+JC7tw9w0XeRT7Dk/LTHdUQH0d1x8ZTOAQVLClQ+d//eE+XBx00Plldi9LhgeQF4RXXviXLNa/KrguVVOiVcXgBJy6dCV89K2puC5QWQKK0IlpclAr63jQHraA2XX8Ah1UqSncHyAiipDfe68raWYHkB0NkRLCtPJoLlVdrUECwvgFGTN4bLrKQ0XF6hBbwGyZaw70WdzeFe77U7wpbNSsO9h5dXVwXLq7Qy3Ps3QLI93Htbe0PYaxCybCGvZ/uO3Zrq90miNdznaEdz2M+D8tHh7t1ER9jP0WRHwM+qRDJYXqGFLFtJRT4/CXsXsmwdTQG//40E/dQMpwAnAKOIBonpXjtkBTAn9cTdf25mDnycqGLGSuCD7v7TgSlqdvm8Mub2WylERHoQNFAiIiIiIjIM9WMHr/mVw/1i4OI80l8GXNZf5SlUzsESd1/RnwURERERERERkcL0VwevI1XYOlciIiIiIiIiMigULAlHwRIRERERERGRIa5YOngdLhQsERERERERERni3KFTwZJgFCwRERERERERGQZUsyScER8sMbPFwOJ58+YNdlFERERERERECqIOXsMKN7j8EOXuS9z9orqxYwe7KCIiIiIiIiIFS7jnNUl2I75mSbGzuilB8/OSgJfcAsfaEh3BsipJtAfLi2QiXF5ASUdDuLzaW4LlFZwnB7sEWYV8HQR9TQGMqg6WVUlFVbC8QvOA7x8lE4NlBYBNnxMus5LScHlB2PfdgO+53hkuLyDo+653hC2blZeHyyz0/RGQd4T7HK1qbw2WF4AV83kL+FrwgOetc+PqYHkBlFSF+6zyZODvC53h7t1EU7jvbMn2zmB5QdjzVlIe9ruMlYb7rOrY0RwsLwCuWBI2vyKjDl7DUrBERERERKSPggcNRUTypGY4YWUNlpjZnQXm6e5+YoHbioiIiIiIiIgMqp5qliwqME+FskREREREREQGmGqWhJM1WOLuI77zVxEREREREZGhwIFE6H6ARjD1WSIiIiIiIiIy1Lk6eA1JwRIRERERERGRIS6qWaJgSSg9dfB6bKGZuvs9hW4rIiIiIiIiIvlxh04FS4LpqWbJUgrvrLW0wO1EREREREREJE+qWRJWT8GSr6CRbQadtTUOdhGyKvHAnQclO4NlVdLWFCwvb2sOlleUX2uwvBKd7cHyArCyinCZlYTtI9pGVYXLqyJc2bwkcGy4tDxYVkkL3E93SbiWmx4wL0Jfg4DnzUNfg2IV+PUe8l4j9GdVSCHvj9D3WsDP5NCCfjkt5tdowHu3ork+WF7BBX6NWiLcvWsdLcHy8tZw300BPJEIlpeVB/z+B0E/l6uS4Y4z8v8C51dkXMGSkHoaDefiASyHiEhWIQMlIiIiIiLDkaMOXkNSB68iIiIiIiIiw4CCJeEoWCIiIiIiIiIyxLma4QSVc7DEzO7MMam7+4kFlkdERERERERECuAKlgSTT82SRb2sd8BQp7AiIiIiIiIiA8odkgqWBJNzF+DuXpJpAsYBpwBPAn8AAnenLCIiIiIiIiI9c9zzmyS7Po+X5u7b3f0fwMnAccDH+1wqEREREREREcmLJz2vSbILNri8u28FbgbeGypPEREREREREclB3Awnn0myCz0azg5gj8B5Dj2eDJZV56Y1wfICKJs0I1he1tESLC8Ab28NlleiYVuwvEKWC4Cy8mBZWUlpsLwArDxg2Soqg+UFQNmoYFklR1UHy8tLA7c8DHlNLVg8HAAvC3isJeE+fjzwcQY9b4FfoyGFPG9exMdZzPo6YoG709bWRlNTE80tLTQ3NdHU3ERLc0u0rLmZpqYmWlqaaW5qpqm5idaWVkpKS6isrGRUxSgqRo1i1KgKRo2qZFT8uKJiFFWVlTvXVYxiVGW8vqKCilGjqKyspKKigpKS3u+j0F/FrY/buzvt7e00NTXR1NxAU2MjTc1N0TlqaorOXXwum5uaaWxqpLWllfaOdjo7Oujo6KCjo5P29nY6O6Pn7e3tdHR00tHRQWfnzuedHR20d7RHy+PtOjo7qBw1ipraWmpqaqipqaW2NprX1NRQU1tLbW0tY2prqUktr62hNn19PK+qqsKs9zNSWlnXx7O2qxJPBMvLAn5vBiAZrmwhv9Nboj1YXsGF/r4Q8DM++P0xzDlBb9sRL9idbGZVwGnAxlB5iogAQQMlIiLFJplMsmXLFjasX8+GDRtYv34969evZ+OGDazfsJ4tm7fQHAc8mpub4gBIFBBJJgf3W3FJSckuP9a7/3DP57mZUVpaSllZGSWlpZSVllFWVtq1rLSsLHqctry0rCxa17W8jNLSEkrLyuhob6epuTkOhjTTHAeQGhsbSSQC/qAuwA5g48a+f2UuKSlhbF0dEydOZNKkSTvnXY8nM3HiRKZMnsykSZMYP348paUKboqI5CKfoYPf2UMes4DzgL2A7wYol4iIiIwQyWSStra2rqm9rY229vYen7d3dJBMJinr/kM6/vG88wd07+tT61JTWbfnpaWlOf17311bWxsbN2xgXRz8SA+EbNiwgfXr1kVBkY0b6ezs7Icz2/8GO1gz0iWTSeq3bqV+61b+8+9/95rezJgwcSKT4qDKpG5BlYmTJjJ2bB1jx4yhdswYxsRTrjVYRGTwqdPWcPKpWXIFmWtSpt45k8Dvgc/3sUwDyswWA4vnzZs32EUREREZdhKJBEuXLuWaq6/m8ccfp7m5mbb29igA0tYWN2Uo/kBBqtZDpqBKSWkppSUlu6zbtm0bW7du7fdylZeXU11dTVVVFaOrq6kePZqq0aMZPbqa6upoPnp0VTSvHk1VVRWJRCI+/+20trV2PW5vb6O1tbXruqQCU62pgFWcrq1tZ5qhqqysjJqaGkaPHt113kZXV1MdT6nzVVNdE523yirKKyqoqCinvLyc8rJyyisqosflZZSXV1BWXk5ZWTkVFRWUl5dRVl5ORXmUpqy8PNq2rJyysjJaWltobGiksbGBhnje2NhIY0M037FjB02NO5c3NKTWx9vEadva2vI6bndn86ZNbN60iX/96195na9U4GTChAkcuGA+CxcuZOHBC9lvv30pD9iMV0T6QEMHB5VPsOTdZA6WJIF64FF3Xx+kVAPI3ZcASxYefPCFg10WERGR4eK5557j6quu4tprr2XdunWDXZw+c3c6Ozv7LbBTV1fH5ClTmDplKlOnTo0eT53KlClTmDRpEtU1NYxOBUSqR1NVNZrq6uquH6mD0S+Iu+/SnKX7v5mp597L+pRkMkkymaSzs5NEZyeJRILORCednYnocbw8GT/uTHSSSHRLHy/v7Oykoryi63xVV9d0BY+qq6upqKjYpWwh5PP7pI5xMK3nNCU5XIT29na21dezefNmNm3alDaPAiKp51vieX19fe6FTNPZ2cnWrVvZunUry5cv57HHHuPXv7kCgMrKShYsWMDChQdzyMELOfjg17D33nvn1J+NiISmEW5CyhosMbMFwHp33wjg7lcMVKFERERk6NmwYQPX/fGPXHX11Tz15JN5bRt1LhpNFRUVVFRURI/jTkW71qU6GY07F+36EZ1I0Bk/7voxvcsP6OgHd6L78vhxaur+PDUVoqSkhMmTJzN12rSuwEf6fPKU6PGUKVOoqqoqaB+DycwoK+v9f7di6+B1OKmoqGDylClMnjKlx3SlcROajo6OboGVjdF8Y/R88+ZNbN+xg4YdDezYsZ0dDQ3s2L69xxosra2tPPzwwzz88MNdy2pra3nNaw5iz3l7Mnr06DhgVc3o0aO7avRUxzV6aqpHUx3X5KkenQoGqtmPSCGiDl4VLAmlp0+4J4AvA18BMLM7gSvc/bcDUTAREREpfq2trdx08y1cdfXV3H7bbRkDC5MnT+atb30rZ511FpOnTNklGDJq1CjKy8uL/odRV42HDIGURFqQJpFMkkgkqK2tZeLEiT12ptnX0XBE8lVeXs60adOYNq2Xai3dtLW1sWPHDhoaGlixYgVPPPYojz3+GI899jirVq3aLX1DQwP33HMv99xzb0HlNLOuYEqqOVRtbS0zpk9j5syZzJwxI5rPnMHMGTOZPHlS0b+HiAwIh6T6LAmmp2BJEkj/hF8ELO3PwoiIiEjxc3ceePBBrr76av7057+wffv23dKMGjWKxYsXc97b3sZJJ52UUw2EYlZSUtLVdENkpBk1alRXh7Dz5s3jxEXHdq3buHEjjz/+RFfw5LHHHmPjpk192p+7R320NDbmXL4ZM6Yzc8ZMZs6YzsyZM5g1Y0YcVIkCKnV1YxVQkRFBNUvC6emby2rgoAEqh4iIiBS5l19+mauvuYarr7mW5cuXZ0xz9NFHc97b3sab3vQm6urqBrR8IjLwJk+ezOtedyqve92pQBToWL1mDU888QSbNm2iqamZpqbGaN7cRHM8b2psip83xet2psu349q2tjZeeWUZr7yyLGuampqaKHgSB1Dqxo6lqqqKqqpKqiqrqKyqZHRVVbSsspKq0aOpqqygqjJOk7ausrJSfbJk0NHRQWNTEw3NbTQ1NdLY2ERjUzTceWNTE42NOx83NTZSWlbG6Kqqrk6qq6tHR30zVUU1ikZXVVE9uipOEz0fNWqUgl69ULAknJ6CJUuAD5rZv4BUz2znm9miXvJ0dz8xQNkESDZsC5pfoqIyWF5Wkr1qcSE8WVib8Ix5dQbsob8sbA/vpWMnBMvLAl5PgGRlbbC8vDTsP7BeGu46eHnA81YS9t9yD5lf6NeoBfxiGDIvDzx0aciyFTHP8ctmfX09f/rTn7j6qqt46KGHMqbZc889Oe+8t3HOuecyZ86cnfvQ97UeDVbnojLydAS/QXp+n5w8Yw9OnbFHwbl3dnbSHAdPUsGVbfXbWLNmNWtWx9Oa1axevYY1a1azfdu2XvNsbGzkhRdf5IUXXyy4XOkqK9MCKKNHU1tTQ01tLbW1tdTW1FJTW0Nt7Rhqa2uoqallTG0ttWNqqamp3blszBhqaqImRvnWXMu1qYW709YWjXTV2tJCS2srba2ttLS20NISLWtta6WlpZWWlhba4sdR2hbaWttoaW2Jnre0RgGtxiYamxppioMeqeDHQIyQVVJSwujRqU6uo/no0VX8+Cc/5YD58/t9/8XO3TUaTkA9fSv/HFABnAYcR/SZPieeeqKrIyJBhQyUiMju3J2NGzeyfNkyli9fzrLly1m2bBnLly3jn//8Z8YvwHV1dZz9lrfwtvPO49DDDtc/fSISTPpQxbloaGjoCqCsjQMqq1evZs3qNaxavYo1q1fT0tIStIytra20trYWPMJQdxUVFYwZM4bq6mrMjGQyGf/wTZ9D0ndd7hnT7Zx3dHTsNvLUUJZMJruaaKW39hoKQ9APlOF0vQdb1mCJuzcA7089N7MkcLG7f2UgCiYiIiLhvfTSS9z69793BUVSAZLm5uZety0rK+PU172Ot513Hq9/wxsYNWoUoBokIjK4amtrefW++/LqffelNEPc1t3ZunVrFERZs5q1a9bQ0NBIa1y7oqWlmZaWFlpb4hoXzc20xDUxmptb4nQttLa20tycfzOhXLS3t8cjEm0OnvdAKSkpoba2Nuqct6aGmni+y/PqGqprqqkeXU0imaC5qZnm5mZaWpppaormzU3NNLc009IcNc9qaY6uT1NTU9baK1WjRw/w0Rav0BVuR7J86nvfDSzvp3KIiIhIP1u2bBmvOfjgvP+BW7hwIee97W2cffbZTJo0qZ9KJyLSP8yMCRMmMGHCBBYceGCf80smk7S2Rs1WUj/iGxsbaGxopKGxgYYdDTQ2NtDQ0BjPo3WNjQ00NDbSsGMHDY2NNDZE6xoaGgoeojwX5eXlVFVVURn3t1IZ970yqnJnfy1VVVWMGlVJVVUllZVx2rg/l1GVO5fX1KQCHlHwo6a2tiso0h/9iXTPLdVEq6W5meaWFpqbmmhuaWb27NlB9ztUuaNmOAHlHCxx9+P7syAiIiLSvzZv3txjoGTs2LEsWrSIefPmMXvOHObOncs+e+/NHvoSKiLSJdVvxug8ajOU9BBEcHdaW1tpaGigqakJiAI8JSUWza0EM8NKSuLlJXhcjtTzTHMzo7y8vMchzGFo9aGQbxOtkUgdvIYztMfxExGRotPe3h79ixa3KY7+PYv+bWtsaKQx7iG/oSH6h60xbUptl/rCWFFRwSGHHMJRRx3FkUceyWsOOkjDt/bBIYccwk9+/GMu/cEP+M9//rPb+u3bt/Of//yHQw45hDe8/vXMnDVrEEopIjKymFlXZ7G5yrWDVxlhXMGSkEwdwEQWHnyw33///UHyskS4nqD9vj8EywugdMLUYHkV9Wg47a3B8go9oshIGQ2HgKPhhO7gVaPhFKato5N169axZu1a1q5dy9q16+L5Wtaui56vX78+eCd66SorK6PgyZFHcuSRR3L44Yczrm5s2J2MgNFw3J3HnniCa6+5huuuu46NGzfulsbMOOaYY3jzWWex7777MnfOHKZNn57xH0p9lShMIuCJ03fj4ackYGuGkXR/ZOqzpBj0VLOkECGDJcV8e4S+nLXVox9z90MCZ1s0qqbs5XPO+35e27xw6ZnD+pz0hWqWiIiMcO5OfX19FPxYt5Y1XUGQdV1BkLVr17KpCDqda21t5b777uO+++4Doh/0++27L0ceeQRHHXkURx55BLNnz9bILL0wMxYuXMjChQv55re+xR133MG111zDjTfe2BXscnfuuece7rnnnq7tKioq2GOPPZgzdy5z585lzuzZzJ07l9lz5jJnzhzq6uoG6YhERETEKc6aJWZ2LnA1sMbdZ2ZYfyHwcWAuUT+pl7j7zwe0kBkoWFLkktu3BM2vpDpc+z4bHbAWAmFrSYQ8TqrCton0UdXB8kqW515dMxdBa1wE/nc+ZI2LkDVVPHQNq26fb8lkkvr6erZs2cLmzZvYsnkLW7ZsobGpkba2Ntrb2mlra6OtvY2O9nba2tppa2+L17XR3t5BW3v0uK2tjba2djo64m3a2mhvb6exsZHW1nC1sUpLS6mtraWmpqZrnuoArqa2ltqaWmpqa7rm1dU11NbWUFNTmzaPetPftGkTDz34IA8+9CAPPvAAy5Yt63a+nOeef57nnn+eX/7q1wBMmzaNI488kqOOOoojjjySBQsWUFaW+/1jxVxNImAX90b0Gi0vLeV1p5zC6045hYaGBpYsWcI1117LnXfeSTK56/7a29t56aWXeOmllzLmOW7cOObOmcOcuVHwZG7c78mcOXOYNWvWoDSh8iIOnJUG/M/Uivi/4dAlC3lFQ/7bX8S3Gp2BfzwV4W+xLokiLZsX8Ws09PUMWSuqeM9akSrCZjhmVgdcAqzPsv5C4DLgm8A/gBOBn5qZufvPBqqcGcumZjiRYm2Gk/jbT4PlBVA2fW6wvEoCB0soC/cD1soDfiEv4mCJj5BgSdCmKQxusKSlpYUtmzezafPmKACyaRNbtmzper4lHjYwtWzrli27/WAdLCUlJUyZMoXp06czffp0pk2L5/Hz1FRbW9tvNTvWrVvHQw89yIMPRsGTp556qtcRBKqrqznssMM4Ig6gHH744dTU1GRNP1KCJb29RtetW8f1f/oTjzzyCMuXL2f58uVs2rSp4N2VlJQwY8YM6urqqKqqijpHrKqiKp6PHj2663FV3HFi1vXx8jG1tYwdO7bH+62YgyUhb7Vi7r9AwZLBN5KCJcUqZAAhtGIOloQ2Zpg3w6mcvJfPfut389rm3z9+U7+eEzO7HJgNrANOSq9ZYmZlwFrgFnd/V9ryXwNnANPcvaO/ytabrL9AzOzPwLXu/sf4+bHAcndfOVCFGwhmthhYPG/evMEuiogMce7OqpUrWb5iBStS0/LlrFixgi1btrBy5cquXu6LTU1Nze6Bj2m7BkEmT5mSVw2N/jBt2jTe9KY386Y3vRmApqYmHn30ka7gyT//+U8aGhp22aapqYm77rqLu+66C4hqviw48ECOioMnRx19NFOmTBnwYyl206ZN40Mf/OAuyxobG1m+fDnLli1jWRxAWZ72uKcaSslkklWrVrFq1aqg5SwvL2fChAlMmjSJiRMn7pwmTIjmkyZF08SJTJkyhXHjxqmZloiIDFvFNHSwmR0NvB1YAHw+Q5IjgUnA77st/x1wAfBa4K7+LGNPevrW+0bgybTndwFfBr7Sj+UZcO6+BFiy8OCDLxzssojI0LN61SruWrqUu+68k7uWLmXD+ow1DPtk7NixTIh/+E2YEP0QrKmtYdSoUYyqGMWoUaOoGFVBRUUFoypGUTFqFKNGVUTLyyvi59GyiopRUbq056NHj+6xpkUxq66uZtGiRSxatAiARCLBs88+2xU8eeCBB1izZs0u2yQSCZ54/HGeePxxfvKTn1BeXs7ll1/OW885ZxCOYGipqanhgAMO4IADDthtXTKZZMOGDVHgZNmyKKgSB1aWL1/O2rVr6Y/arB0dHaxfv571Ob72xowZEw2LPGcOc+bM6Roiec6cOUybNo0xY8YomCJFwd3Ztm1bVNswrpG4OVX7MJ5v2ryZGTNm8LGPfYy99tprsIssIkWgWFqOmFk5cDnwHXd/Kctn6/7x/Nluy5+L5/tRpMGSbUB6+wN9cxCREW/btm3cc++93BnXVPj3v3cffrUnqX/BU/9+dwVBdnk+KS04MkFD5eahtLSUAw88kAMPPJD3v//9AKxauZIHH3yQW265hT/8YfcRxjo6OrjhhhsULOmjkpISpk2bxrRp0zjqyCN3W9/a2sqaNWtobGykuaWFluZmmpubMz9uaaG5ubnrcUtzMy2trbssa2pqYvv27XnX1tqxYwfPPP00zzz9dMb1o0ePZurUqUybNq1rPm3aNKam5vEyBVUkX4lEImpiuWlTFPTYtKkrALIlLRCyefNmNsfNMjs7O3PK+7o//pHvX3IJb3/723Vfioxg7l5MfZZ8GhhF1BdJNuPjeX235Vu7rR8UPQVL/gWca2aPELUvApgTN8fpkbvf01saEZGhoK2tjYceeog777qLO+9ayuOPP95jHyJ1dXXss88+zJ49mz1mz2b27NnMmTOHGTNm5PQDq0j+DBg2Ojo6ePa557jpppu46aabMqaZMWMGH/nIRwa4ZCNPZWUle+65Z/B8W1paoh+ccf8/qX/bN8c/SLv6B9q8mTVr1tDc3Nxjfs3Nzbzyyiu88sorPaarqqraJXjSNY+DKtOnT2fmzJlUV4frp0qKT1NTE5s2bWLTxo1s3LQxepx6vjHteXw/9lcfVE1NTbzvoov4x+2388Mf/YixYwMPqS4iQ0YBzXAmmtmjac8vd/fL0xOY2UnA7Tnkdbe7LzKzvYDPAW9y955GEUh9KS7Kb8A9BUu+DNxANMRPyrviqTdhh4cQERkgDQ0NPP744zz88CPcc++93P/AA11DqWZSWVnJUUcdxfHHH8/xJ5zAgQceSGmp3gIHk7vz6KOPcu0113D99ddn7JS0oqKC0047jXe8852cdNJJg94XixSuqqqKPWbNYo9ZszKuT+/g1d3ZtGlTVzOh5StWsGzZMlYsX87KlStZt25dj6/3dC0tLTkFVSZMmMDMWbOYOXMms2bOZFbq8axZzJw5i6nTpuk9o4h0dnZGQbauIMfG6PnGTWnBj2i+cePGXoNvfVVbW7uzNmKqX56051WVlXz961/n3//+NwDXXXcdDz/8MFdeeSWHHX54v5ZNRIqTJ3vu+D6DzTl08PoAsG8OeaXeFH8I3Ak8FI+GA1ABWPy8zd1b2LUGybq0fFI1SrYyiLJ+O3T328xsX+AkYAZwMXB3PImIDHmJRIIXXniBhx95hEceeZRHHnmE5//1rx7/+TMzDj74YE44/nhOOH4Rhx91NJWVAUcRkoItX76ca665hmuvuYb//Cdz86gDDzqId77jHfzXW9/KhAkTBriEMtjMjMmTJzN58uSMPyTdnR07drBu3TrWr18fzdet2/V5PM/1R/KWLdFw3089+WTG9aWlpUyfPj0KnnQFVWbt8ryurk5NKwqUGn49FQDZnBbs6GoKkzZt3dq/38vHjx+/a2fEGQIg6U00c/l8ecNpp/HJT36SK37zGwBWrFjBiSeeyOe/8AU+8YlPKBgnMpK4FxIsySFbbwZeyGOT/YhGwOnevIZ42Q+A/2Vn3yT7s2uwZL94/nxeBQ2sx7/S3H0F8CsAM7sYWOruw6qD134RcMjUzubc/uHKVXlFuB91JXWTguUFkAw4pG6yfHSwvLx8VLC8ALysOIfnjfIL+GU8cNmSAYb7Xb9+PY888ggPP/wwjzz8CI8//hiNjY29brfnXntx/PHHs+j44znmmGMZP35n80kn7JCMIX8OlRbz2H2BbN26lb/86U9cfc01PPjggxnTTJ8+nXPOOYdzzzln145Js7V5Cjk8b2AWsmxFfJwe8P3DyD0vA+rGjKFuzBj23WefzIk8ibvT0NDQFThZt37DLoGUdevXsWbNWlavXk1HR88jHiYSiV5HCRo3bhzHHXccp5x8MieffDIzZ87cLY0V8es9dPPCEs/8Q2DLli088OCD3HvvfTz40EOsXrWKTZs39zq8eF9UVFREAbhJk5g8eRKTJk1i8qR4nvZ88uTJTJwwgfLyPD/LEr2PmFlbWcHPf/QDTj5+Ef/9oQ+zfft2EokEX774Yu664w5+/cvLmTJzdmEHmEUR325BFfNhhhz2ujTwgSq2O3ic/gmWFOAcoPuPns8AC4G3AKvjZQ8Cm4G3Af9IS/t2olol9/dvMXuWT73j44Hl/VQOEZGsCgmUtLa28uQTT+wMjjzyCCtX9j7yeUlJCfvttz+HHHoIhx12OMctWsQee+xRSLGln7S1tXHrrbdyzdVXc+utt9Le3r5bmtraWt545pmcd955HHPMMfpnVYIyM8aMGcOYMWPYe++9s6aLRgjayOo1q+OASDSPnq9m9erVbNy4sdf91dfXc8MNN3DDDTcAsP/++3PyySdz6imncOSRRzJqVNig/lCxYcMG7rv/fu697z7uv+9+nn3uud436oWZddXy2Bn4iGqBpIIi0fLoeW1tbdHU+jnrzW/ikEMWcv573suDDz4EwD333sthRx7Fj3/6MxYvPmOQSygi/c7B+zFAnHMx3B/qvszMzidqfrM0LV2HmX0B+KmZrSEKmJwAvBv4kLvv/iVvAOUcLHH3XZrfmNk4oMbds/8VIiIyAJLJJC+//DKPPvoojzz8MA8//DDPPPNMr//oAkydOpVDDj2UQw89jEMPPZTXHHzwkB1Gdzhzdx584AGuufZa/vynP1Ffv3utztLSUk45+WTOOfdcTj/tNEaPDlfDTKQQ0QhBU5k2bSqHHpKhObiVdI0SlKpdsnp1HFhJzVet2q3Jz3PPPcdzzz3HpZdeGg2ffdxxnHzqqZxyyinMmTNnYA5uEKxZvZp777uXB+67l3vvuy/n0cjGjh3LpDjIMWnSRCbFgZBJkyYxOW4OkwqCTJgwfkgHV2fvsQe333Iz3/x/3+ab/+/bJJNJtm6t57xzzuE9730v3/jmt/TeKDKsFU3Nkpy5+8/NzIGPA58EVgIfdPefDm7JwPIZh9nMaog6fn0bMAlwdy+L1x0OfAn4vLs/3g9l7VcLDz7Y778/TC0fS+Y2zFsu2v74nWB5AVTtd3CwvEonTg+WF4RthuNqhlNgfsXZDKenmiWvvPIKb37Tm7o6t+tJZWUlr3nNazgkDowcethhzJgxo0//CobuunukNsNpamqKmi+sW8faNWu6Hq9atYply5ezfNkytm/fnnHbhQsXct5553H2WWcxefLkvhemiJunBG2GU8RCNsMJ/j4Z8hrkUDZ354UXXuC222/n9ttv5957781Ymypln332YfHixZx++ukccuihlJQEPv4CFNIMp76+nieeeILHHnuMJx5/jMcee4zVq1f3uE1paSkHH3wwx7z2tRzz2tdywPwDmDRxYo81b4bza+q++x/g/Pe8d5fztt9++/PXG29k6rRpfcq7KIet6AfF/CkashlOaL0VLZlM0tDQQEVFBZWVlQNaO2t0VdVjOXRmOmRVjJ/tk079XF7brL32fcP6nPRFzjVLzGwscB9R5ytPErUtSu8R9xngGOBcYMgFS0RkaLppyZKsgZK9996bQw89lEMOPZTDDjuMAw44gPLychLFM/78sNfW1saG9etZu3ZtVwCkKyiStmzHjh155Tt79mzOOfdczj33XPZ51av6qfQig8/M2Hfffdl33335yIc/TFNTE/fccw+33X47t912226j8bz44ou8+OKLfPe732XK1KmcdtppLF68mEWLFhVtc536+nqeeeYZnnzyCR5//HEef+wxXn755V63q6io4NBDD+G1Rx/NMa89hsMPP0w1A9O89uijeOTB+/mfD32EP8dNuJ5//jlOP/00brnlViaFCC7LiNba2kp9fT319fVs21ZP/dZ6ttbXs31bNN8Wr0t/vG3bNurr67s60y8vL2fs2LGMHTuWMWPHMnbMmF0f19UxdswYxowdy5gxY6irq2NMnCY15d0X0DA31GqWFLOca5aY2beBTwDnu/tvzexLwBfdvTQtzU3AdHcPV31hgKhmSf5Us6TA/FSzJG891SxZtmwZRx5xxC4/tr/3ve9xzrnnMm7cuIzbhAyWDNWaJe7Oxo0bWb5sGevWryfR2UlnZycd8Tw1JdKfJxK7Le/o6NhlXUd7O5s2b+4aQWTz5s3Bjmf8+PG86c1v5txzzuHIo47q+ifKQvceWcT/NA/nf8HTqWZJ7l5++WVuu+02bvvHP7h76dKsQx/X1NRwyimncPrpp3PoYYcxc+bMAQuepF6iyWSSFStW8PRTT/H000/zzDPP8PTTT/XYuW26qqoqDjv8cI597dG89uijOfTQQ6mqqupT2UbCa8rd+cWVv+OjH/lIV2e3++9/AH+75ZaCRwUbKX85FG/djf6pWZJIJNi8eTPr169nw4YNXfMN69exYcMGNm7cuEvgI9eh1vtbVVUVN910E0cedVSvaYd7zZLy8Xv4xBM/ldc266//0LA+J32RTwevbwb+7u6/7SHNCuDQvhVJRCR3c+fO5eZbbuGMxYu7hnz85S9/ydvf8Y5BLtnga2lpYcWKFSxbtozly5axbNmyriYty5Yty3no04FQUVHBtGnTuqbp06d3zefMmcOcuXOZMmVK0XSkKFIs9txzTz7wgQ/w/v/+b5qbm7nzzju56aabuPlvf9slWNnY2Mif//xn/vznPwNRjZVp06Yxe/Zs5syZwx6zZ3c9nj17NjNnzuzTv7UtLS08//zzUVDk6ae7giMNDQ05bV9WVsYBB8xn4cKFHHzwwRy8cCH77rsv5eXlWUfDkczMjAsueDdjx4zlgvPfRTKZ5LnnnuXMxaez5G83Z/1jQYaP5ubmOPgRBT3Wr9s1GBLN17Np06Z+HT0qXXV1NR0dHT02K8xVS0sLVeqLJ+KqWRJSPsGSmcCfeknTCIwtvDgDz8wWA4vnzZs32EURkQIdfPDB3LhkCSedeCKtra3861//4n0XXcRVV189rH9cuzsb1q/vCoAsX76MZcuWs3x5FBxZt25d75n0s9LSUqZMmbIzEBIHQdIDItOmTWP8+PHD+lqJDITRo0dz+umnc/rpp5NIJHjowQe56aabWLJkyW7NddydtWvXsnbt2ozDbpeUlDBjxgxmx0GUPdICKbNnz2bGjBmUlUVfIzdu3BjVEkmrMfLiiy/m/KOroqKC/fbbn/nz5/Oa17yGhQsXcsD8+VRWBqyJKbz5rLNob2/nogvfi7vz1FNP8eY3nslfl9zEmDFjBrt4kqfm5mY2btzIxo0b2LhhY/w4fr5x5/MNGzbk3dQ1V2VlZYwbP55xdXWMGzeOurpxjBs/jvHjxlE3LpqPGz+eurq6rmXj4ikVjG1tbWX79u1d044dO9i+bRvbd+xgx/btbNu+nR3x8tTj7XGaHTt2sH37dpLJJGPHDqmfoP3ISSpYEkw+zXA2ATe5+wXx80zNcP4IHOXuM/ujsP2pWJvhJG76cbC8ACoPOTFYXokxU4PlBeAVAZvOlOQTB+xZyOsJgauXh1YSbgSAkNcAyKm6+lVXXcV7L7yw6/lXvvIVPvmJT+yWrjNg/eHQ1WB7+sd048aN3Hrr37n1tr/zwgsvsHz5ij5VgR0zZgzz5s5l5swZVI6qpLSslLKysmgqLaMs/XlZGaWlZZSXl+2yrKysNE5bRmm8bML48fEIINOYPGnS0BtZopi/ZIS830I3XwqpmI8zZLONAXrPdXf+9a9/seSmm7jjzjtZtmw5a9asIZ9O/rsrLS1l5syZtLW1sX79+py3mzB+PAsWzOfA+fNZMP8AFsw/gH323juvWixBP5eLrFlVupDfF5Jp37GuvPJKPvD+93c9P+KII7hxyZJB6+8l9Es0aIviAX6fbGlpYd26dWzYuJGNGzbsEvDYsHHjLkGQxsbGfinD+HHjmDJlClOnTon+7JgyhSlTJjN16lQmT57MhPFxwKOujpqamv7/o6OX14G709jYyOjRo3P6vlFZM2ZYNzkpr5vpdcd9JK9tNt/4qWF9Tvoin18zjwCnm1mtu+9Wh9LMpgFvAG4KVTgRESDnL6Bve9vbeOzxx/nZz34GwJe+9CUOOvBATj755P4sXb9xd1588UVu+tvN/O3mm/nnP/+Z14+b0tJSZs2axdw5c6Jp7q7zcePGqTaHyAhgZuy3337st99+fPpTUVv29vZ2Vq9ezYoVK1ixciUrVqxg+fKdj9etW9fj+00ikWDFihU97nPPPfdkwYIFHHjAfiw44AAWLJjP9GnT9L4zyN71rnfR3t7ORz78YQAeeughzj7rLP78l79oWOF+kkwm2bx5c1dtrt2muNPz+vr6ftl/eXl5HACZytS0QMjUqVOjgMjkSUyZMpkpkycXbUfQ2ZgZtbW1g12MouGoGU5I+QRLfgDcAtxsZhelrzCzfYFfAJXAD8MVT0QkP//vW9/i6aef5v7778fdedf553P/ffcxd+7cwS5aTjo7O3nggQe46W83c/Mtt/Q6IsS4ceOYO2cOc+bOYe6cuXEgJJrPmjFdPcSLSEYVFRXMmzePbM2Q29o7WLVqVRRMiaflaY/Ta5NUVVVxwAEHsGD+fBYsWMCCAw/kgP3376qpYJ1tA3JMkrsLL7yQjvZ2PhHXvrznnnt463/9F9ddf72aP+UpVRtk7dq1rMkSDFm3bh0dHR1B91teXs7kyVGAY/Ju06Su5VOmTOm1qWvoWtQyiNzxAep3ZiTIOVji7n83s4uBi4FngQ4AM9sMjCPqMPrT7v5A+GKKiOSmvLycq37/e446+uiuf2mOP/54Fi9ezCmnnMKiRYuoqimOfyC2bdvGs88+yzPPPM2zz0Tz559/PmvTmpKSEo488gje8Po3cNxxxzJv7tweO+YbCaM8iEj/GDVqFHvttRd77bVXxvWtra2sXLkSM2PevHlDr7md8N//8z+0tbXxuc99DoA77riD1xx0EPvtvz+lJSWUxJOZdT3uvsyypYsf144Zw6xZs5g1axYzZ85k1qxZRTe8s7vT3NzcNaxtamjbbdu2sX3btmjkl3j5Lo/jqbW1NVhZysrKump7TJ0yZWfwI36cHhipGztGtbRE+llenQq4+1fM7F7gw8ARwASi2j43A5e4+53hiygikp8pU6ZwzdVXc/Ipp9De3s6GjRv55a9+xS9/9SvKy8s56qijOenkkznllFPYd7/9+v3LRltbGytXruTZZ5/hmaef4ZlnnuHZZ59h5cqVvW5bU1PDSSedyOlvOI1TTz2FiRMn9mtZRURyUVlZyd577z3YxZA++ujHPkZbeztf+fKXAbpqDvWnurq6KHgSB1BSUyqoMm1a4bUi29vb2bp1C1u2bGHr1q1s3bKFzWmPt2zZwpb4cX19Pdu3b6e+vj54rY9M6urqmD59ejTFnZx3nyZNmkRJSY591egPEclCzXDCyTlYYmbHAjvc/S7grv4rkohI3x122GFcecUV/M8HP9g1pDBAR0cHd9+9lLvvXsoXPv85Zs6cyUknn8zJp5zCokXH5z0iQEdHB+vWrWX16tWsWbMmmq9enfZ8DRs3bsgrz1mzZvGG17+O095wGscee8yQaz8sIiJDx2c+8xkqysv56le/Sltb/zeZStXIeOaZZzKuTw1rnQqgzIjn48ePZ/u27WzdupUtWzbHQY+tcWAkCojkOjR1SGVlZUyZMoUZM2bsFvyYEc+nTZtGdXX1gJdNRiB3BUsCymc0nARwmbv/d/8WaXBoNJz8aTScwmg0nAL04Zx1dHTwz4cf5ra//53bbruNp55+OmvasrIyjjzqKE4++RROOeUU9nn1q9mwYT2rV69hTRz8WLN6NavXrO56vn79+oJHlCgvL+fVr96X+QvmM3/+fA44YD4HHrAfkyZNKvRwd6FmOAUq5i8ZxTxKTEjFfJxDcDScggT8rArdZ4lGw8lfMofvWNu2beORRx6hra2NZDJJMpnEk0ncvet5MpnEYdfn3dZ3LUsk2LxlC2tWr2bVqlWsjuft7e3BjiuUyspK6urqdk7xaC91dXXRfNw46saOjZ6PG9eVbty4cYwePXpwmsMEvHeLus+SwK+r4T4aTtmYaV5z2Hvy2mb7HV8f1uekL/IJlmwAfu/uH+/fIg0OBUvyp2BJYRQsKUDAc7Zu3Tpuve12br/9Nu684w62b98eLO9sSkpKmDp1Kvvutx8HHHAA8+cvYP78+eyzzz67VTXuaejgfClYUiAFSwZfMR+ngiX5Z6VgSUEGOlgyEJLJJJs2beoKnKxZvZqVq1axOi2YsmHDhoL/hCgtLWX8+PFMmDCB8ePHR48nTmRC2uPx48czYfx4xo0f3xXwyNap7UAPHZwXBUsKMtyDJaVjpnnNIRfktc2Ou745rM9JX+TzyboUOKqfyjG8BHzzKpsedgSPRPWEYHklK/NrrtCrgF+Orb0pXF4dgb/khcws4BdtgOSocJ2ulST6v/1vIWZMGMO733Ee737HeXR2dvLPhx/h77fdzm23386TTz2Vd35mxpTJk5k5YzozZ8xg5swZzJi+8/HMGTOYNnUKZWWZ3m47oFs76aABjmIOloT88lPMxxm6bCHPW8gvx4G/zFpnwH+eQ78XhQxwlFUEy4uy4h3BpLRpS9gME+HuDw943kIHqL003GhmxRI8LwWm11UzvW4fDjtgHwC8bNempu3t7axZu5ZVq6KanKtWrWb16jXU19dTV1fH+PHjmThxfFfQY8KECV3BkLFjx1JCAQGOjnCdtGYV+BqEDHBY4OMPGegrlnt3yFAznKDyCZZ8HvinmX0V+Iq7F+cvoTyZ2WJgcbah80Rk+CorK+Poo47k6KOO5CsXf5H1GzZw2+3/4Lbbbucfd97Jtm3bmDRxYtz5XBT4mNEVBImWTZ88kYqKgD94RERERrCKigrmzpnD3DlzCstAPxRlhFOwJJx8giWfJRoy+P+A95jZU8B62C186+6eX0OpQeTuS4AlCw8++MLBLouIDK6pU6bwzre/jXe+/W24Ox0dHb0HQoq0Bo2IiIiIjDDuJBUsCSafYMn5aY+nxlMmDgyZYImISCZmphojIiIiIjJkOOAJBUtCySdYErbzDBEREREREREJQ32WBJVzsMTdV/RnQURERERERESkUAqWhBR4nDkRERERERERGQwKloSjYImIiIiIiIjIUKdmOEGZewFjkQ9DZtYAvDjY5ZBBNRHYPNiFkEGn+0B0DwjoPhDdA6J7YDia7e6TBrsQ/cXMbiW6b/Ox2d1f1x/lGeoULImZ2aPufshgl0MGj+4BAd0HontAIroPRPeA6B4QGdlKBrsAIiIiIiIiIiLFRMESEREREREREZE0CpbsdPlgF0AGne4BAd0HontAIroPRPeA6B4QGcHUZ4mIiIiIiIiISBrVLBERERERERERSTOigyVmNsvMrjez7Wa2w8z+bGZ7DHa5pG/M7Gwz+5OZrTCzFjN70cy+aWa13dKNM7NfmtlmM2sys3+Y2fwM+VWa2XfMbF2c34NmduzAHZGEYGa3mpmb2de6Ldd9MMyZ2RvM7B4za4zf6x81sxPS1useGObM7Ggzu83MNsb3wONm9u5uaXQfDBNmNtPMfhRfm+b4vX9OhnRBr7mZlZjZZ81suZm1mtlTZnZWPx2m9CCXe8DMTjSz35vZy/F1fdnMfmZmkzPkp3tAZAQascESMxsN3Am8GngX8A7gVcBdZlY9mGWTPvsEkAD+D3gd8DPgA8DtZlYCYGYG3Biv/xBwFlBOdP1ndsvvV8CFwBeB04F1wN/N7KB+PxIJwszOBQ7MsFz3wTBnZu8D/go8BrwJeAtwHTA6Xq97YJgzswXAP4iu64VE1/gR4Fdm9oE4je6D4WUv4L+AeuDeTAn66Zp/FbgY+DHweuAh4Doze0Ofj0jy1es9ALwfmAB8jeg++CZwBvCQmdV0S6t7QGQkcvcROQEfIfpBvVfasrlAJ/CxwS6fpj5d20kZlr0TcOCE+PmZ8fPj09KMBbYCP0xbdmCc7oK0ZWXAi8CNg32smnK6H+qA9cC58bX8Wto63QfDeALmAC3A//aQRvfAMJ+AbwDtQE235Q8BD+o+GH4TUJL2+L3xNZvTLU3Qaw5MBtqAL3fbzx3A04N9TkbalOM9kOn74rFx2nfrHtCkSdOIrVlCHDl295dSC9x9GXA/0QeoDFHuvinD4kfi+Yx4fgaw1t3vSttuO7CEXa//GUAH8Ie0dJ3AtcCpZjYqYNGlf3wbeM7dr8mwTvfB8PZuIAn8vIc0ugeGvwqia9fSbfk2dtaw1X0wjLh7Modkoa/5qUT32u+77ef3wHwzm5vvcUjhcrkHcvy+CLoHREaskRws2R94NsPy54D9Brgs0v+Oi+f/iuc9Xf890qpf7g8sc/fmDOkqiKp5SpEys9cS1Sr67yxJdB8Mb68FXgDOiduid5rZS2b2P2lpdA8Mf1fE8x+a2XQzqzOzC4ETgUvidboPRp7Q13x/oloFL2VIB/puOVR0/74IugdERqyRHCwZT9SOsbutwLgBLov0IzObAXwF+Ie7Pxov7un6w857oLd040OVU8Iys3LgMuC77v5ilmS6D4a36UR9UX0H+BZwCnA78GMz+0icRvfAMOfuzwKLiGoLrCG6jj8B3u/u18bJdB+MPKGv+Xhgm7t7L+mkSFk0EMClRIGSG9JW6R4QGaHKBrsAg6z7mxmADXgppN/E/wz9lagvmgvSV5Hb9c81nRSfTwNVwNd7SKP7YHgrAWqB8939z/GyO+MRET5rZj9E98CwZ2avAv5E9O/u+4ma45wJ/NzMWt39KnQfjEShr7nujSHMzMqAa4ia3xwdN7PpWo3uAZERaSQHS+rJHOEdR+bosQwxZlZJ1NP9POA4d1+dtnor2a8/7LwHtgKZhpMel7ZeioxFQ4B/jqhTt1Hd+hEYZWZ1QAO6D4a7LUQ1S27vtvw2opEPpqF7YCT4BlF/A6e7e0e87A4zmwD8wMyuQffBSBT6mm8FxpmZdatZoHujyMUjJV4JnASc5u5Pd0uie0BkhBrJzXCeI2pb2N1+wPMDXBYJLG6C8SfgMOAN7v5MtyQ9Xf+V7t6Ylm5uPNR093Tt7N4uVYrDPKCSqFO1+rQJoqGl64H56D4Y7p7Lsjz1L18S3QMjwXzgqbRAScrDRMOGTkb3wUgU+po/B4wC9syQDvTdspj9HHgrcI6735Fhve4BkRFqJAdLbgSOMLN5qQVx1eyj43UyRMX/EFxF1Hnfme7+UIZkNwIzzOy4tO3GAIvZ9frfCJQDb0lLV0b0oXqbu7eFPwIJ4Eng+AwTRAGU44m+3Og+GN7+Es9P7bb8VGC1u69H98BIsB44yMwqui0/HGgl+rdX98HIE/qa30r0w/lt3fbzduDZeMRFKTJm9j2iWqgXuPsNWZLpHhAZoUZyM5xfAB8E/mpmnydqY/hVYBVRp5AydP2E6APt60CTmR2Rtm513BznRuBB4Pdm9kmimgafJfrH+dupxO7+pJn9Abg0rq2yDPgAMJfdPwylSLj7NmBp9+VmBrDC3ZfGz3UfDG83A3cBl5nZROAV4Gyijl5TfRjpHhj+fgxcBywxs58S9VlyBnAucIm7t+u9YPgxs7Pjhwvj+evNbBOwyd3vJvBr3903mtklRP0hNQCPE/2YPoFdhyKWAdLbPWBmnwY+Bvwa+E+374ub3P1l0D0gMqK5+4idiNof/gnYQdR/wQ3AnMEul6Y+X9flRMGvTNPFaenGE31AbgWagTuAAzPkVwV8n+jfyVbgn8CiwT5OTQXdGw58rdsy3QfDeALGEAVQNxD94/c0cJ7ugZE1Aa8nCqBuij/vnyQaUrxU98HwnHr4HrC0v645UAp8HlhBNITs08DZg30uRurU2z0QvydkS3OF7gFNmjSZe6ZOm0VERERERERERqaR3GeJiIiIiIiIiMhuFCwREREREREREUmjYImIiIiIiIiISBoFS0RERERERERE0ihYIiIiIiIiIiKSRsESEREREREREZE0CpaIiAxjZrbIzNzMLh7ssuTCzC6Oy5uafp7HtufH25zfj0UcVGnnZ9Fgl0VERERkOFOwRERkCDOzOfGP5ysGuyyBXQl8GbhpsAsi4ZnZ6Wa21My2m1mjmf3TzN7VQ/pSM/tfM3vazFrMbKuZ3WxmR/WwzXgzu9TMlptZm5mtNbNfm9nMHrbZz8z+aGYbzazVzF40sy+bWVWBx5l3fvmemxzK0O/nWkREZDgqG+wCiIhIv3oY2BfYPNgFydMV7r50sAtRhH4MXAusHOyCFMrMPgj8CNgC/B5oB84GrjCz+e7+iW7pjeiYzwZeJDoH44G3AveY2Vnu/tdu20wAHgD2Bu6Mt381cAFwmpkd6e6vdNvm8DhtOXA9sAo4AfgicKKZnejubXkcZ9755XtucihDv59rERGR4crcfbDLICIiBTKzOcAy4Ep3P39wS9N3cXOhLwHH5xssiZvf/Aa4wN2vCF026bv4fn0BaAIWuvvyePk44BFgT+Aod38wbZtzgauJgh8nuntrvPxQ4D5gO7CnuzekbXMZcBFwibt/LG35h4EfAH9399elLS8FniEKLJ7p7jfGy0uAPwJnAZ9192/leJx551fIuemlDHnnV8i5FhERGa7UDEdEZIiKAwvL4qfv6tbXx/lxmox9lsTV8t3Mys3si2b2ctxM4AUzuzAt3fvN7Jm4Ov7quAlBxs8OMzvczK43s/Vm1m5mq8zsMjObHvi49zKz68ys3syazOwBMzuth/THm9nlZva8me2Ij+VZM/uSmVV2S/ut+Ly8M0teC+P1S9KWTTGz78ZNLJrMbFv8+Aozm5fjMS0ws2tsZ5ORTWb2uEXNSMrT0mXssyRettTMJsbHui7O5zkzu6CH/Z5iZkssaibSFl+zv5rZSRnSnho3x9gcp33ZzL5jZnW5HGPs3cAo4MepH+8A7l4PfCN++v5u23wgnn8+9eM93uYR4A/AJKKaEKlyVgPvIAoSfKlbXj8GlgOndrs2xxEFNu5JBTbifSSBT6XKFde8yEUh+RVybnrS7+daRERkOFMzHBGRoWspUAd8BHgKuCFt3ZM55nEtcDhwM9BB9EPocjPrABYA7yLqN+QO4AyiJgTNwP9LzyT+Qf4LoA24kajJwauA9wKLzewId+9z0xEzexXwIDABuIXoOPciOvZbsmz2aaImGA8AfwMqgaOBi4FFZnaSuyfitD8HPgm8D/hthrzeF88vi8szGrif6F/624ElgAGzgTOJml+8sns2uxzTAuCfgBOdu2XAmPi4/hv4PNG16U1dXJb2eL+VRNfz12aWdPcru+33y0TXs5Ho/K0CpgNHAW8H/pGW9otEfchsJbofNhLdH58A3mBRs5YdOZTxhHh+a4Z1t3RLg5mNisvTDNybZZt3xNv8Jl52JFAF3Na9BoS7J83sNqJaJ8ez89pkLZe7v2Jm/yZq0jMPeLmH40spJL+8zk1fypApvwLPtYiIyLClYImIyBDl7kvNbDlRsORJd7+4gGz2AA5w920AZvY9oqr7lwDbgAXuviZedzHwEvAJM/ueu3fGy/cmCh4sB45LpY/XnUAURPgB8KYCytfdT4gCJf/r7j9I28+Z7BosSvffwDLv1u7UzL5KFIg4m+hfc9x9uZndQtSvxXx3fyYtfQ1wLlFQIfVj80SiQMml7v7RbvlXEP2z35t3EQU23pih741xRD9ec3Eg8Cvgfangj5ldAjxNFDDqCpaY2SlEgZJlwDHp1yxePzPt8fFEgZIHgTek7pV43flEP5y/DOxy/FnsE8//3X2Fu68zsyZgppmNdvdmooBRKfBK6n7r5j/xfO9c9tHHbfaOp1yCJYXkl++5KbgMAc+1iIjIsKVmOCIiI9tn0n/8xp1e3kdUS+Gr6T+i43RLgInAjLQ8PkDUieVHuv/odvc7iWpLLDaz2r4UNP4BfzLRD/wfd9vPX4G7M23n7q90D5TELo3np3Zb/rN4flG35W8DaoBfptVESWnJsN/2PPt2yJRHfdx0IxfNwMfSy+buzxPVNtm32/n/UDz/ePdrFm+3Ou3ph+P5hen3SpzuCqLaPW/LsYxj4/n2LOu3d0uXa/q6AvbR12160p9lGJtlfaFl6Mu5FhERGbZUs0REZGR7NMOytfH8sQzrUj+sZwIr4sdHxvPjLOoIsrvJRP9Y750lz1y9Jp7flyFYAVGzpOO6L4z7sPgIUc2WvYFaoqYyKTO6bXILUUDmHWb26bR/8S8CEsAv09LeTXROPmNmBxM1Z7qfqKZPpjJm8oe4fDeY2fVEzV/ud/dcajCk+0+WpjCr4nkdkAreHEHU7CdTE43ujiRqBvQWM3tLhvUVwCQzm+DuW/Ir8m5S1yXX3ufzTR9kGzM7CHhjtzTb3P3SASzDG4GDuqV50t1v6KcyFFJmERGRIUvBEhGREczdM/2LnKqC39O68rRlE+L5J3vZXU0eRcsk9c/3hizr13dfEHeOeidwGPAsUWBiEzv7APkS3ZrKxP1aXAZ8i2jI1N+Y2ULgYOAGd1+blnaHmR1B1AzlDHbWUtlsZj8FvubuPfY34u4Pm9kxwOeImgS9Iy77i8CX3f2anrZPsy3L8tQ1K01bVgfUu/tutVkymED0faF7Z6nd1RANUduT7UQ1k8ZmSTsmnu9ISw/Za1OM6ZZuoLY5iN3Pxwp21lYqtAz5nJs3EjXhSnclO5ujDcS5FhERGbbUDEdERPqq60eWu1sPU8ZmMgXsZ0qW9VMzLDuTKFBypbvPd/eL3P1zcf8ul/Wwr18TdVab6tB1l45d07n7and/D1ENmgOImq1sIeoT5Is97CM9jwfd/XRgHFHns18lOs6rM41ME8A2YJyZVeWQdjtRYKWna2vuvqLXnODFeL5bvxdmNg2oBlan1eZ5iag2zzwzy/QHz6vieXq/HFn3EWobd78iw/HP6a8yZDo37n5+hjKcX2h+FHauRUREhi0FS0REhrZUU4/SHlP1r4fi+TH9vJ8n4vlrzSzT8S7KsGyveP6nDOt2a7KT4u6biEaUOdzMjibq2HU5cFsP27i7P+fuPyLqWwV2b6rRI3dvc/cH3P2L7Owr5Mx88sjRQ0TNKl6XY9pxZrZ/gP3eGc8z7ff13dLg7m1EoxiNJvP9tds2ROVtAY7u3k+ORcNenxI/vSuXcsVDDO9NVHOkx5GN+phfXuemL2XIlF+B51pERGTYUrBERGRoqyfqQ2CPQSzDj4matVwSj4yzCzOriJuZ9Enc6ejtwFzgg932cSaZgx/L4/mibunn0W344wxSHb3+gaiJyeXdO1s1swPMbE6GbVO1X3odtcTMjjGzTE0fcs6jAD+K598zs+59ttBt2SXx/BdmNj1D2uq4KVIufkNUY+eD6ectHvXn/+KnP++2Teo6fM3MKtO2OZSomdQm0oJh7t4I/I6o5sTF3fL6IDAH+HvcmXHK3cC/gGPN7Iy0fZSw8z75eZaOgjMpJL9Czk1P+v1ci4iIDGfqs0REZAhz90Yz+ydwjJldRVRFPgHc6O5PD1AZXjCzdxM1XXnOzG6Ny1FOFMQ5huhH1qsD7O5/iIawvTQe/vYpotojbyIaqWdxt/RLiJoXfMzM5hPVTtkDOB34Gz0Emdz9fjN7imhI3o74+Lo7Cfi+mT1ANOTyRqLOb88EksB3cjimjwOnmNlSopoGjcD+RP/k1wOX55BHXtz9tnjo5C8A/zKzG4g6gp0CvJaodsb5cdo7zOwzwDeB/5jZzUQd4NYAs4mCVPeRQy0Vd19mZp8Efgg8amZ/ANqJ+mqZCXzP3R/sttm1wJvjNE+Y2RKiflTeSlSj6sIMHdv+H1GA7GNxZ6wPA/sSXZeNRPdRerkSZnYBUa2J6+OOdlcSDQ19CFGnvZeQo0LyK/Dc9FSGgTrXIiIiw5O7a9KkSZOmITwRBQuWEPWTkSSqaXJ+vG5R/PzibtssjT4CMuZ3RbzNnAzrLo7XLcqwbn687Qqif7S3EnWqehlwQo7HkjX/bsd7PVG/G01EwZPTiH7cdx17WvpZwFVEo9a0AM8BnyL6w8CBpT3s6yNxmuuyrN8X+D7RqEKb4uNeHpfvqByP+RSiWgDPE/UP0kTU38QPgdm5nJ+ejqOX6/kGohFxtsZlXwX8JdP1Igqi/JFotKT2+HifjI//kDzv2cVEtS8a4uN9BHhXD+nLgI8Cz8TXsJ5o5KGs5xgYD/wgvh/bgXVEAa+ZPWyzH3AdsDk+H/8m6ry3qsDXZt755XtuiuFca9KkSZMmTcNxMneNACciIsXBzC4mGmXkeHdfOrilATO7gmjEkZPc/Y5BLo6IiIiIDBD1WSIiIsXoLjNzM8unj4agzGwWcA5R3xPq1FJERERkBFGfJSIiUkyWdnv+6EAXwMzOIxqt5BxgFPAFVzVMERERkRFFzXBERETSxB2tHkvUf8cl7n7poBZIRERERAacgiUiIiIiIiIiImnUZ4mIiIiIiIiISBoFS0RERERERERE0ihYIiIiIkXLzCbGIyN1TYNdJhERERn+FCwRERHpIzObaWa/NrO1ZtZmZsvN7FIzG5cl/VFmdrOZbTWzZjN72sz+18xKC9h3lZl92cxeNLNWM9toZn80s31DlTeHMrzLzB42s0Yz225mS83s9EBlbga+HE8rCimfiIiISL7UwauIiEgfmNmewAPAZOCvwAvAYcDxwIvA0e6+JS39mcCfgFbgD8BWYDGwD3C9u78lj32PAu4AjiYaZvlOYBbwFqAdOMHd/9mX8uZQhu8CHwdWA9cDFUTDLo8HPuTuP+5rmdO2XQoc5+6Wa/lERERECqFgiYiISB+Y2d+BU4APu/uP0pZ/H/gocJm7vz9eNgZ4CRhLFJR4NF5eSRQ0OBI4192vzXHfnwW+QRSkeKu7J+PlZwI3AM8D81PL8y1vDvs/CrgfeBk41N3r4+VzgMeAauDV7r68L2VO23YpCpaIiIjIAFAzHBERkQKZ2TyiwMNy4CfdVn8JaALeYWbV8bKzgUnAtalACYC7twKfj59+IMd9G5AKanwqPbjg7n8F7gX2A47rQ3l7k9r/11OBknj/qfxHARf0pcwiIiIig0HBEhERkcKdEM9v614Twt0biGpdjAaO6Jb+1gx53UPUP8dRcVMVIKqlEXdsurxb+j3/f3t372JHFcZx/PvArkZ8iRIJiJjsJhhfakFMUFEhmEZtNGLjH6A2qQIpJGKl2IiglUIqixQKgiAkrk0wIJYR8+JuREmhBhTfYqKPxZyRyTiTl7l75xr8fprD3nPOPM+t7vJj5gywATiamcsd1/uwVXNIv3UPK6WHhVaNC32frvpDepYkSRqdYYkkScPdUcajPfPHyrjlYusz8xywDMwBm6ZQe+ieTuXuk1uBnzPz1Nj1JUmSpmlu1g1IknQFW1vGH3vm689vHLge4FvgLuDshLWH7gF4BJgvvcyiviRJ0qgMSyRJmp76INJLPU39X+sz8yzVG2umXbt3T2aeGFD/n+2T1pckSRqbj+FIkjRcfSfE2p75G1rrLnf9atYeu37XXSSrWV+SJGlqDEskSRruyzL2nbFxexnrMzp610fEHLAInAO+mkLtoXs6ZeYvVI/lXBcRt4xdX5IkaZoMSyRJGu7jMm6PiPN+UyPiemAb8Bvwafn4YBkf7bjWA1RvojmUmWcuofYJ4GtgS0QsdszvaNUc0u/FXOj7dNUf0rMkSdLoDEskSRqonOXxEbAAPNea3gtcC+wrd2EA7Ae+B56OiHvqhRGxBni5/Plm8yIRMR8Rd0bE5lbtBN4qf77SDD8i4nHgfuAI8MkE/dbX21x6mG/tqevviYibGuvr658B3pmkZ0mSpFmI6v8WSZI0RAkxDgHrgfeBL4B7gYeoHifZmpk/NNY/QRWa/A68C5wGHqN6re5+4Kls/DiX4GEZOJmZC63aV1PdhbEV+Aw4AGwAngT+AB7OzMOT9Fv2rAAbgcXMXGnNvQbsAr4p/V8F7ATWAS9k5huT9tzYuwQ8mJnRNS9JkrRaDEskSZpQRNwGvET1OMo64BTwHrA3M093rN8G7AHuA9YAx4G3gdcz88/W2gV6wpIyfw2wG3iGKnT4CVgCXszMI6vU7wo9YUmZfxZ4Hrgb+Av4HHg1Mz/oqX/ZPZd9SxiWSJKkERiWSJKkK4JhiSRJGsvcrBuQJEnqExE3A9/Nug9JkvT/YlgiSZL+y36lOnxWkiRpND6GI0mSJEmS1OCrgyVJkiRJkhoMSyRJkiRJkhoMSyRJkiRJkhoMSyRJkiRJkhoMSyRJkiRJkhoMSyRJkiRJkhoMSyRJkiRJkhr+BmEk/qb7H4SGAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "infileHSz20_tau40=\"/archive/lmh/SHiELD/202108/C96.L63.solo.HSzurita20.tau40/history/0000000000/atmos_30day_ave.nc\"\n", + "daHSz20_tau40=HSplots(infileHSz20_tau40,slice(300,1400),'Zurita $\\phi_0 = 20$ ($\\\\tau = 40$)')\n", + "\n", + "plt.figure(figsize=(20,5))\n", + "uc=daHSz20_tau40.isel(pfull=slice(0,20)).sel(lat=0,method='nearest').mean(dim='lon').ucomp.T\n", + "uc.plot(yincrease=False)\n", + "uc.plot.contour(colors='k',levels=(0,),linewidths=3,yincrease=False)\n", + "plt.gca().set_yscale('log')\n", + "plt.gca().set_title(\"Equatorial stratospheric $\\overline{U}$\")" + ] + }, + { + "cell_type": "markdown", + "id": "b33f3087", + "metadata": {}, + "source": [ + "If we use the traditional HS94 spatially-varying damping timescale we do not get permanent equatorial superrotation with $\\phi_0 = 20$. It superrotates for the first few months before losing it. " + ] + }, + { + "cell_type": "code", + "execution_count": 199, + "id": "a72c690b", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "infileHSz20=\"/archive/lmh/SHiELD/202108/C96.L63.solo.HSzurita20/history/0000000000/atmos_30day_ave.nc\"\n", + "daHSz20_mean=HSplots(infileHSz20,slice(300,1400),'Zurita $\\phi_0 = 20$, HS94 spatially-varying timescale')" + ] + }, + { + "cell_type": "markdown", + "id": "94895f84", + "metadata": {}, + "source": [ + "# $\\phi_0 = 10$\n", + "\n", + "Superrotation continues at the same strength as for larger $\\phi_0$ but the subtropical jets are weaker. The latter result reproduces Zurita-Gotor et al. (2022) but the former does not." + ] + }, + { + "cell_type": "code", + "execution_count": 205, + "id": "54fd3463", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/net/Lucas.Harris/anaconda3/envs/myenv/lib/python3.9/site-packages/xarray/plot/plot.py:932: UserWarning: No contour levels were found within the data range.\n", + " primitive = ax.contour(x, y, z, **kwargs)\n" + ] + }, + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'Equatorial stratospheric $\\\\overline{U}$')" + ] + }, + "execution_count": 205, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "infileHSz10_tau40=\"/archive/lmh/SHiELD/202108/C96.L63.solo.HSzurita10.tau40/history/0000000000/atmos_30day_ave.nc\"\n", + "daHSz10_tau40=HSplots(infileHSz10_tau40,slice(300,1400),'Zurita $\\phi_0 = 10$ ($\\\\tau = 40$)')\n", + "\n", + "\n", + "plt.figure(figsize=(20,5))\n", + "uc=daHSz10_tau40.isel(pfull=slice(0,20)).sel(lat=0,method='nearest').mean(dim='lon').ucomp.T\n", + "uc.plot(yincrease=False)\n", + "uc.plot.contour(colors='k',levels=(0,),linewidths=3,yincrease=False)\n", + "plt.gca().set_yscale('log')\n", + "plt.gca().set_title(\"Equatorial stratospheric $\\overline{U}$\")" + ] + }, + { + "cell_type": "markdown", + "id": "b11dfcdd", + "metadata": {}, + "source": [ + "For peak forcing at this low lattude we finally get strong superrotation when using the HS94 spatially-varying timescale. Apparently the relatively fast timescales in the HS94 forcing blunts a lot of the effects of the lower-latitude baroclinic forcing. " + ] + }, + { + "cell_type": "code", + "execution_count": 201, + "id": "19be7b7c", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "infileHSz10=\"/archive/lmh/SHiELD/202108/C96.L63.solo.HSzurita10/history/0000000000/atmos_30day_ave.nc\"\n", + "daHSz10_mean=HSplots(infileHSz10,slice(300,1400),'Zurita $\\phi_0 = 10$, HS94 spatially-varying timescale')" + ] + }, + { + "cell_type": "markdown", + "id": "987b7ed2", + "metadata": {}, + "source": [ + "# Overview: equilbrium zonal-mean winds at 150 mb\n", + "\n", + "Compare this plot to Figure 7 in Zurita-Gotor et al. (2022). The results are very similar:\n", + "\n", + "- For $\\phi_0 \\ge 25^\\circ$ we see no superrotation, and the jets move equatorward with the latitude of peak baroclinic forcing. The jet locations are roughly the same as in Z-G22.\n", + "- For $\\phi_0 = 20^\\circ$ clear, strong superrotation appears, and the subtropical jets become much stronger.\n", + "- Superrotation continues for lower forcing latitudes. The subtropical jets remain strong but decrease in strength. \n", + "\n", + "There are some differences:\n", + "\n", + "- The jet strength increases modestly in the earth-like (non-superrotating) regime with decreasing $\\phi_0$.\n", + "- Once the superrotating regime is entered, the strength of equatorial westerlies shows little sensitivity to the forcing latitude.\n", + "- In the superrotating regime the subtropical jets move slightly equatorward with decreasing forcing. The jets are also not as strong in this regime as in Z-G22.\n", + "\n", + "Note that in our runs we are using the GFS-like 63 levels and the nonhydrostatic solver. Some one-off sensitivity tests lead me to believe the results are not sensitive to these parameters but a clean set of tests is forthcoming. " + ] + }, + { + "cell_type": "code", + "execution_count": 197, + "id": "4672940f", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, '150-mb $\\\\overline{U}$, uniform $\\\\tau = 40$-day damping timescale')" + ] + }, + "execution_count": 197, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "infileHS=\"/archive/lmh/SHiELD/202108/C96.L63.solo.HS/history/0000000000/atmos_30day_ave.nc\"\n", + "daHS=xa.open_dataset(infileHS,decode_times=False,chunks={'time': 1}) #xarray is confused by solo_core's NO_CALENDAR\n", + "daHS_ts=daHS.sel(pfull=150,method=\"nearest\").mean(dim=\"lon\")\n", + "\n", + "infileHSz40=\"/archive/lmh/SHiELD/202108/C96.L63.solo.HSzurita40.tau40/history/0000000000/atmos_30day_ave.nc\"\n", + "daHSz40=xa.open_dataset(infileHSz40,decode_times=False,chunks={'time': 1}) #xarray is confused by solo_core's NO_CALENDAR\n", + "daHSz40_ts=daHSz40.sel(pfull=150,method=\"nearest\").mean(dim=\"lon\")\n", + "\n", + "\n", + "infileHSz30=\"/archive/lmh/SHiELD/202108/C96.L63.solo.HSzurita30.tau40/history/0000000000/atmos_30day_ave.nc\"\n", + "daHSz30=xa.open_dataset(infileHSz30,decode_times=False,chunks={'time': 1}) #xarray is confused by solo_core's NO_CALENDAR\n", + "daHSz30_ts=daHSz30.sel(pfull=150,method=\"nearest\").mean(dim=\"lon\")\n", + "\n", + "\n", + "infileHSz25=\"/archive/lmh/SHiELD/202108/C96.L63.solo.HSzurita.tau40/history/0000000000/atmos_30day_ave.nc\"\n", + "daHSz25=xa.open_dataset(infileHSz25,decode_times=False,chunks={'time': 1}) #xarray is confused by solo_core's NO_CALENDAR\n", + "daHSz25_ts=daHSz25.sel(pfull=150,method=\"nearest\").mean(dim=\"lon\")\n", + "\n", + "\n", + "infileHSz20=\"/archive/lmh/SHiELD/202108/C96.L63.solo.HSzurita20.tau40/history/0000000000/atmos_30day_ave.nc\"\n", + "daHSz20=xa.open_dataset(infileHSz20,decode_times=False,chunks={'time': 1}) #xarray is confused by solo_core's NO_CALENDAR\n", + "daHSz20_ts=daHSz20.sel(pfull=150,method=\"nearest\").mean(dim=\"lon\")\n", + "\n", + "\n", + "infileHSz15=\"/archive/lmh/SHiELD/202108/C96.L63.solo.HSzurita15.tau40/history/0000000000/atmos_30day_ave.nc\"\n", + "daHSz15=xa.open_dataset(infileHSz15,decode_times=False,chunks={'time': 1}) #xarray is confused by solo_core's NO_CALENDAR\n", + "daHSz15_ts=daHSz15.sel(pfull=150,method=\"nearest\").mean(dim=\"lon\")\n", + "\n", + "\n", + "infileHSz10=\"/archive/lmh/SHiELD/202108/C96.L63.solo.HSzurita10.tau40/history/0000000000/atmos_30day_ave.nc\"\n", + "daHSz10=xa.open_dataset(infileHSz10,decode_times=False,chunks={'time': 1}) #xarray is confused by solo_core's NO_CALENDAR\n", + "daHSz10_ts=daHSz10.sel(pfull=150,method=\"nearest\").mean(dim=\"lon\")\n", + "\n", + "plt.figure(figsize=(20,5))\n", + "daHS_ts.ucomp.sel(time=slice(300,1400)).mean(dim=\"time\").plot(label='HS94 (var $\\\\tau$)',linewidth='3',color='k')\n", + "daHSz40_ts.ucomp.sel(time=slice(300,1400)).mean(dim=\"time\").plot(label='$\\phi_0$=40')\n", + "daHSz30_ts.ucomp.sel(time=slice(300,1400)).mean(dim=\"time\").plot(label='$\\phi_0$=30')\n", + "daHSz25_ts.ucomp.sel(time=slice(300,1400)).mean(dim=\"time\").plot(label='$\\phi_0$=25')\n", + "daHSz20_ts.ucomp.sel(time=slice(300,1400)).mean(dim=\"time\").plot(label='$\\phi_0$=20')\n", + "daHSz15_ts.ucomp.sel(time=slice(300,1400)).mean(dim=\"time\").plot(label='$\\phi_0$=15')\n", + "daHSz10_ts.ucomp.sel(time=slice(300,1400)).mean(dim=\"time\").plot(label='$\\phi_0$=10')\n", + "plt.gca().plot((-90,90),(0,0),linewidth='0.5',color='k',linestyle=':')\n", + "plt.gca().set_xlim((-90,90))\n", + "plt.legend(loc=\"center left\")\n", + "plt.title(\"150-mb $\\overline{U}$, uniform $\\\\tau = 40$-day damping timescale\");" + ] + }, + { + "cell_type": "markdown", + "id": "8807f0d4", + "metadata": { + "tags": [] + }, + "source": [ + "With the HS94 damping timescale it is much more difficult to enter the superrotating regime. The circulation remains Earth-like until the latitude of forcing reaches $15^\\circ$, and strong superrotation requires the forcing to be still further equatorward. The subtropical jets also do not show significant increases of strength with superrotation, and in fact decelerate a bit when superrotation first appears." + ] + }, + { + "cell_type": "code", + "execution_count": 196, + "id": "35ff8816", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, '150-mb $\\\\overline{U}$, HS94 spatially-varying damping timescale')" + ] + }, + "execution_count": 196, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "infileHS=\"/archive/lmh/SHiELD/202108/C96.L63.solo.HS/history/0000000000/atmos_30day_ave.nc\"\n", + "daHS=xa.open_dataset(infileHS,decode_times=False,chunks={'time': 1}) #xarray is confused by solo_core's NO_CALENDAR\n", + "daHS_ts=daHS.sel(pfull=150,method=\"nearest\").mean(dim=\"lon\")\n", + "\n", + "infileHSz40=\"/archive/lmh/SHiELD/202108/C96.L63.solo.HSzurita40/history/0000000000/atmos_30day_ave.nc\"\n", + "daHSz40=xa.open_dataset(infileHSz40,decode_times=False,chunks={'time': 1}) #xarray is confused by solo_core's NO_CALENDAR\n", + "daHSz40_ts=daHSz40.sel(pfull=150,method=\"nearest\").mean(dim=\"lon\")\n", + "\n", + "\n", + "infileHSz30=\"/archive/lmh/SHiELD/202108/C96.L63.solo.HSzurita30/history/0000000000/atmos_30day_ave.nc\"\n", + "daHSz30=xa.open_dataset(infileHSz30,decode_times=False,chunks={'time': 1}) #xarray is confused by solo_core's NO_CALENDAR\n", + "daHSz30_ts=daHSz30.sel(pfull=150,method=\"nearest\").mean(dim=\"lon\")\n", + "\n", + "\n", + "infileHSz25=\"/archive/lmh/SHiELD/202108/C96.L63.solo.HSzurita/history/0000000000/atmos_30day_ave.nc\"\n", + "daHSz25=xa.open_dataset(infileHSz25,decode_times=False,chunks={'time': 1}) #xarray is confused by solo_core's NO_CALENDAR\n", + "daHSz25_ts=daHSz25.sel(pfull=150,method=\"nearest\").mean(dim=\"lon\")\n", + "\n", + "\n", + "infileHSz20=\"/archive/lmh/SHiELD/202108/C96.L63.solo.HSzurita20/history/0000000000/atmos_30day_ave.nc\"\n", + "daHSz20=xa.open_dataset(infileHSz20,decode_times=False,chunks={'time': 1}) #xarray is confused by solo_core's NO_CALENDAR\n", + "daHSz20_ts=daHSz20.sel(pfull=150,method=\"nearest\").mean(dim=\"lon\")\n", + "\n", + "#infileHSz17_5=\"/archive/lmh/SHiELD/202108/C96.L63.solo.HSzurita17.5/history/0000000000/atmos_30day_ave.nc\"\n", + "#daHSz17_5=xa.open_dataset(infileHSz17_5,decode_times=False,chunks={'time': 1}) #xarray is confused by solo_core's NO_CALENDAR\n", + "#daHSz17_5_ts=daHSz17_5.sel(pfull=150,method=\"nearest\").mean(dim=\"lon\")\n", + "\n", + "infileHSz15=\"/archive/lmh/SHiELD/202108/C96.L63.solo.HSzurita15/history/0000000000/atmos_30day_ave.nc\"\n", + "daHSz15=xa.open_dataset(infileHSz15,decode_times=False,chunks={'time': 1}) #xarray is confused by solo_core's NO_CALENDAR\n", + "daHSz15_ts=daHSz15.sel(pfull=150,method=\"nearest\").mean(dim=\"lon\")\n", + "\n", + "#infileHSz12_5=\"/archive/lmh/SHiELD/202108/C96.L63.solo.HSzurita12.5/history/0000000000/atmos_30day_ave.nc\"\n", + "#daHSz12_5=xa.open_dataset(infileHSz12_5,decode_times=False,chunks={'time': 1}) #xarray is confused by solo_core's NO_CALENDAR\n", + "#daHSz12_5_ts=daHSz12_5.sel(pfull=150,method=\"nearest\").mean(dim=\"lon\")\n", + "\n", + "infileHSz10=\"/archive/lmh/SHiELD/202108/C96.L63.solo.HSzurita10/history/0000000000/atmos_30day_ave.nc\"\n", + "daHSz10=xa.open_dataset(infileHSz10,decode_times=False,chunks={'time': 1}) #xarray is confused by solo_core's NO_CALENDAR\n", + "daHSz10_ts=daHSz10.sel(pfull=150,method=\"nearest\").mean(dim=\"lon\")\n", + "\n", + "plt.figure(figsize=(20,5))\n", + "daHS_ts.ucomp.sel(time=slice(300,1400)).mean(dim=\"time\").plot(label='HS94',linewidth='3',color='k')\n", + "daHSz40_ts.ucomp.sel(time=slice(300,1400)).mean(dim=\"time\").plot(label='d=40')\n", + "daHSz30_ts.ucomp.sel(time=slice(300,1400)).mean(dim=\"time\").plot(label='d=30')\n", + "daHSz25_ts.ucomp.sel(time=slice(300,1400)).mean(dim=\"time\").plot(label='d=25')\n", + "daHSz20_ts.ucomp.sel(time=slice(300,1400)).mean(dim=\"time\").plot(label='d=20')\n", + "#daHSz17_5_ts.ucomp.sel(time=slice(300,1400)).mean(dim=\"time\").plot(label='d=17.5')\n", + "daHSz15_ts.ucomp.sel(time=slice(300,1400)).mean(dim=\"time\").plot(label='d=15')\n", + "#daHSz12_5_ts.ucomp.sel(time=slice(300,1400)).mean(dim=\"time\").plot(label='d=12.5')\n", + "daHSz10_ts.ucomp.sel(time=slice(300,1400)).mean(dim=\"time\").plot(label='d=10')\n", + "plt.gca().plot((-90,90),(0,0),linewidth='0.5',color='k',linestyle=':')\n", + "plt.gca().set_xlim((-90,90))\n", + "plt.legend(loc=\"center left\")\n", + "plt.title(\"150-mb $\\overline{U}$, HS94 spatially-varying damping timescale\");" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.4" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/examples/README.md b/docs/examples/README.md index 58ea1fba6..be519f53d 100644 --- a/docs/examples/README.md +++ b/docs/examples/README.md @@ -1,11 +1,14 @@ # FV3 Examples -This directory contains Python (Jupyter) notebooks demonstrating basic FV3 capabilities, including characteristics of the solver, physics-dynamics coupling, output using FMS diag_manager, and basic analyses of the model output. The notebooks should all be viewable in any browser; you can also download any of them and use them in an up-to-date Python/Jupyter environment. +This directory contains Python (Jupyter) notebooks demonstrating basic FV3 capabilities, including characteristics of the solver, physics-dynamics coupling, output using FMS `diag_manager`, and basic analyses of the model output. The notebooks should all be viewable in any browser; you can also download any of them and use them in an up-to-date Python/Jupyter environment. ## 1D Cases tp_core : 1D advection operators in FV3. This is designed to be an *interactive* notebook for downloading and playing with the options, initial conditions, zooms, and so on. +fv3_level_transmogrifier +: An *interactive* notebook that shows different hybrid-level setups within FV3, and allows detection of discontinuities within the levels that may cause errors or instabilities. The directory contains the notebook and its dependencies, including source for a Python-wrapped version of `set_eta()`. + ## 2D Global Shallow-water Cases RHwave : Rossby-Haurwitz wave, a test of height-vorticity consistency @@ -33,6 +36,9 @@ mtn_rest_100km TornadicSupercell : Global super-stretched grid with Toy semi-circle hodograph creating supercell thunderstorms with tornado-like vortices, demonstrating the importance of vorticity preservation at kilometer scales. See animations on [Google Drive](https://drive.google.com/drive/folders/1pVNAuKrYKwxVAlCdVa5faIVRBaK2hdVI) (noaa.gov only). +HSzuritasuperrotation +: The classic Held-Suarez idealized climate, with modifications from [Zurita-Gotor et al. (JAS, 2022)](https://journals.ametsoc.org/view/journals/atsc/79/5/JAS-D-21-0269.1.xml) to demonstrate superrotation. + ## 2D Periodic MountainWaveIC diff --git a/driver/GFDL/atmosphere.F90 b/driver/GFDL/atmosphere.F90 index ccab7590a..2202ca515 100644 --- a/driver/GFDL/atmosphere.F90 +++ b/driver/GFDL/atmosphere.F90 @@ -10,7 +10,7 @@ !* (at your option) any later version. !* !* The FV3 dynamical core is distributed in the hope that it will be -!* useful, but WITHOUT ANYWARRANTY; without even the implied warranty +!* useful, but WITHOUT ANY WARRANTY; without even the implied warranty !* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. !* See the GNU General Public License for more details. !* @@ -45,7 +45,7 @@ module atmosphere_mod use mpp_mod, only: mpp_error, FATAL, NOTE, input_nml_file, & mpp_npes, mpp_get_current_pelist, & mpp_set_current_pelist, stdout, & - mpp_pe, mpp_root_pe, mpp_chksum + mpp_pe, mpp_root_pe, mpp_chksum, mpp_sync use mpp_domains_mod, only: domain2d use xgrid_mod, only: grid_box_type !miz @@ -96,7 +96,7 @@ module atmosphere_mod use mpp_domains_mod, only: mpp_get_data_domain, mpp_get_compute_domain use gfdl_mp_mod, only: gfdl_mp_init, gfdl_mp_end -use cloud_diagnosis_mod,only: cloud_diagnosis_init +use cld_eff_rad_mod, only: cld_eff_rad_init use coarse_graining_mod, only: coarse_graining_init use coarse_grained_diagnostics_mod, only: fv_coarse_diag_init, fv_coarse_diag use coarse_grained_restart_files_mod, only: fv_coarse_restart_init @@ -309,11 +309,12 @@ subroutine atmosphere_init (Time_init, Time, Time_step, Surf_diff, Grid_box) allocate(pref(npz+1,2), dum1d(npz+1)) if (Atm(mygrid)%flagstruct%do_inline_mp) then - call gfdl_mp_init(mpp_pe(), mpp_root_pe(), nlunit, input_nml_file, stdlog(), fn_nml) - call cloud_diagnosis_init(nlunit, input_nml_file, stdlog(), fn_nml) + call gfdl_mp_init(input_nml_file, stdlog()) + call cld_eff_rad_init(input_nml_file, stdlog()) endif - call fv_restart(Atm(mygrid)%domain, Atm, dt_atmos, seconds, days, cold_start, Atm(mygrid)%gridstruct%grid_type, mygrid) + call fv_restart(Atm(mygrid)%domain, Atm, dt_atmos, seconds, days, cold_start, & + Atm(mygrid)%gridstruct%grid_type, mygrid) fv_time = Time @@ -372,7 +373,7 @@ subroutine atmosphere_init (Time_init, Time, Time_step, Surf_diff, Grid_box) if ( Atm(mygrid)%flagstruct%nudge ) then call fv_ada_nudge_init( Time, Atm(mygrid)%atmos_axes, npz, zvir, Atm(mygrid)%ak, Atm(mygrid)%bk, & Atm(mygrid)%ts, Atm(mygrid)%phis, Atm(mygrid)%gridstruct, Atm(mygrid)%ks, Atm(mygrid)%npx, & - Atm(mygrid)%neststruct, Atm(mygrid)%bd, Atm(mygrid)%domain) + Atm(mygrid)%neststruct, Atm(mygrid)%bd, Atm(mygrid)%domain_for_read) call mpp_error(NOTE, 'ADA nudging is active') endif #else @@ -594,11 +595,12 @@ subroutine atmosphere_dynamics ( Time, Surf_diff ) Atm(n)%flagstruct%hybrid_z, & Atm(n)%gridstruct, Atm(n)%flagstruct, & Atm(n)%neststruct, Atm(n)%idiag, Atm(n)%bd, & - Atm(n)%parent_grid, Atm(n)%domain, Atm(n)%inline_mp) - + Atm(n)%parent_grid, Atm(n)%domain, Atm(n)%inline_mp, & + Atm(n)%diss_est) call timing_off('fv_dynamics') if (ngrids > 1 .and. (psc < p_split .or. p_split < 0)) then + call mpp_sync() call timing_on('TWOWAY_UPDATE') call twoway_nesting(Atm, ngrids, grids_on_this_pe, zvir, fv_time, mygrid) call timing_off('TWOWAY_UPDATE') @@ -1108,7 +1110,7 @@ subroutine atmosphere_state_update (Time, Physics_tendency, Physics, Atm_block) call fv_diag(Atm(mygrid:mygrid), zvir, fv_time, Atm(mygrid)%flagstruct%print_freq) if (Atm(mygrid)%coarse_graining%write_coarse_diagnostics) then - call fv_coarse_diag(Atm(mygrid:mygrid), fv_time) + call fv_coarse_diag(Atm(mygrid:mygrid), fv_time, zvir) endif call fv_cmip_diag(Atm(mygrid:mygrid), zvir, fv_time) @@ -1219,7 +1221,7 @@ subroutine adiabatic_init(zvir,nudge_dz) Atm(mygrid)%cx, Atm(mygrid)%cy, Atm(mygrid)%ze0, Atm(mygrid)%flagstruct%hybrid_z, & Atm(mygrid)%gridstruct, Atm(mygrid)%flagstruct, & Atm(mygrid)%neststruct, Atm(mygrid)%idiag, Atm(mygrid)%bd, Atm(mygrid)%parent_grid, & - Atm(mygrid)%domain, Atm(mygrid)%inline_mp) + Atm(mygrid)%domain, Atm(mygrid)%inline_mp, Atm(n)%diss_est) ! Backward call fv_dynamics(Atm(mygrid)%npx, Atm(mygrid)%npy, npz, nq, Atm(mygrid)%ng, -dt_atmos, 0., & Atm(mygrid)%flagstruct%fill, Atm(mygrid)%flagstruct%reproduce_sum, kappa, cp_air, zvir, & @@ -1233,7 +1235,7 @@ subroutine adiabatic_init(zvir,nudge_dz) Atm(mygrid)%cx, Atm(mygrid)%cy, Atm(mygrid)%ze0, Atm(mygrid)%flagstruct%hybrid_z, & Atm(mygrid)%gridstruct, Atm(mygrid)%flagstruct, & Atm(mygrid)%neststruct, Atm(mygrid)%idiag, Atm(mygrid)%bd, Atm(mygrid)%parent_grid, & - Atm(mygrid)%domain, Atm(mygrid)%inline_mp) + Atm(mygrid)%domain, Atm(mygrid)%inline_mp, Atm(n)%diss_est) ! Nudging back to IC !$omp parallel do default (none) & !$omp shared (pref, npz, jsc, jec, isc, iec, n, sphum, Atm, u0, v0, t0, dp0, xt, zvir, mygrid, nudge_dz, dz0) & @@ -1305,7 +1307,7 @@ subroutine adiabatic_init(zvir,nudge_dz) Atm(mygrid)%cx, Atm(mygrid)%cy, Atm(mygrid)%ze0, Atm(mygrid)%flagstruct%hybrid_z, & Atm(mygrid)%gridstruct, Atm(mygrid)%flagstruct, & Atm(mygrid)%neststruct, Atm(mygrid)%idiag, Atm(mygrid)%bd, Atm(mygrid)%parent_grid, & - Atm(mygrid)%domain, Atm(mygrid)%inline_mp) + Atm(mygrid)%domain, Atm(mygrid)%inline_mp, Atm(n)%diss_est) ! Forward call call fv_dynamics(Atm(mygrid)%npx, Atm(mygrid)%npy, npz, nq, Atm(mygrid)%ng, dt_atmos, 0., & Atm(mygrid)%flagstruct%fill, Atm(mygrid)%flagstruct%reproduce_sum, kappa, cp_air, zvir, & @@ -1319,7 +1321,7 @@ subroutine adiabatic_init(zvir,nudge_dz) Atm(mygrid)%cx, Atm(mygrid)%cy, Atm(mygrid)%ze0, Atm(mygrid)%flagstruct%hybrid_z, & Atm(mygrid)%gridstruct, Atm(mygrid)%flagstruct, & Atm(mygrid)%neststruct, Atm(mygrid)%idiag, Atm(mygrid)%bd, Atm(mygrid)%parent_grid, & - Atm(mygrid)%domain, Atm(mygrid)%inline_mp) + Atm(mygrid)%domain, Atm(mygrid)%inline_mp, Atm(n)%diss_est) ! Nudging back to IC !$omp parallel do default (none) & !$omp shared (nudge_dz,npz, jsc, jec, isc, iec, n, sphum, Atm, u0, v0, t0, dz0, dp0, xt, zvir, mygrid) & diff --git a/driver/SHiELD/atmosphere.F90 b/driver/SHiELD/atmosphere.F90 index 869bf2cfe..8d9e3ceac 100644 --- a/driver/SHiELD/atmosphere.F90 +++ b/driver/SHiELD/atmosphere.F90 @@ -10,7 +10,7 @@ !* (at your option) any later version. !* !* The FV3 dynamical core is distributed in the hope that it will be -!* useful, but WITHOUT ANYWARRANTY; without even the implied warranty +!* useful, but WITHOUT ANY WARRANTY; without even the implied warranty !* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. !* See the GNU General Public License for more details. !* @@ -18,6 +18,7 @@ !* License along with the FV3 dynamical core. !* If not, see . !*********************************************************************** + module atmosphere_mod #include @@ -53,6 +54,8 @@ module atmosphere_mod use tracer_manager_mod, only: get_tracer_index, get_number_tracers, & NO_TRACER, get_tracer_names use IPD_typedefs, only: IPD_data_type, kind_phys +use data_override_mod, only: data_override_init +use fv_iau_mod, only: IAU_external_data_type !----------------- ! FV core modules: @@ -61,6 +64,7 @@ module atmosphere_mod use fv_control_mod, only: fv_control_init, fv_end, ngrids use fv_eta_mod, only: get_eta_level use fv_fill_mod, only: fill_gfs +use dyn_core_mod, only: del2_cubed use fv_dynamics_mod, only: fv_dynamics use fv_nesting_mod, only: twoway_nesting use fv_diagnostics_mod, only: fv_diag_init, fv_diag, fv_time, prt_maxmin, prt_height @@ -75,14 +79,15 @@ module atmosphere_mod use fv_regional_mod, only: start_regional_restart, read_new_bc_data use fv_regional_mod, only: a_step, p_step use fv_regional_mod, only: current_time_in_seconds +use fv_grid_utils_mod, only: g_sum use mpp_domains_mod, only: mpp_get_data_domain, mpp_get_compute_domain use gfdl_mp_mod, only: gfdl_mp_init, gfdl_mp_end -use cloud_diagnosis_mod,only: cloud_diagnosis_init +use cld_eff_rad_mod, only: cld_eff_rad_init +use diag_manager_mod, only: send_data use coarse_graining_mod, only: coarse_graining_init use coarse_grained_diagnostics_mod, only: fv_coarse_diag_init, fv_coarse_diag use coarse_grained_restart_files_mod, only: fv_coarse_restart_init -use diag_manager_mod, only: send_data implicit none private @@ -98,13 +103,16 @@ module atmosphere_mod atmosphere_diag_axes, atmosphere_etalvls, & atmosphere_hgt, atmosphere_scalar_field_halo, & !rab atmosphere_tracer_postinit, & -! atmosphere_diss_est, & + atmosphere_diss_est, & ! dissipation estimate for SKEB atmosphere_nggps_diag, & get_bottom_mass, get_bottom_wind, & - get_stock_pe, set_atmosphere_pelist + get_stock_pe, set_atmosphere_pelist, & + atmosphere_coarse_diag_axes !--- physics/radiation data exchange routines public :: atmos_phys_driver_statein +public :: atmosphere_coarse_graining_parameters +public :: atmosphere_coarsening_strategy !----------------------------------------------------------------------- ! version number of this module @@ -114,7 +122,7 @@ module atmosphere_mod !---- private data ---- type (time_type) :: Time_step_atmos - public Atm + public Atm, mygrid !These are convenience variables for local use only, and are set to values in Atm% real :: dt_atmos @@ -142,7 +150,7 @@ module atmosphere_mod !---dynamics tendencies for use in fv_subgrid_z and during fv_update_phys real, allocatable, dimension(:,:,:) :: u_dt, v_dt, t_dt, qv_dt - real, allocatable :: pref(:,:), dum1d(:) + real, allocatable :: pref(:,:), dum1d(:), ps_dt(:,:) logical :: first_diag = .true. @@ -150,9 +158,10 @@ module atmosphere_mod - subroutine atmosphere_init (Time_init, Time, Time_step, Grid_box, area) + subroutine atmosphere_init (Time_init, Time, Time_step, Grid_box, area, IAU_Data) type (time_type), intent(in) :: Time_init, Time, Time_step type(grid_box_type), intent(inout) :: Grid_box + type(iau_external_data_type), intent(out) :: IAU_Data real(kind=kind_phys), pointer, dimension(:,:), intent(inout) :: area !--- local variables --- integer :: i, n @@ -268,16 +277,16 @@ subroutine atmosphere_init (Time_init, Time, Time_step, Grid_box, area) allocate( u_dt(isd:ied,jsd:jed,npz), & v_dt(isd:ied,jsd:jed,npz), & t_dt(isc:iec,jsc:jec,npz), & - qv_dt(isc:iec,jsc:jec,npz) ) + qv_dt(isc:iec,jsc:jec,npz), & + ps_dt(isd:ied,jsd:jed) ) + !--- allocate pref allocate(pref(npz+1,2), dum1d(npz+1)) - if (Atm(mygrid)%flagstruct%do_inline_mp) then - call gfdl_mp_init(mpp_pe(), mpp_root_pe(), nlunit, input_nml_file, stdlog(), fn_nml) - call cloud_diagnosis_init(nlunit, input_nml_file, stdlog(), fn_nml) - endif - - call fv_restart(Atm(mygrid)%domain, Atm, dt_atmos, seconds, days, cold_start, Atm(mygrid)%gridstruct%grid_type, mygrid) + call gfdl_mp_init(input_nml_file, stdlog()) + call cld_eff_rad_init(input_nml_file, stdlog()) + call fv_restart(Atm(mygrid)%domain, Atm, dt_atmos, seconds, days, cold_start, & + Atm(mygrid)%gridstruct%grid_type, mygrid) fv_time = Time @@ -348,10 +357,15 @@ subroutine atmosphere_init (Time_init, Time, Time_step, Grid_box, area) #ifdef DEBUG call fv_diag(Atm(mygrid:mygrid), zvir, Time, -1) if (Atm(mygrid)%coarse_graining%write_coarse_diagnostics) then - call fv_coarse_diag(Atm(mygrid:mygrid), fv_time) + call fv_coarse_diag(Atm(mygrid:mygrid), fv_time, zvir) endif #endif + if ( trim(Atm(mygrid)%flagstruct%grid_file) .NE. "Inline" .and. trim(Atm(mygrid)%flagstruct%grid_file) .NE. "" & + & .and. .NOT.Atm(mygrid)%gridstruct%bounded_domain ) then + call data_override_init(Atm_domain_in = Atm(mygrid)%domain) + endif + end subroutine atmosphere_init @@ -434,6 +448,10 @@ subroutine atmosphere_dynamics ( Time ) call read_new_bc_data(Atm(n), Time, Time_step_atmos, p_split, & isd, ied, jsd, jed ) endif + +!save ps to ps_dt before dynamics update + ps_dt(:,:)=Atm(n)%ps(:,:) + do psc=1,abs(p_split) p_step = psc call timing_on('fv_dynamics') @@ -454,8 +472,8 @@ subroutine atmosphere_dynamics ( Time ) Atm(n)%flagstruct%hybrid_z, & Atm(n)%gridstruct, Atm(n)%flagstruct, & Atm(n)%neststruct, Atm(n)%idiag, Atm(n)%bd, & - Atm(n)%parent_grid, Atm(n)%domain, Atm(n)%inline_mp) - + Atm(n)%parent_grid, Atm(n)%domain, Atm(n)%inline_mp, & + Atm(n)%diss_est) call timing_off('fv_dynamics') if (ngrids > 1 .and. (psc < p_split .or. p_split < 0)) then @@ -466,6 +484,24 @@ subroutine atmosphere_dynamics ( Time ) endif end do !p_split + + if (.not. Atm(n)%flagstruct%hydrostatic .and. .not. Atm(n)%flagstruct%pass_full_omega_to_physics_in_non_hydrostatic_mode) then + Atm(n)%local_omga(isc:iec,jsc:jec,1:npz) = Atm(n)%delp(isc:iec,jsc:jec,1:npz) / Atm(n)%delz(isc:iec,jsc:jec,1:npz) * Atm(n)%w(isc:iec,jsc:jec,1:npz) + if(Atm(n)%flagstruct%nf_omega>0) then + call del2_cubed(& + Atm(n)%local_omga, & + 0.18*Atm(n)%gridstruct%da_min, & + Atm(n)%gridstruct, & + Atm(n)%domain, & + Atm(n)%npx, & + Atm(n)%npy, & + Atm(n)%npz, & + Atm(n)%flagstruct%nf_omega, & + Atm(n)%bd) + endif + endif + + call mpp_clock_end (id_dynam) !----------------------------------------------------- @@ -475,6 +511,10 @@ subroutine atmosphere_dynamics ( Time ) call mpp_clock_begin (id_subgridz) u_dt(:,:,:) = 0. ! These are updated by fv_subgrid_z v_dt(:,:,:) = 0. +! t_dt is used for two different purposes: +! 1 - to calculate the diagnostic temperature tendency from fv_subgrid_z +! 2 - as an accumulator for the IAU increment and physics tendency +! because of this, it will need to be zeroed out after the diagnostic is calculated t_dt(:,:,:) = Atm(n)%pt(isc:iec,jsc:jec,:) qv_dt(:,:,:) = Atm(n)%q (isc:iec,jsc:jec,:,sphum) @@ -506,20 +546,23 @@ subroutine atmosphere_dynamics ( Time ) endif #endif - if (Atm(1)%idiag%id_u_dt_sg > 0) then - used = send_data(Atm(1)%idiag%id_u_dt_sg, u_dt(isc:iec,jsc:jec,:), fv_time) - end if - if (Atm(1)%idiag%id_v_dt_sg > 0) then - used = send_data(Atm(1)%idiag%id_v_dt_sg, v_dt(isc:iec,jsc:jec,:), fv_time) - end if - if (Atm(1)%idiag%id_t_dt_sg > 0) then + if (allocated(Atm(n)%sg_diag%u_dt)) then + Atm(n)%sg_diag%u_dt = u_dt(isc:iec,jsc:jec,:) + endif + if (allocated(Atm(n)%sg_diag%v_dt)) then + Atm(n)%sg_diag%v_dt = v_dt(isc:iec,jsc:jec,:) + endif + if (allocated(Atm(n)%sg_diag%t_dt)) then t_dt(:,:,:) = rdt*(Atm(1)%pt(isc:iec,jsc:jec,:) - t_dt(:,:,:)) - used = send_data(Atm(1)%idiag%id_t_dt_sg, t_dt, fv_time) - end if - if (Atm(1)%idiag%id_qv_dt_sg > 0) then + Atm(n)%sg_diag%t_dt = t_dt(isc:iec,jsc:jec,:) + endif + if (allocated(Atm(n)%sg_diag%qv_dt)) then qv_dt(:,:,:) = rdt*(Atm(1)%q(isc:iec,jsc:jec,:,sphum) - qv_dt(:,:,:)) - used = send_data(Atm(1)%idiag%id_qv_dt_sg, qv_dt, fv_time) - end if + Atm(n)%sg_diag%qv_dt = qv_dt(isc:iec,jsc:jec,:) + endif + +! zero out t_dt for use as an accumulator + t_dt = 0. call mpp_clock_end (id_subgridz) @@ -533,8 +576,7 @@ subroutine atmosphere_end (Time, Grid_box )!rab, Radiation, Physics) !rab type (physics_type), intent(inout) :: Physics ! initialize domains for writing global physics data - if ( Atm(mygrid)%flagstruct%nudge ) call fv_nwp_nudge_end - + if ( Atm(mygrid)%flagstruct%nudge ) call fv_nwp_nudge_end if (Atm(mygrid)%flagstruct%do_inline_mp) then call gfdl_mp_end ( ) @@ -545,7 +587,7 @@ subroutine atmosphere_end (Time, Grid_box )!rab, Radiation, Physics) call fv_diag(Atm(mygrid:mygrid), zvir, fv_time, Atm(mygrid)%flagstruct%print_freq) call fv_nggps_diag(Atm(mygrid:mygrid), zvir, fv_time) if (Atm(mygrid)%coarse_graining%write_coarse_diagnostics) then - call fv_coarse_diag(Atm(mygrid:mygrid), fv_time) + call fv_coarse_diag(Atm(mygrid:mygrid), fv_time, zvir) endif first_diag = .false. call timing_off('FV_DIAG') @@ -554,7 +596,7 @@ subroutine atmosphere_end (Time, Grid_box )!rab, Radiation, Physics) call fv_end(Atm, mygrid) deallocate (Atm) - deallocate( u_dt, v_dt, t_dt, qv_dt, pref, dum1d ) + deallocate( u_dt, v_dt, t_dt, qv_dt, ps_dt, pref, dum1d ) end subroutine atmosphere_end @@ -601,9 +643,10 @@ subroutine atmosphere_pref (p_ref) end subroutine atmosphere_pref - subroutine atmosphere_control_data (i1, i2, j1, j2, kt, p_hydro, hydro) + subroutine atmosphere_control_data (i1, i2, j1, j2, kt, p_hydro, hydro, tile_num) integer, intent(out) :: i1, i2, j1, j2, kt logical, intent(out), optional :: p_hydro, hydro + integer, intent(out), optional :: tile_num i1 = Atm(mygrid)%bd%isc i2 = Atm(mygrid)%bd%iec j1 = Atm(mygrid)%bd%jsc @@ -612,7 +655,13 @@ subroutine atmosphere_control_data (i1, i2, j1, j2, kt, p_hydro, hydro) if (present(p_hydro)) p_hydro = Atm(mygrid)%flagstruct%phys_hydrostatic if (present( hydro)) hydro = Atm(mygrid)%flagstruct%hydrostatic - + if (present(tile_num)) then + if (Atm(mygrid)%gridstruct%nested) then + tile_num = Atm(mygrid)%tile_of_mosaic + 6 + else + tile_num = Atm(mygrid)%tile_of_mosaic + endif + endif end subroutine atmosphere_control_data @@ -664,17 +713,20 @@ subroutine set_atmosphere_pelist () end subroutine set_atmosphere_pelist - subroutine atmosphere_domain ( fv_domain, layout, regional ) - type(domain2d), intent(out) :: fv_domain + subroutine atmosphere_domain ( fv_domain, rd_domain, layout, regional, bounded_domain ) + type(domain2d), intent(out) :: fv_domain, rd_domain integer, intent(out) :: layout(2) logical, intent(out) :: regional + logical, intent(out) :: bounded_domain ! returns the domain2d variable associated with the coupling grid ! note: coupling is done using the mass/temperature grid with no halos fv_domain = Atm(mygrid)%domain_for_coupler + rd_domain = Atm(mygrid)%domain_for_read layout(1:2) = Atm(mygrid)%layout(1:2) regional = Atm(mygrid)%flagstruct%regional + bounded_domain = Atm(mygrid)%gridstruct%bounded_domain end subroutine atmosphere_domain @@ -691,6 +743,17 @@ subroutine atmosphere_diag_axes ( axes ) end subroutine atmosphere_diag_axes + !>@brief The subroutine 'atmosphere_coarse_diag_axes' is an API to return the axis indices + !! for the coarse atmospheric (mass) grid. + subroutine atmosphere_coarse_diag_axes(coarse_axes) + integer, intent(out) :: coarse_axes(4) + + coarse_axes = (/ & + Atm(mygrid)%coarse_graining%id_xt_coarse, & + Atm(mygrid)%coarse_graining%id_yt_coarse, & + Atm(mygrid)%coarse_graining%id_pfull, & + Atm(mygrid)%coarse_graining%id_phalf /) + end subroutine atmosphere_coarse_diag_axes subroutine atmosphere_etalvls (ak, bk, flip) real(kind=kind_phys), pointer, dimension(:), intent(inout) :: ak, bk @@ -858,6 +921,30 @@ subroutine atmosphere_scalar_field_halo (data, halo, isize, jsize, ksize, data_p return end subroutine atmosphere_scalar_field_halo + subroutine atmosphere_diss_est (npass) + use dyn_core_mod, only: del2_cubed + !--- interface variables --- + integer, intent(in) :: npass + !--- local variables + integer:: k + + !horizontally smooth dissiapation estimate for SKEB + ! 3 passes before taking absolute value + do k = 1,min(3,npass) + call del2_cubed(Atm(mygrid)%diss_est, 0.25*Atm(mygrid)%gridstruct%da_min, Atm(mygrid)%gridstruct, & + Atm(mygrid)%domain, npx, npy, npz, 3, Atm(mygrid)%bd) + enddo + + Atm(mygrid)%diss_est=abs(Atm(mygrid)%diss_est) + + do k = 4,npass + call del2_cubed(Atm(mygrid)%diss_est, 0.25*Atm(mygrid)%gridstruct%da_min, Atm(mygrid)%gridstruct, & + Atm(mygrid)%domain, npx, npy, npz, 3, Atm(mygrid)%bd) + enddo + ! provide back sqrt of dissipation estimate + Atm(mygrid)%diss_est=sqrt(abs(Atm(mygrid)%diss_est)) + + end subroutine atmosphere_diss_est subroutine atmosphere_nggps_diag (Time, init) !---------------------------------------------- @@ -1056,17 +1143,19 @@ subroutine get_stock_pe(index, value) end subroutine get_stock_pe - subroutine atmosphere_state_update (Time, IPD_Data, Atm_block) + subroutine atmosphere_state_update (Time, IPD_Data, IAU_Data, Atm_block) !--- interface variables --- type(time_type), intent(in) :: Time type(IPD_data_type), intent(in) :: IPD_Data(:) + type(IAU_external_data_type), intent(in) :: IAU_Data type(block_control_type), intent(in) :: Atm_block !--- local variables --- type(time_type) :: Time_prev, Time_next integer :: i, j, ix, k, k1, n, w_diff, nt_dyn, iq integer :: nb, blen, nwat, dnats, nq_adv real(kind=kind_phys):: rcp, q0, qwat(nq), qt, rdt - real :: tracer_clock, lat_thresh + real :: psum, qsum, psumb, qsumb, betad, psdt_mean + real :: tracer_clock, lat_thresh, fhr character(len=32) :: tracer_name Time_prev = Time @@ -1081,6 +1170,57 @@ subroutine atmosphere_state_update (Time, IPD_Data, Atm_block) if( nq<3 ) call mpp_error(FATAL, 'GFS phys must have 3 interactive tracers') + if (IAU_Data%in_interval) then + if (IAU_Data%drymassfixer) then + ! global mean total pressure and water before IAU + psumb = g_sum(Atm(n)%domain,sum(Atm(n)%delp(isc:iec,jsc:jec,1:npz),dim=3),& + isc,iec,jsc,jec,Atm(n)%ng,Atm(n)%gridstruct%area_64,1,reproduce=.true.) + qsumb = g_sum(Atm(n)%domain,& + sum(Atm(n)%delp(isc:iec,jsc:jec,1:npz)*sum(Atm(n)%q(isc:iec,jsc:jec,1:npz,1:nwat),4),dim=3),& + isc,iec,jsc,jec,Atm(n)%ng,Atm(n)%gridstruct%area_64,1,reproduce=.true.) + if (is_master()) then + print *,'dry ps before IAU/physics',psumb+Atm(n)%ptop-qsumb + endif + endif + +! IAU increments are in units of 1/sec + +! add analysis increment to u,v,t tendencies +! directly update delp with analysis increment + do k = 1, npz + do j = jsc,jec + do i = isc,iec + u_dt(i,j,k) = u_dt(i,j,k) + IAU_Data%ua_inc(i,j,k) + v_dt(i,j,k) = v_dt(i,j,k) + IAU_Data%va_inc(i,j,k) + t_dt(i,j,k) = t_dt(i,j,k) + IAU_Data%temp_inc(i,j,k) + Atm(n)%delp(i,j,k) = Atm(n)%delp(i,j,k) + IAU_Data%delp_inc(i,j,k)*dt_atmos + enddo + enddo + enddo + if (.not. Atm(n)%flagstruct%hydrostatic) then + do k = 1, npz + do j = jsc,jec + do i = isc,iec + Atm(n)%delz(i,j,k) = Atm(n)%delz(i,j,k) + IAU_Data%delz_inc(i,j,k)*dt_atmos + enddo + enddo + enddo + endif +! add analysis increment to tracers to output from physics + do nb = 1,Atm_block%nblks + !if (nb.EQ.1) print*,'in block_update',IAU_Data%in_interval,IAU_Data%temp_inc(isc,jsc,30) + blen = Atm_block%blksz(nb) + do k = 1, npz + k1 = npz+1-k !reverse the k direction + do ix = 1, blen + i = Atm_block%index(nb)%ii(ix) + j = Atm_block%index(nb)%jj(ix) + IPD_Data(nb)%Stateout%gq0(ix,k,:) = IPD_Data(nb)%Stateout%gq0(ix,k,:) + IAU_Data%tracer_inc(i,j,k1,:)*dt_atmos + enddo + enddo + enddo + endif + call timing_on('GFS_TENDENCIES') call atmos_phys_qdt_diag(Atm(n)%q, Atm(n)%phys_diag, nt_dyn, dt_atmos, .true.) @@ -1114,7 +1254,8 @@ subroutine atmosphere_state_update (Time, IPD_Data, Atm_block) j = Atm_block%index(nb)%jj(ix) u_dt(i,j,k1) = u_dt(i,j,k1) + (IPD_Data(nb)%Stateout%gu0(ix,k) - IPD_Data(nb)%Statein%ugrs(ix,k)) * rdt v_dt(i,j,k1) = v_dt(i,j,k1) + (IPD_Data(nb)%Stateout%gv0(ix,k) - IPD_Data(nb)%Statein%vgrs(ix,k)) * rdt - t_dt(i,j,k1) = (IPD_Data(nb)%Stateout%gt0(ix,k) - IPD_Data(nb)%Statein%tgrs(ix,k)) * rdt + t_dt(i,j,k1) = t_dt(i,j,k1) + (IPD_Data(nb)%Stateout%gt0(ix,k) - IPD_Data(nb)%Statein%tgrs(ix,k)) * rdt + !t_dt(i,j,k1) = (IPD_Data(nb)%Stateout%gt0(ix,k) - IPD_Data(nb)%Statein%tgrs(ix,k)) * rdt ! SJL notes: ! ---- DO not touch the code below; dry mass conservation may change due to 64bit <-> 32bit conversion ! GFS total air mass = dry_mass + water_vapor (condensate excluded) @@ -1166,6 +1307,25 @@ subroutine atmosphere_state_update (Time, IPD_Data, Atm_block) enddo ! nb-loop +! dry mass fixer in IAU interval following +! https://onlinelibrary.wiley.com/doi/full/10.1111/j.1600-0870.2007.00299.x + if (IAU_Data%in_interval .and. IAU_data%drymassfixer) then + ! global mean total pressure + psum = g_sum(Atm(n)%domain,sum(Atm(n)%delp(isc:iec,jsc:jec,1:npz),dim=3),& + isc,iec,jsc,jec,Atm(n)%ng,Atm(n)%gridstruct%area_64,1,reproduce=.true.) + ! global mean total water (before adjustment) + qsum = g_sum(Atm(n)%domain,& + sum(Atm(n)%delp(isc:iec,jsc:jec,1:npz)*sum(Atm(n)%q(isc:iec,jsc:jec,1:npz,1:nwat),4),dim=3),& + isc,iec,jsc,jec,Atm(n)%ng,Atm(n)%gridstruct%area_64,1,reproduce=.true.) + betad = (psum - (psumb - qsumb))/qsum + !if (is_master()) print *,'dry ps after IAU/physics',psum+Atm(n)%ptop-qsum, betad + Atm(n)%q(:,:,:,1:nwat) = betad*Atm(n)%q(:,:,:,1:nwat) + qsum = g_sum(Atm(n)%domain,& + sum(Atm(n)%delp(isc:iec,jsc:jec,1:npz)*sum(Atm(n)%q(isc:iec,jsc:jec,1:npz,1:nwat),4),dim=3),& + isc,iec,jsc,jec,Atm(n)%ng,Atm(n)%gridstruct%area_64,1) + !if (is_master()) print *,'dry ps after iau_drymassfixer',psum+Atm(n)%ptop-qsum + endif + call atmos_phys_qdt_diag(Atm(n)%q, Atm(n)%phys_diag, nt_dyn, dt_atmos, .false.) call timing_off('GFS_TENDENCIES') @@ -1212,17 +1372,38 @@ subroutine atmosphere_state_update (Time, IPD_Data, Atm_block) call timing_off('FV_UPDATE_PHYS') call mpp_clock_end (id_dynam) +!MT surface pressure tendency (hPa/3hr) + ps_dt(:,:)=(Atm(n)%ps(:,:)-ps_dt(:,:))*rdt*108. + psdt_mean = g_sum(Atm(n)%domain,ABS(ps_dt(isc:iec,jsc:jec)),isc,iec,jsc,jec, & + Atm(n)%ng,Atm(n)%gridstruct%area_64,1,reproduce=.true.) + do nb = 1,Atm_block%nblks + blen = Atm_block%blksz(nb) + do ix = 1, blen + i = Atm_block%index(nb)%ii(ix) + j = Atm_block%index(nb)%jj(ix) + IPD_Data(nb)%intdiag%ps_dt(ix)=ps_dt(i,j) + enddo + enddo + + if (is_master()) then + fhr=time_type_to_real( Time_next - Atm(n)%Time_init )/3600. + if (fhr <= 12.0 .or. (fhr - int(fhr)) == 0.0) then + write(555,*) fhr, psdt_mean + endif + endif !LMH 7jan2020: Update PBL and other clock tracers, if present tracer_clock = time_type_to_real(Time_next - Atm(n)%Time_init)*1.e-6 + lat_thresh = 15.*pi/180. do iq = 1, nq call get_tracer_names (MODEL_ATMOS, iq, tracer_name) - if (trim(tracer_name) == 'pbl_clock') then + if (trim(tracer_name) == 'pbl_clock' .or. trim(tracer_name) == 'tro_pbl_clock') then do nb = 1,Atm_block%nblks blen = Atm_block%blksz(nb) do ix = 1, blen i = Atm_block%index(nb)%ii(ix) j = Atm_block%index(nb)%jj(ix) + if (trim(tracer_name) == 'tro_pbl_clock' .and. abs(Atm(n)%gridstruct%agrid(i,j,2)) > lat_thresh) cycle do k=1,npz k1 = npz+1-k !reverse the k direction Atm(n)%q(i,j,k1,iq) = tracer_clock @@ -1237,7 +1418,6 @@ subroutine atmosphere_state_update (Time, IPD_Data, Atm_block) enddo enddo else if (trim(tracer_name) == 'itcz_clock' ) then - lat_thresh = 15.*pi/180. do k=1,npz do j=jsc,jec do i=isc,iec @@ -1268,9 +1448,9 @@ subroutine atmosphere_state_update (Time, IPD_Data, Atm_block) call timing_on('FV_DIAG') call fv_diag(Atm(mygrid:mygrid), zvir, fv_time, Atm(mygrid)%flagstruct%print_freq) - if (Atm(mygrid)%coarse_graining%write_coarse_diagnostics) then - call fv_coarse_diag(Atm(mygrid:mygrid), fv_time) - endif + if (Atm(mygrid)%coarse_graining%write_coarse_diagnostics) then + call fv_coarse_diag(Atm(mygrid:mygrid), fv_time, zvir) + endif first_diag = .false. call timing_off('FV_DIAG') @@ -1380,7 +1560,7 @@ subroutine adiabatic_init(zvir,nudge_dz) Atm(mygrid)%cx, Atm(mygrid)%cy, Atm(mygrid)%ze0, Atm(mygrid)%flagstruct%hybrid_z, & Atm(mygrid)%gridstruct, Atm(mygrid)%flagstruct, & Atm(mygrid)%neststruct, Atm(mygrid)%idiag, Atm(mygrid)%bd, Atm(mygrid)%parent_grid, & - Atm(mygrid)%domain, Atm(mygrid)%inline_mp) + Atm(mygrid)%domain, Atm(mygrid)%inline_mp, Atm(mygrid)%diss_est) ! Backward call fv_dynamics(Atm(mygrid)%npx, Atm(mygrid)%npy, npz, nq, Atm(mygrid)%ng, -dt_atmos, 0., & Atm(mygrid)%flagstruct%fill, Atm(mygrid)%flagstruct%reproduce_sum, kappa, cp_air, zvir, & @@ -1394,7 +1574,7 @@ subroutine adiabatic_init(zvir,nudge_dz) Atm(mygrid)%cx, Atm(mygrid)%cy, Atm(mygrid)%ze0, Atm(mygrid)%flagstruct%hybrid_z, & Atm(mygrid)%gridstruct, Atm(mygrid)%flagstruct, & Atm(mygrid)%neststruct, Atm(mygrid)%idiag, Atm(mygrid)%bd, Atm(mygrid)%parent_grid, & - Atm(mygrid)%domain, Atm(mygrid)%inline_mp) + Atm(mygrid)%domain, Atm(mygrid)%inline_mp, Atm(mygrid)%diss_est) ! Nudging back to IC !$omp parallel do default (none) & !$omp shared (pref, npz, jsc, jec, isc, iec, n, sphum, Atm, u0, v0, t0, dp0, xt, zvir, mygrid, nudge_dz, dz0) & @@ -1466,7 +1646,7 @@ subroutine adiabatic_init(zvir,nudge_dz) Atm(mygrid)%cx, Atm(mygrid)%cy, Atm(mygrid)%ze0, Atm(mygrid)%flagstruct%hybrid_z, & Atm(mygrid)%gridstruct, Atm(mygrid)%flagstruct, & Atm(mygrid)%neststruct, Atm(mygrid)%idiag, Atm(mygrid)%bd, Atm(mygrid)%parent_grid, & - Atm(mygrid)%domain, Atm(mygrid)%inline_mp) + Atm(mygrid)%domain, Atm(mygrid)%inline_mp, Atm(mygrid)%diss_est) ! Forward call call fv_dynamics(Atm(mygrid)%npx, Atm(mygrid)%npy, npz, nq, Atm(mygrid)%ng, dt_atmos, 0., & Atm(mygrid)%flagstruct%fill, Atm(mygrid)%flagstruct%reproduce_sum, kappa, cp_air, zvir, & @@ -1480,7 +1660,7 @@ subroutine adiabatic_init(zvir,nudge_dz) Atm(mygrid)%cx, Atm(mygrid)%cy, Atm(mygrid)%ze0, Atm(mygrid)%flagstruct%hybrid_z, & Atm(mygrid)%gridstruct, Atm(mygrid)%flagstruct, & Atm(mygrid)%neststruct, Atm(mygrid)%idiag, Atm(mygrid)%bd, Atm(mygrid)%parent_grid, & - Atm(mygrid)%domain, Atm(mygrid)%inline_mp) + Atm(mygrid)%domain, Atm(mygrid)%inline_mp, Atm(mygrid)%diss_est) ! Nudging back to IC !$omp parallel do default (none) & !$omp shared (nudge_dz,npz, jsc, jec, isc, iec, n, sphum, Atm, u0, v0, t0, dz0, dp0, xt, zvir, mygrid) & @@ -1545,8 +1725,9 @@ subroutine atmos_phys_driver_statein (IPD_Data, Atm_block) real(kind=kind_phys), parameter:: qmin = 1.0e-10 real(kind=kind_phys):: pk0inv, ptop, pktop real(kind=kind_phys) :: rTv, dm, qgrs_rad - integer :: nb, blen, npz, i, j, k, ix, k1, dnats, nq_adv + integer :: nb, blen, npz, i, j, k, ix, k1, dnats, nq_adv, isd, ied, jsd, jed + real, pointer :: omega_for_physics(:,:,:) !!! NOTES: lmh 6nov15 !!! - "Layer" means "layer mean", ie. the average value in a layer !!! - "Level" means "level interface", ie the point values at the top or bottom of a layer @@ -1559,13 +1740,19 @@ subroutine atmos_phys_driver_statein (IPD_Data, Atm_block) dnats = Atm(mygrid)%flagstruct%dnats nq_adv = nq - dnats + if (.not. Atm(mygrid)%flagstruct%hydrostatic .and. .not. Atm(mygrid)%flagstruct%pass_full_omega_to_physics_in_non_hydrostatic_mode) then + omega_for_physics => Atm(mygrid)%local_omga + else + omega_for_physics => Atm(mygrid)%omga + endif + !--------------------------------------------------------------------- ! use most up to date atmospheric properties when running serially !--------------------------------------------------------------------- !$OMP parallel do default (none) & !$OMP shared (Atm_block, Atm, IPD_Data, npz, nq, ncnst, sphum, liq_wat, & !$OMP ice_wat, rainwat, snowwat, graupel, pk0inv, ptop, & -!$OMP pktop, zvir, mygrid, dnats, nq_adv) & +!$OMP pktop, zvir, mygrid, dnats, nq_adv, omega_for_physics) & !$OMP private (dm, nb, blen, i, j, ix, k1, rTv, qgrs_rad) do nb = 1,Atm_block%nblks @@ -1589,12 +1776,6 @@ subroutine atmos_phys_driver_statein (IPD_Data, Atm_block) enddo endif - do ix = 1, blen - i = Atm_block%index(nb)%ii(ix) - j = Atm_block%index(nb)%jj(ix) - IPD_Data(nb)%Statein%sst(ix) = _DBL_(_RL_(Atm(mygrid)%ts(i,j))) - enddo - do k = 1, npz do ix = 1, blen i = Atm_block%index(nb)%ii(ix) @@ -1606,8 +1787,9 @@ subroutine atmos_phys_driver_statein (IPD_Data, Atm_block) IPD_Data(nb)%Statein%tgrs(ix,k) = _DBL_(_RL_(Atm(mygrid)%pt(i,j,k1))) IPD_Data(nb)%Statein%ugrs(ix,k) = _DBL_(_RL_(Atm(mygrid)%ua(i,j,k1))) IPD_Data(nb)%Statein%vgrs(ix,k) = _DBL_(_RL_(Atm(mygrid)%va(i,j,k1))) - IPD_Data(nb)%Statein%vvl(ix,k) = _DBL_(_RL_(Atm(mygrid)%omga(i,j,k1))) + IPD_Data(nb)%Statein%vvl(ix,k) = _DBL_(_RL_(omega_for_physics(i,j,k1))) IPD_Data(nb)%Statein%prsl(ix,k) = _DBL_(_RL_(Atm(mygrid)%delp(i,j,k1))) ! Total mass + if (Atm(mygrid)%flagstruct%do_diss_est)IPD_Data(nb)%Statein%diss_est(ix,k) = _DBL_(_RL_(Atm(mygrid)%diss_est(i,j,k1))) if (.not.Atm(mygrid)%flagstruct%hydrostatic .and. (.not.Atm(mygrid)%flagstruct%use_hydro_pressure)) & IPD_Data(nb)%Statein%phii(ix,k+1) = IPD_Data(nb)%Statein%phii(ix,k) - _DBL_(_RL_(Atm(mygrid)%delz(i,j,k1)*grav)) @@ -1705,6 +1887,8 @@ subroutine atmos_phys_driver_statein (IPD_Data, Atm_block) enddo enddo endif + IPD_Data(nb)%Statein%dycore_hydrostatic = Atm(mygrid)%flagstruct%hydrostatic + IPD_Data(nb)%Statein%nwat = Atm(mygrid)%flagstruct%nwat enddo end subroutine atmos_phys_driver_statein @@ -1806,4 +1990,19 @@ subroutine atmos_phys_qdt_diag(q, phys_diag, nq, dt, begin) end subroutine atmos_phys_qdt_diag + subroutine atmosphere_coarse_graining_parameters(coarse_domain, write_coarse_restart_files, write_only_coarse_intermediate_restarts) + type(domain2d), intent(out) :: coarse_domain + logical, intent(out) :: write_coarse_restart_files, write_only_coarse_intermediate_restarts + + coarse_domain = Atm(mygrid)%coarse_graining%domain + write_coarse_restart_files = Atm(mygrid)%coarse_graining%write_coarse_restart_files + write_only_coarse_intermediate_restarts = Atm(mygrid)%coarse_graining%write_only_coarse_intermediate_restarts + end subroutine atmosphere_coarse_graining_parameters + + subroutine atmosphere_coarsening_strategy(coarsening_strategy) + character(len=64), intent(out) :: coarsening_strategy + + coarsening_strategy = Atm(mygrid)%coarse_graining%strategy + end subroutine atmosphere_coarsening_strategy + end module atmosphere_mod diff --git a/driver/solo/atmosphere.F90 b/driver/solo/atmosphere.F90 new file mode 100644 index 000000000..9ff66e494 --- /dev/null +++ b/driver/solo/atmosphere.F90 @@ -0,0 +1,608 @@ +!*********************************************************************** +!* GNU Lesser General Public License +!* +!* This file is part of the FV3 dynamical core. +!* +!* The FV3 dynamical core is free software: you can redistribute it +!* and/or modify it under the terms of the +!* GNU Lesser General Public License as published by the +!* Free Software Foundation, either version 3 of the License, or +!* (at your option) any later version. +!* +!* The FV3 dynamical core is distributed in the hope that it will be +!* useful, but WITHOUT ANY WARRANTY; without even the implied warranty +!* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. +!* See the GNU General Public License for more details. +!* +!* You should have received a copy of the GNU Lesser General Public +!* License along with the FV3 dynamical core. +!* If not, see . +!*********************************************************************** + +module atmosphere_mod + +!----------------------------------------------------------------------- +! +! interface for FV dynamical core with Held-Suarez forcing +! +!----------------------------------------------------------------------- + + +use constants_mod, only: grav, kappa, cp_air, pi, rdgas, rvgas, SECONDS_PER_DAY +use fms_mod, only: file_exist, open_namelist_file, & + error_mesg, FATAL, & + check_nml_error, stdlog, stdout, & + write_version_number, & + close_file, set_domain, nullify_domain, mpp_pe, mpp_root_pe, & + mpp_error, FATAL, NOTE +use mpp_mod, only: input_nml_file +use time_manager_mod, only: time_type, get_time, set_time, operator(+) +use mpp_domains_mod, only: domain2d +use mpp_io_mod, only: mpp_close +use mpp_mod, only: input_nml_file +!------------------ +! FV specific codes: +!------------------ +use fv_arrays_mod, only: fv_atmos_type +use fv_control_mod, only: fv_control_init, fv_end, ngrids +use fv_phys_mod, only: fv_phys, fv_nudge, fv_phys_init +use fv_diagnostics_mod, only: fv_diag_init, fv_diag, fv_time, eqv_pot +use fv_timing_mod, only: timing_on, timing_off +use fv_restart_mod, only: fv_restart +use fv_dynamics_mod, only: fv_dynamics +use fv_nesting_mod, only: twoway_nesting +use gfdl_cld_mp_mod, only: gfdl_cld_mp_init, gfdl_cld_mp_end +use gfdl_mp_mod, only: gfdl_mp_init, gfdl_mp_end +use cld_eff_rad_mod, only: cld_eff_rad_init +use fv_nwp_nudge_mod, only: fv_nwp_nudge_init, fv_nwp_nudge_end, do_adiabatic_init +use field_manager_mod, only: MODEL_ATMOS +use tracer_manager_mod, only: get_tracer_index +!----------------------------------------------------------------------- + +implicit none +private + +public atmosphere_init, atmosphere, atmosphere_end, atmosphere_domain + +!----------------------------------------------------------------------- +!---- private data ---- + +type (time_type) :: Time_step_atmos +real :: dt_atmos +integer :: sec +integer days, seconds + +logical :: cold_start = .false. ! read in initial condition +integer :: mytile = 1 +integer :: p_split = 1 +real, allocatable:: lprec(:,:), fprec(:,:), f_land(:,:) + +type(fv_atmos_type), allocatable, target :: Atm(:) + +logical, allocatable :: grids_on_this_pe(:) +integer :: this_grid !not used yet +integer :: axes(4) +integer:: isd, ied, jsd, jed, ngc +!----------------------------------------------------------------------- + +! version number of this module +! Include variable "version" to be written to log file. +#include + +contains + +!####################################################################### + + subroutine atmosphere_init ( Time_init, Time, Time_step ) + + type (time_type), intent(in) :: Time_step + type (time_type), intent(in) :: Time_init + type (time_type), intent(in) :: Time + + ! local: + integer isc, iec, jsc, jec + real:: zvir + integer :: n, theta_d + + integer :: nlunit = 9999 + character (len = 64) :: fn_nml = 'input.nml' + + call timing_on('ATMOS_INIT') + !----- write version and namelist to log file ----- + + call write_version_number ( 'SOLO/ATMOSPHERE_MOD', version ) + + !---- compute physics/atmos time step in seconds ---- + + Time_step_atmos = Time_step + call get_time (Time_step_atmos, sec) + dt_atmos = real(sec) + + !----- initialize FV dynamical core ----- + cold_start = (.not.file_exist('INPUT/fv_core.res.nc') .and. .not.file_exist('INPUT/fv_core.res.tile1.nc')) + + call fv_control_init(Atm, dt_atmos, this_grid, grids_on_this_pe, p_split) ! allocates Atm components + + do n=1,ngrids + if (grids_on_this_pe(n)) mytile = n + enddo + + call timing_on('fv_restart') + call fv_restart(Atm(1)%domain, Atm, dt_atmos, seconds, days, cold_start, & + Atm(1)%flagstruct%grid_type, mytile) + call timing_off('fv_restart') + + fv_time = time + + do n=1,ngrids + + isc = Atm(n)%bd%isc + iec = Atm(n)%bd%iec + jsc = Atm(n)%bd%jsc + jec = Atm(n)%bd%jec + isd = Atm(n)%bd%isd + ied = Atm(n)%bd%ied + jsd = Atm(n)%bd%jsd + jed = Atm(n)%bd%jed + + + if ( grids_on_this_pe(n)) then + + Atm(N)%flagstruct%moist_phys = .false. ! need this for fv_diag calendar + call fv_diag_init(Atm(n:n), axes, Time, Atm(n)%npx, Atm(n)%npy, Atm(n)%npz, Atm(n)%flagstruct%p_ref) + + endif + + ! if ( Atm(n)%flagstruct%adiabatic .or. Atm(n)%flagstruct%do_Held_Suarez ) then + zvir = 0. + if ( Atm(n)%flagstruct%adiabatic ) then + Atm(n)%flagstruct%moist_phys = .false. + else + zvir = rvgas/rdgas - 1. + Atm(n)%flagstruct%moist_phys = .true. + if ( grids_on_this_pe(n) ) then + call fv_phys_init(isc,iec,jsc,jec,Atm(n)%npz,Atm(n)%flagstruct%nwat, Atm(n)%ts, Atm(n)%pt(isc:iec,jsc:jec,:), & + Time, axes, Atm(n)%gridstruct%agrid(isc:iec,jsc:jec,2)) +! if ( Atm(n)%flagstruct%nwat==6) call gfdl_cld_mp_init(mpp_pe(), & +! mpp_root_pe(), input_nml_file, stdlog()) +! if ( Atm(n)%flagstruct%nwat==6) call cld_eff_rad_init(input_nml_file) + endif + endif + if (.not. Atm(n)%flagstruct%adiabatic) call gfdl_mp_init (input_nml_file, stdlog()) + + + + if ( grids_on_this_pe(n) ) then + + if ( Atm(n)%flagstruct%nudge ) & + call fv_nwp_nudge_init( Time, axes, Atm(n)%npz, zvir, Atm(n)%ak, Atm(n)%bk, Atm(n)%ts, & + Atm(n)%phis, Atm(n)%gridstruct, Atm(n)%ks, Atm(n)%npx, Atm(n)%neststruct, Atm(n)%bd) + + if ( Atm(n)%flagstruct%make_nh ) then + Atm(n)%w(:,:,:) = 0. + endif + + if ( Atm(n)%flagstruct%na_init>0 ) then + call adiabatic_init(zvir,n) + endif + + theta_d = get_tracer_index (MODEL_ATMOS, 'theta_d') + if ( theta_d > 0 ) then + call eqv_pot(Atm(n)%q(isc:iec,jsc:jec,:,theta_d), Atm(n)%pt, Atm(n)%delp, & + Atm(n)%delz, Atm(n)%peln, Atm(n)%pkz, Atm(n)%q(isd,jsd,1,1), isc, iec, jsc, jec, Atm(n)%ng, & + Atm(n)%npz, Atm(n)%flagstruct%hydrostatic, Atm(n)%flagstruct%moist_phys) + endif + + endif + + enddo + + call timing_off('ATMOS_INIT') + end subroutine atmosphere_init + + subroutine adiabatic_init(zvir, n) + real, allocatable, dimension(:,:,:):: u0, v0, t0, dp0 + real, intent(in):: zvir + integer, intent(in) :: n + real, parameter:: wt = 1.5 ! 2. + real:: xt, esl + integer:: isc, iec, jsc, jec, npz + integer:: m, i,j,k + + character(len=80) :: errstr + + xt = 1./(1.+wt) + if ( Atm(n)%flagstruct%moist_phys ) then + esl = zvir + else + esl = 0. + endif + + write(errstr,'(A, I4, A)') 'Performing adiabatic init', Atm(n)%flagstruct%na_init, ' times' + call mpp_error(NOTE, errstr) + + npz = Atm(n)%npz + + isc = Atm(n)%bd%isc + iec = Atm(n)%bd%iec + jsc = Atm(n)%bd%jsc + jec = Atm(n)%bd%jec + + ngc = Atm(n)%ng + isd = isc - ngc + ied = iec + ngc + jsd = jsc - ngc + jed = jec + ngc + + call timing_on('adiabatic_init') + do_adiabatic_init = .true. + + allocate ( u0(isc:iec, jsc:jec+1, npz) ) + allocate ( v0(isc:iec+1,jsc:jec, npz) ) + allocate ( t0(isc:iec,jsc:jec, npz) ) + allocate (dp0(isc:iec,jsc:jec, npz) ) + call p_adi(npz, Atm(n)%ng, isc, iec, jsc, jec, Atm(n)%ptop, & + Atm(n)%delp, Atm(n)%ps, Atm(n)%pe, & + Atm(n)%peln, Atm(n)%pk, Atm(n)%pkz, Atm(n)%flagstruct%hydrostatic) + +!$omp parallel do default(shared) + do k=1,npz + do j=jsc,jec+1 + do i=isc,iec + u0(i,j,k) = Atm(n)%u(i,j,k) + enddo + enddo + do j=jsc,jec + do i=isc,iec+1 + v0(i,j,k) = Atm(n)%v(i,j,k) + enddo + enddo + do j=jsc,jec + do i=isc,iec +! t0(i,j,k) = Atm(n)%pt(i,j,k)*(1.+esl*Atm(n)%q(i,j,k,1))*(Atm(n)%peln(i,k+1,j)-Atm(n)%peln(i,k,j)) + t0(i,j,k) = Atm(n)%pt(i,j,k) + dp0(i,j,k) = Atm(n)%delp(i,j,k) + enddo + enddo + enddo + + do m=1,Atm(n)%flagstruct%na_init +! Forwardward call + call fv_dynamics(Atm(n)%npx, Atm(n)%npy, npz, Atm(n)%ncnst, Atm(n)%ng, dt_atmos, 0., & + Atm(n)%flagstruct%fill, Atm(n)%flagstruct%reproduce_sum, kappa, cp_air, zvir, & + Atm(n)%ptop, Atm(n)%ks, Atm(n)%ncnst, Atm(n)%flagstruct%n_split, & + Atm(n)%flagstruct%q_split, Atm(n)%u, Atm(n)%v, Atm(n)%w, & + Atm(n)%delz, Atm(n)%flagstruct%hydrostatic, & + Atm(n)%pt, Atm(n)%delp, Atm(n)%q, Atm(n)%ps, & + Atm(n)%pe, Atm(n)%pk, Atm(n)%peln, Atm(n)%pkz, Atm(n)%phis, & + Atm(n)%q_con, Atm(n)%omga, Atm(n)%ua, Atm(n)%va, Atm(n)%uc, Atm(n)%vc, & + Atm(n)%ak, Atm(n)%bk, Atm(n)%mfx, Atm(n)%mfy, & + Atm(n)%cx, Atm(n)%cy, Atm(n)%ze0, Atm(n)%flagstruct%hybrid_z, & + Atm(n)%gridstruct, Atm(n)%flagstruct, & + Atm(n)%neststruct, Atm(n)%idiag, Atm(n)%bd, Atm(n)%parent_grid, & + Atm(n)%domain, Atm(n)%inline_mp, Atm(n)%diss_est) +! Backward + call fv_dynamics(Atm(n)%npx, Atm(n)%npy, npz, Atm(n)%ncnst, Atm(n)%ng, -dt_atmos, 0., & + Atm(n)%flagstruct%fill, Atm(n)%flagstruct%reproduce_sum, kappa, cp_air, zvir, & + Atm(n)%ptop, Atm(n)%ks, Atm(n)%ncnst, Atm(n)%flagstruct%n_split, & + Atm(n)%flagstruct%q_split, Atm(n)%u, Atm(n)%v, Atm(n)%w, & + Atm(n)%delz, Atm(n)%flagstruct%hydrostatic, & + Atm(n)%pt, Atm(n)%delp, Atm(n)%q, Atm(n)%ps, & + Atm(n)%pe, Atm(n)%pk, Atm(n)%peln, Atm(n)%pkz, Atm(n)%phis, & + Atm(n)%q_con, Atm(n)%omga, Atm(n)%ua, Atm(n)%va, Atm(n)%uc, Atm(n)%vc, & + Atm(n)%ak, Atm(n)%bk, Atm(n)%mfx, Atm(n)%mfy, & + Atm(n)%cx, Atm(n)%cy, Atm(n)%ze0, Atm(n)%flagstruct%hybrid_z, & + Atm(n)%gridstruct, Atm(n)%flagstruct, & + Atm(n)%neststruct, Atm(n)%idiag, Atm(n)%bd, Atm(n)%parent_grid, & + Atm(n)%domain, Atm(n)%inline_mp, Atm(n)%diss_est) +! Nudging back to IC +!$omp parallel do default(shared) + do k=1,npz + do j=jsc,jec+1 + do i=isc,iec + Atm(n)%u(i,j,k) = xt*(Atm(n)%u(i,j,k) + wt*u0(i,j,k)) + enddo + enddo + do j=jsc,jec + do i=isc,iec+1 + Atm(n)%v(i,j,k) = xt*(Atm(n)%v(i,j,k) + wt*v0(i,j,k)) + enddo + enddo + do j=jsc,jec + do i=isc,iec + Atm(n)%delp(i,j,k) = xt*(Atm(n)%delp(i,j,k) + wt*dp0(i,j,k)) + enddo + enddo + enddo + + call p_adi(npz, Atm(n)%ng, isc, iec, jsc, jec, Atm(n)%ptop, & + Atm(n)%delp, Atm(n)%ps, Atm(n)%pe, & + Atm(n)%peln, Atm(n)%pk, Atm(n)%pkz, Atm(n)%flagstruct%hydrostatic) +!$omp parallel do default(shared) + do k=1,npz + do j=jsc,jec + do i=isc,iec +! Atm(n)%pt(i,j,k) = xt*(Atm(n)%pt(i,j,k)+wt*t0(i,j,k)/((1.+esl*Atm(n)%q(i,j,k,1))*(Atm(n)%peln(i,k+1,j)-Atm(n)%peln(i,k,j)))) + Atm(n)%pt(i,j,k) = xt*(Atm(n)%pt(i,j,k)+wt*t0(i,j,k)) + enddo + enddo + enddo + +! Backward + call fv_dynamics(Atm(n)%npx, Atm(n)%npy, npz, Atm(n)%ncnst, Atm(n)%ng, -dt_atmos, 0., & + Atm(n)%flagstruct%fill, Atm(n)%flagstruct%reproduce_sum, kappa, cp_air, zvir, & + Atm(n)%ptop, Atm(n)%ks, Atm(n)%ncnst, Atm(n)%flagstruct%n_split, & + Atm(n)%flagstruct%q_split, Atm(n)%u, Atm(n)%v, Atm(n)%w, & + Atm(n)%delz, Atm(n)%flagstruct%hydrostatic, & + Atm(n)%pt, Atm(n)%delp, Atm(n)%q, Atm(n)%ps, & + Atm(n)%pe, Atm(n)%pk, Atm(n)%peln, Atm(n)%pkz, Atm(n)%phis, & + Atm(n)%q_con, Atm(n)%omga, Atm(n)%ua, Atm(n)%va, Atm(n)%uc, Atm(n)%vc, & + Atm(n)%ak, Atm(n)%bk, Atm(n)%mfx, Atm(n)%mfy, & + Atm(n)%cx, Atm(n)%cy, Atm(n)%ze0, Atm(n)%flagstruct%hybrid_z, & + Atm(n)%gridstruct, Atm(n)%flagstruct, & + Atm(n)%neststruct, Atm(n)%idiag, Atm(n)%bd, Atm(n)%parent_grid, & + Atm(n)%domain, Atm(n)%inline_mp, Atm(n)%diss_est) +! Forwardward call + call fv_dynamics(Atm(n)%npx, Atm(n)%npy, npz, Atm(n)%ncnst, Atm(n)%ng, dt_atmos, 0., & + Atm(n)%flagstruct%fill, Atm(n)%flagstruct%reproduce_sum, kappa, cp_air, zvir, & + Atm(n)%ptop, Atm(n)%ks, Atm(n)%ncnst, Atm(n)%flagstruct%n_split, & + Atm(n)%flagstruct%q_split, Atm(n)%u, Atm(n)%v, Atm(n)%w, & + Atm(n)%delz, Atm(n)%flagstruct%hydrostatic, & + Atm(n)%pt, Atm(n)%delp, Atm(n)%q, Atm(n)%ps, & + Atm(n)%pe, Atm(n)%pk, Atm(n)%peln, Atm(n)%pkz, Atm(n)%phis, & + Atm(n)%q_con, Atm(n)%omga, Atm(n)%ua, Atm(n)%va, Atm(n)%uc, Atm(n)%vc, & + Atm(n)%ak, Atm(n)%bk, Atm(n)%mfx, Atm(n)%mfy, & + Atm(n)%cx, Atm(n)%cy, Atm(n)%ze0, Atm(n)%flagstruct%hybrid_z, & + Atm(n)%gridstruct, Atm(n)%flagstruct, & + Atm(n)%neststruct, Atm(n)%idiag, Atm(n)%bd, Atm(n)%parent_grid, & + Atm(n)%domain, Atm(n)%inline_mp, Atm(n)%diss_est) +! Nudging back to IC +!$omp parallel do default(shared) + do k=1,npz + do j=jsc,jec+1 + do i=isc,iec + Atm(n)%u(i,j,k) = xt*(Atm(n)%u(i,j,k) + wt*u0(i,j,k)) + enddo + enddo + do j=jsc,jec + do i=isc,iec+1 + Atm(n)%v(i,j,k) = xt*(Atm(n)%v(i,j,k) + wt*v0(i,j,k)) + enddo + enddo + do j=jsc,jec + do i=isc,iec + Atm(n)%delp(i,j,k) = xt*(Atm(n)%delp(i,j,k) + wt*dp0(i,j,k)) + enddo + enddo + enddo + + call p_adi(npz, Atm(n)%ng, isc, iec, jsc, jec, Atm(n)%ptop, & + Atm(n)%delp, Atm(n)%ps, Atm(n)%pe, & + Atm(n)%peln, Atm(n)%pk, Atm(n)%pkz, Atm(n)%flagstruct%hydrostatic) + +!$omp parallel do default(shared) + do k=1,npz + do j=jsc,jec + do i=isc,iec +! Atm(n)%pt(i,j,k) = xt*(Atm(n)%pt(i,j,k)+wt*t0(i,j,k)/((1.+esl*Atm(n)%q(i,j,k,1))*(Atm(n)%peln(i,k+1,j)-Atm(n)%peln(i,k,j)))) + Atm(n)%pt(i,j,k) = xt*(Atm(n)%pt(i,j,k)+wt*t0(i,j,k)) + enddo + enddo + enddo + enddo + + deallocate ( u0 ) + deallocate ( v0 ) + deallocate ( t0 ) + deallocate (dp0 ) + + do_adiabatic_init = .false. + call timing_off('adiabatic_init') + + end subroutine adiabatic_init + +!####################################################################### + + subroutine atmosphere (Time) + type(time_type), intent(in) :: Time + + real:: zvir + real:: time_total + integer :: n, sphum, p, nc + integer :: psc ! p_split counter + + + call timing_on('ATMOSPHERE') + fv_time = Time + Time_step_atmos + call get_time (fv_time, seconds, days) + + time_total = days*SECONDS_PER_DAY + seconds + + do psc=1,abs(p_split) + + do n=1,ngrids + + if (.not. grids_on_this_pe(n)) then + cycle + endif + + call set_domain(Atm(n)%domain) ! needed for diagnostic output done in fv_dynamics + + if ( Atm(n)%flagstruct%nudge_ic ) & + call fv_nudge(Atm(n)%npz, Atm(n)%bd%isc, Atm(n)%bd%iec, Atm(n)%bd%jsc, Atm(n)%bd%jec, Atm(n)%ng, & + Atm(n)%u, Atm(n)%v, Atm(n)%w, Atm(n)%delz, Atm(n)%delp, Atm(n)%pt, dt_atmos/real(abs(p_split)), Atm(n)%flagstruct%hydrostatic ) + + !---- call fv dynamics ----- +! if ( Atm(n)%flagstruct%adiabatic .or. Atm(n)%flagstruct%do_Held_Suarez ) then + if ( Atm(n)%flagstruct%adiabatic ) then + zvir = 0. ! no virtual effect + else + zvir = rvgas/rdgas - 1. + endif + + call timing_on('fv_dynamics') + call fv_dynamics(Atm(n)%npx, Atm(n)%npy, Atm(n)%npz, Atm(n)%ncnst, Atm(n)%ng, & + dt_atmos/real(abs(p_split)), Atm(n)%flagstruct%consv_te, Atm(n)%flagstruct%fill, & + Atm(n)%flagstruct%reproduce_sum, kappa, & + cp_air, zvir, Atm(n)%ptop, Atm(n)%ks, Atm(n)%ncnst, & + Atm(n)%flagstruct%n_split, Atm(n)%flagstruct%q_split, & + Atm(n)%u, Atm(n)%v, Atm(n)%w, Atm(n)%delz, & + Atm(n)%flagstruct%hydrostatic, Atm(n)%pt, Atm(n)%delp, Atm(n)%q, Atm(n)%ps, & + Atm(n)%pe, Atm(n)%pk, Atm(n)%peln, Atm(n)%pkz, & + Atm(n)%phis, Atm(n)%q_con, Atm(n)%omga, Atm(n)%ua, Atm(n)%va, Atm(n)%uc, Atm(n)%vc, & + Atm(n)%ak, Atm(n)%bk, Atm(n)%mfx, Atm(n)%mfy, Atm(n)%cx, Atm(n)%cy, & + Atm(n)%ze0, Atm(n)%flagstruct%hybrid_z, Atm(n)%gridstruct, Atm(n)%flagstruct, & + Atm(n)%neststruct, Atm(n)%idiag, Atm(n)%bd, Atm(n)%parent_grid, Atm(n)%domain, & + Atm(n)%inline_mp, Atm(n)%diss_est, time_total=time_total) + call timing_off('fv_dynamics') + end do + + if (ngrids > 1 .and. (psc < p_split .or. p_split < 0)) then + call timing_on('TWOWAY_UPDATE') + call twoway_nesting(Atm, ngrids, grids_on_this_pe, zvir, fv_time, mytile) + call timing_off('TWOWAY_UPDATE') + endif + + end do !p_split + + do n=1,ngrids + + if (.not. grids_on_this_pe(n)) then + cycle + endif + + if(Atm(n)%npz /=1 .and. .not. Atm(n)%flagstruct%adiabatic)then + + call timing_on('FV_PHYS') + call fv_phys(Atm(n)%npx, Atm(n)%npy, Atm(n)%npz, Atm(n)%bd%isc, Atm(n)%bd%iec, & + Atm(n)%bd%jsc, Atm(n)%bd%jec, Atm(n)%ng, Atm(n)%ncnst, & + Atm(n)%u, Atm(n)%v, Atm(n)%w, Atm(n)%pt, Atm(n)%q, Atm(n)%pe, & + Atm(n)%delp, Atm(n)%peln, Atm(n)%pkz, dt_atmos, & + Atm(n)%ua, Atm(n)%va, Atm(n)%phis, Atm(n)%gridstruct%agrid, & + Atm(n)%ptop, Atm(n)%ak, Atm(n)%bk, Atm(n)%ks, Atm(n)%ps, Atm(n)%pk, & + Atm(n)%u_srf, Atm(n)%v_srf, Atm(n)%ts, Atm(n)%delz, & + Atm(n)%flagstruct%hydrostatic, Atm(n)%oro, .false., & + Atm(n)%flagstruct%p_ref, & + Atm(n)%flagstruct%fv_sg_adj, Atm(n)%flagstruct%do_Held_Suarez, & + Atm(n)%gridstruct, Atm(n)%flagstruct, Atm(n)%neststruct, & + Atm(n)%flagstruct%nwat, Atm(n)%bd, & + Atm(n)%domain, fv_time, Atm(n)%phys_diag, Atm(n)%nudge_diag, time_total) + call timing_off('FV_PHYS') + endif + + call nullify_domain() + end do + + if (ngrids > 1 .and. p_split > 0) then + call timing_on('TWOWAY_UPDATE') + call twoway_nesting(Atm, ngrids, grids_on_this_pe, zvir, fv_time, mytile) + call timing_off('TWOWAY_UPDATE') + endif + + + !---- diagnostics for FV dynamics ----- + + do n=1,ngrids + + if (.not. grids_on_this_pe(n)) then + cycle + endif + + !For correct diagnostics (may need to be changed for moist Held-Suarez) + if ( Atm(n)%flagstruct%adiabatic .or. Atm(n)%flagstruct%do_Held_Suarez ) then + zvir = 0. ! no virtual effect + else + zvir = rvgas/rdgas - 1. + endif + + call nullify_domain() + call timing_on('FV_DIAG') + call fv_diag(Atm(n:n), zvir, fv_time, Atm(n)%flagstruct%print_freq) + + call timing_off('FV_DIAG') + end do + + call timing_off('ATMOSPHERE') + end subroutine atmosphere + + + subroutine atmosphere_end + + integer n + + call get_time (fv_time, seconds, days) + + do n=1,ngrids + if ( Atm(n)%flagstruct%moist_phys .and. Atm(n)%flagstruct%nwat==6 .and. grids_on_this_pe(N)) call gfdl_mp_end + !if ( Atm(n)%flagstruct%moist_phys .and. Atm(n)%flagstruct%nwat==6 .and. grids_on_this_pe(N)) call gfdl_cld_mp_end + enddo + + call fv_end(Atm, mytile) + deallocate(Atm) + + end subroutine atmosphere_end + + subroutine atmosphere_domain ( fv_domain ) + type(domain2d), intent(out) :: fv_domain + +! returns the domain2d variable associated with the coupling grid +! note: coupling is done using the mass/temperature grid with no halos + + fv_domain = Atm(mytile)%domain + + end subroutine atmosphere_domain + + subroutine p_adi(km, ng, ifirst, ilast, jfirst, jlast, ptop, & + delp, ps, pe, peln, pk, pkz, hydrostatic) + +! Given (ptop, delp) computes (ps, pk, pe, peln, pkz) +! Input: + integer, intent(in):: km, ng + integer, intent(in):: ifirst, ilast ! Longitude strip + integer, intent(in):: jfirst, jlast ! Latitude strip + logical, intent(in):: hydrostatic + real, intent(in):: ptop + real, intent(in):: delp(ifirst-ng:ilast+ng,jfirst-ng:jlast+ng, km) +! Output: + real, intent(out) :: ps(ifirst-ng:ilast+ng, jfirst-ng:jlast+ng) + real, intent(out) :: pk(ifirst:ilast, jfirst:jlast, km+1) + real, intent(out) :: pe(ifirst-1:ilast+1,km+1,jfirst-1:jlast+1) ! Ghosted Edge pressure + real, intent(out) :: peln(ifirst:ilast, km+1, jfirst:jlast) ! Edge pressure + real, intent(out) :: pkz(ifirst:ilast, jfirst:jlast, km) +! Local + real pek + integer i, j, k + + pek = ptop ** kappa + +!$OMP parallel do default(none) shared(ifirst,ilast,jfirst,jlast,km,ptop,pek,pe,pk, & +!$OMP ps,delp,peln,hydrostatic,pkz) + do j=jfirst,jlast + do i=ifirst,ilast + pe(i,1,j) = ptop + pk(i,j,1) = pek + enddo + + do k=2,km+1 + do i=ifirst,ilast + pe(i,k,j) = pe(i,k-1,j) + delp(i,j,k-1) + peln(i,k,j) = log(pe(i,k,j)) + pk(i,j,k) = exp( kappa*peln(i,k,j) ) + enddo + enddo + + do i=ifirst,ilast + ps(i,j) = pe(i,km+1,j) + enddo + + if ( hydrostatic ) then + do k=1,km + do i=ifirst,ilast + pkz(i,j,k) = (pk(i,j,k+1)-pk(i,j,k))/(kappa*(peln(i,k+1,j)-peln(i,k,j))) + enddo + enddo + endif + enddo + + end subroutine p_adi +end module atmosphere_mod diff --git a/driver/solo/fv_phys.F90 b/driver/solo/fv_phys.F90 new file mode 100644 index 000000000..9107bf1c0 --- /dev/null +++ b/driver/solo/fv_phys.F90 @@ -0,0 +1,2625 @@ +!*********************************************************************** +!* GNU Lesser General Public License +!* +!* This file is part of the FV3 dynamical core. +!* +!* The FV3 dynamical core is free software: you can redistribute it +!* and/or modify it under the terms of the +!* GNU Lesser General Public License as published by the +!* Free Software Foundation, either version 3 of the License, or +!* (at your option) any later version. +!* +!* The FV3 dynamical core is distributed in the hope that it will be +!* useful, but WITHOUT ANY WARRANTY; without even the implied warranty +!* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. +!* See the GNU General Public License for more details. +!* +!* You should have received a copy of the GNU Lesser General Public +!* License along with the FV3 dynamical core. +!* If not, see . +!*********************************************************************** + +module fv_phys_mod + +use constants_mod, only: grav, rdgas, rvgas, pi, cp_air, cp_vapor, hlv, kappa +use fv_arrays_mod, only: radius, omega ! scaled for small earth + +use time_manager_mod, only: time_type, get_time +use gfdl_cld_mp_mod, only: gfdl_cld_mp_driver, qsmith, wet_bulb +use hswf_mod, only: Held_Suarez_Tend +use fv_sg_mod, only: fv_subgrid_z +use fv_update_phys_mod, only: fv_update_phys +use fv_timing_mod, only: timing_on, timing_off +use monin_obukhov_mod, only: mon_obkv +use tracer_manager_mod, only: get_tracer_index, adjust_mass +use field_manager_mod, only: MODEL_ATMOS +use fms_mod, only: error_mesg, FATAL, file_exist, open_namelist_file, & + check_nml_error, mpp_pe, mpp_root_pe, close_file, & + write_version_number, stdlog, mpp_error +use fv_mp_mod, only: is_master, mp_reduce_max +use fv_diagnostics_mod, only: prt_maxmin, gn + +use fv_arrays_mod, only: fv_grid_type, fv_flags_type, fv_nest_type, fv_grid_bounds_type, phys_diag_type, nudge_diag_type +use mpp_domains_mod, only: domain2d +use diag_manager_mod, only: register_diag_field, register_static_field, send_data +use qs_tables_mod, only: qs_wat_init, qs_wat + +implicit none + + logical:: nudge_initialized = .false. + logical:: sim_phys_initialized = .false. + logical:: g0_sum_initialized = .false. + logical:: qs_table_is_initialized = .false. + real, allocatable, dimension(:,:) :: l_area + real, allocatable, dimension(:,:) :: table_w(:), des_w(:) + logical:: master + real, allocatable:: u0(:,:,:), v0(:,:,:), t0(:,:,:), dp(:,:,:), u_star(:,:) + real, allocatable:: ts0(:,:) + real:: global_area = -1. + +public :: fv_phys, fv_nudge + +!---- version number ----- + character(len=8) :: mod_name = 'sim_phys' + + integer:: sphum, liq_wat, rainwat, snowwat, graupel, ice_wat, cld_amt +! For nudging the IC to a steady state: + real :: tau_winds = 25. + real :: tau_temp = -1. + real :: tau_press = -1. + + real, parameter:: e0 = 610.71 ! saturation vapor pressure at T0 + real, parameter:: tice = 273.16 +! real, parameter:: c_liq = 4.1855e+3 ! GFS + real, parameter:: c_liq = 4218.0 ! IFS + real, parameter:: cp_vap = cp_vapor ! 1846. +! For consistency, cv_vap derived FMS constants: + real, parameter:: cv_vap = cp_vap - rvgas ! 1384.5 + real, parameter:: cv_air = cp_air - rdgas +#ifdef SIM_NGGPS + real, parameter:: dc_vap = 0. +#else + real, parameter:: dc_vap = cp_vap - c_liq ! = -2344. isobaric heating/cooling +#endif + real, parameter:: Lv0 = hlv - dc_vap*tice +! L = hlv + (Cp_vapor-C_liq)*(T-T_ice) + real:: deg2rad = pi/180. + real:: zvir + real:: area_ref = 6.25E8 + real:: solar_constant = 1367. +! Namelist for Sim_Phys + + logical:: do_K_warm_rain = .false. !Enable Kessler + logical:: do_strat_HS_forcing = .true. !modified held-suarez + logical:: do_LS_cond = .false. !A Simple LS condensation scheme + logical:: do_GFDL_sim_phys = .false. !Enable GFDL simple physics + logical:: do_surf_drag = .false. ! a simple surface drag (bottom friction) scheme + real :: tau_surf_drag = 1. ! time-scale for the surface drag + logical:: do_reed_sim_phys = .false. + logical:: do_terminator = .false. + logical:: term_fill_negative = .false. + integer:: print_freq = 6 ! hours + integer:: seconds, days + logical :: print_diag + integer :: istep = 0 + + !GFDL Simplified Physics (mostly Frierson) + logical:: diurnal_cycle = .false. + logical:: mixed_layer = .false. + logical:: gray_rad = .false. + logical:: strat_rad = .false. + logical:: do_abl = .false. + logical:: do_mon_obkv = .true. + real:: heating_rate = 0.5 ! deg K per day, stratosphere, for gray-radiation + real:: cooling_rate = 0. ! deg K per day (note sign convention) + logical:: uniform_sst = .true. + real:: sst0 = 302.15 ! K + real:: sst_restore_timescale = 5. !days + integer :: sst_type = 0 ! choice of SST profile + real:: shift_n = 12. + logical:: do_t_strat = .false. + real:: p_strat = 50.E2 + real:: t_strat = 200. + real:: tau_strat = 10. ! days + real:: mo_t_fac = 1. + real:: tau_difz = 600. !prescribed surface roughness (?) if do_mon_obkv not set + logical:: prog_low_cloud = .true. + real:: low_cf0 = 0.3 ! global mean *low* cloud fraction + logical:: zero_winds = .false. ! use this only for the doubly periodic domain + real:: tau_zero = 1. ! time-scale to "zero" domain-averaged winds (days) + logical:: do_mo_fixed_cd = .false. ! NJ, fixed drag option + real:: mo_cd = 1.5e-3 ! NJ, fixed drag coefficient + real:: mo_u_mean = 0. ! NJ, mean wind for enthalpy fluxes + real:: abl_s_fac = 0.1 + real:: ml_c0 = 6.285E7 ! Ocean heat capabicity 4190*depth*e3, depth = 15. + real:: sw_abs = 0. ! fraction of the solar absorbed/reflected by the atm + + + !Kessler parameters + logical:: K_sedi_transport = .false. + logical:: do_K_sedi_w = .false. + logical:: do_K_sedi_heat = .false. + integer:: K_cycle = 0 ! K_warm-Rain cycles + + !Reed physics parameters + logical:: do_reed_cond = .false. !Do reed condensation in addition to surface fluxes + logical:: reed_cond_only = .false. !Do NOT do reed surface fluxes, only condensation scheme + logical:: reed_alt_mxg = .false. !Use silly alternate mixing scheme to fix MPAS's problems + integer:: reed_test = 0 ! Constant SST + + !Diagnostics + integer :: id_vr_k, id_rain, id_rain_k, id_pblh + integer :: id_dqdt, id_dTdt, id_dudt, id_dvdt + integer :: id_qflux, id_hflux + real, allocatable:: prec_total(:,:) + real :: missing_value = -1.e10 + + logical :: first_call = .true. + +namelist /sim_phys_nml/do_strat_HS_forcing, & + print_freq, tau_winds, & + tau_temp, tau_press, sst_restore_timescale, & + do_K_warm_rain, do_GFDL_sim_phys,& + do_reed_sim_phys, do_LS_cond, do_surf_drag, & + tau_surf_drag, do_terminator + +namelist /GFDL_sim_phys_nml/ diurnal_cycle, mixed_layer, gray_rad, strat_rad, do_abl, do_mon_obkv, & + heating_rate, cooling_rate, uniform_sst, sst0, sst_type, shift_n, do_t_strat, p_strat, t_strat, tau_strat, & + mo_t_fac, tau_difz, prog_low_cloud, low_cf0, zero_winds, tau_zero, do_mo_fixed_cd, mo_cd, mo_u_mean, & + abl_s_fac, ml_c0, sw_abs + +namelist /Kessler_sim_phys_nml/ K_sedi_transport, do_K_sedi_w, do_K_sedi_heat, K_cycle + +namelist /reed_sim_phys_nml/ do_reed_cond, reed_cond_only,& + reed_alt_mxg, reed_test + +contains + + subroutine fv_phys(npx, npy, npz, is, ie, js, je, ng, nq, & + u, v, w, pt, q, pe, delp, peln, pkz, pdt, & + ua, va, phis, grid, ptop, ak, bk, ks, ps, pk,& + u_srf, v_srf, ts, delz, hydrostatic, & + oro, rayf, p_ref, fv_sg_adj, & + do_Held_Suarez, gridstruct, flagstruct, & + neststruct, nwat, bd, domain, & !S-J: Need to update fv_phys call + Time, phys_diag, nudge_diag, time_total) + + integer, INTENT(IN ) :: npx, npy, npz + integer, INTENT(IN ) :: is, ie, js, je, ng, nq, nwat + integer, INTENT(IN ) :: fv_sg_adj + real, INTENT(IN) :: p_ref, ptop + real, INTENT(IN) :: oro(is:ie,js:je) + + real , INTENT(INOUT) :: u(is-ng:ie+ ng,js-ng:je+1+ng,npz) + real , INTENT(INOUT) :: v(is-ng:ie+1+ng,js-ng:je+ ng,npz) + real , INTENT(INOUT) :: w(is-ng:ie+ ng,js-ng:je+ ng,npz) + real , INTENT(INOUT) :: pt(is-ng:ie+ ng,js-ng:je+ ng,npz) + real , INTENT(INOUT) :: delp(is-ng:ie+ ng,js-ng:je+ ng,npz) + real , INTENT(INOUT) :: q(is-ng:ie+ ng,js-ng:je+ ng,npz, nq) + real , INTENT(INOUT) :: pe(is-1:ie+1 ,1:npz+1,js-1:je+1) + real , INTENT(INOUT) :: peln(is :ie ,1:npz+1,js :je ) + real , INTENT(INOUT) :: pkz(is :ie ,js :je ,1:npz) + real , INTENT(INOUT) :: pk (is :ie ,js :je ,npz+1) + real , INTENT(INOUT) :: ua(is-ng:ie+ng,js-ng:je+ng,npz) + real , INTENT(INOUT) :: va(is-ng:ie+ng,js-ng:je+ng,npz) + real , INTENT(INOUT) :: ps(is-ng:ie+ng,js-ng:je+ng) + + real , INTENT(IN ) :: phis(is-ng:ie+ng,js-ng:je+ng) + real , INTENT(IN ) :: grid(is-ng:ie+ng,js-ng:je+ng, 2) + real , INTENT(IN ) :: ak(npz+1), bk(npz+1) + integer, INTENT(IN ) :: ks + + real , INTENT(IN ) :: pdt + logical, INTENT(IN ) :: rayf, do_Held_Suarez + real, INTENT(inout):: u_srf(is:ie,js:je) + real, INTENT(inout):: v_srf(is:ie,js:je) + real, INTENT(inout):: ts(is:ie,js:je) + type(phys_diag_type), intent(inout) :: phys_diag + type(nudge_diag_type), intent(inout) :: nudge_diag + + type(fv_grid_type) :: gridstruct + type(fv_flags_type) :: flagstruct + type(fv_nest_type) :: neststruct + type(fv_grid_bounds_type), intent(IN) :: bd + type(domain2d), intent(INOUT) :: domain + + type (time_type), intent(in) :: Time + real, INTENT(IN), optional:: time_total + logical, intent(in) :: hydrostatic + real, intent(inout) :: delz(is:,js:,1:) +! Local: + real, parameter:: sigb = 0.7 + logical:: no_tendency = .true. + integer, parameter:: nmax = 2 + real, allocatable:: u_dt(:,:,:), v_dt(:,:,:), t_dt(:,:,:), q_dt(:,:,:,:) + real, dimension(is:ie,npz):: dp2, pm, rdelp, u2, v2, t2, q2, du2, dv2, dt2, dq2 + real:: lcp(is:ie), den(is:ie) + real:: rain(is:ie,js:je), rain2(is:ie), zint(is:ie,1:npz+1) + real:: dq, dqsdt, delm, adj, rkv, sigl, tmp, prec, rgrav + real :: qdiag(1,1,1) + logical moist_phys + integer isd, ied, jsd, jed + integer i, j, k, m, n, int + integer theta_d, Cl, Cl2 + logical used + + call get_time (time, seconds, days) + + if (print_freq < 0) then + istep = istep + 1 + print_diag = (mod(istep,-print_freq) == 0) + else + if ( mod(seconds, print_freq*3600)==0 ) then + print_diag = .true. + else + print_diag = .false. + endif + endif + + master = is_master() +! if (.not. sim_phys_initialized) call fv_phys_init(is, ie, js, je, nwat, ts, time, axes, & +! gridstruct%agrid(:,:,2)) + sphum = get_tracer_index (MODEL_ATMOS, 'sphum') + liq_wat = get_tracer_index (MODEL_ATMOS, 'liq_wat') + ice_wat = get_tracer_index (MODEL_ATMOS, 'ice_wat') + rainwat = get_tracer_index (MODEL_ATMOS, 'rainwat') + snowwat = get_tracer_index (MODEL_ATMOS, 'snowwat') + graupel = get_tracer_index (MODEL_ATMOS, 'graupel') + cld_amt = get_tracer_index (MODEL_ATMOS, 'cld_amt') + + rkv = pdt / (tau_surf_drag*24.*3600.) + + isd = is-ng; ied = ie + ng + jsd = js-ng; jed = je + ng + + allocate ( u_dt(isd:ied,jsd:jed,npz) ) + allocate ( v_dt(isd:ied,jsd:jed,npz) ) + allocate ( t_dt(is:ie,js:je,npz) ) + allocate ( q_dt(is:ie,js:je,npz,nq) ) + +! Place the memory in the optimal shared mem space! +!$OMP parallel do default(none) shared(isd,ied,jsd,jed,npz,is,ie,js,je,nq,u_dt,v_dt,t_dt,q_dt) + do k=1, npz + do j=jsd, jed + do i=isd, ied + u_dt(i,j,k) = 0. + v_dt(i,j,k) = 0. + enddo + enddo + + do j=js, je + do i=is, ie + t_dt(i,j,k) = 0. + enddo + enddo + do n=1,nq + do j=js, je + do i=is, ie + q_dt(i,j,k,n) = 0. + enddo + enddo + enddo + enddo + + if ( fv_sg_adj > 0 ) then + if (is_master() .and. first_call) print*, " Calling fv_subgrid_z ", fv_sg_adj, flagstruct%n_sponge + call fv_subgrid_z(isd, ied, jsd, jed, is, ie, js, je, npz, min(6,nq), pdt, & + fv_sg_adj, nwat, delp, pe, peln, pkz, pt, q, ua, va, & + hydrostatic, w, delz, u_dt, v_dt, t_dt, q_dt, flagstruct%n_sponge ) + no_tendency = .false. + endif + + if ( do_LS_cond ) then + + moist_phys = .true. + zvir = rvgas/rdgas - 1. + theta_d = get_tracer_index (MODEL_ATMOS, 'theta_d') +!$omp parallel do default(shared) private(pm, adj, den, lcp, dq, dqsdt, delm) + do j=js,je + do i=is, ie + rain(i,j) = 0. + enddo + do n=1, nmax + if ( n == nmax ) then + adj = 1. + else + adj = 0.5 + endif + do k=1,npz + if ( hydrostatic ) then + do i=is, ie + pm(i,k) = delp(i,j,k)/(peln(i,k+1,j)-peln(i,k,j)) + den(i) = pm(i,k)/(rdgas*pt(i,j,k)*(1.+zvir*q(i,j,k,sphum))) +! MOIST_NGGPS +! lcp(i) = (Lv0+dc_vap*pt(i,j,k))/cp_air + lcp(i) = (Lv0+dc_vap*pt(i,j,k))/((1.-q(i,j,k,sphum)-q(i,j,k,liq_wat))*cp_air + & + q(i,j,k,sphum)*cp_vap + q(i,j,k,liq_wat)*c_liq) + enddo + else + do i=is, ie + den(i) = -delp(i,j,k)/(grav*delz(i,j,k)) +! MOIST_NGGPS +! lcp(i) = (Lv0+dc_vap*pt(i,j,k))/cv_air + lcp(i) = (Lv0+dc_vap*pt(i,j,k))/((1.-q(i,j,k,sphum)-q(i,j,k,liq_wat))*cv_air + & + q(i,j,k,sphum)*cv_vap + q(i,j,k,liq_wat)*c_liq) + enddo + endif + do i=is,ie + dq = q(i,j,k,sphum) - qs_wat(pt(i,j,k),den(i),dqsdt) + dq = adj*dq/(1.+lcp(i)*dqsdt) + if ( dq > 0. ) then ! remove super-saturation over water + pt(i,j,k) = pt(i,j,k) + dq*lcp(i) + q(i,j,k, sphum) = q(i,j,k, sphum) - dq +! the following line Detrains to liquid water + q(i,j,k,liq_wat) = q(i,j,k,liq_wat) + dq + rain(i,j) = rain(i,j) + dq*delp(i,j,k)/(pdt*grav) ! mm/sec + endif + enddo + enddo + enddo ! n-loop + + do k=2,npz+1 + do i=is,ie + pe(i,k,j) = pe(i,k-1,j) + delp(i,j,k-1) + peln(i,k,j) = log( pe(i,k,j) ) + pk(i,j,k) = exp( kappa*peln(i,k,j) ) + enddo + enddo + do i=is,ie + ps(i,j) = pe(i,npz+1,j) + enddo + if ( hydrostatic ) then + do k=1,npz + do i=is,ie + pkz(i,j,k) = (pk(i,j,k+1)-pk(i,j,k))/(kappa*(peln(i,k+1,j)-peln(i,k,j))) + enddo + enddo + endif + enddo ! j-loop + + if (id_rain > 0) then + rain(:,:) = rain (:,:) / pdt * 86400. + used=send_data(id_rain, rain, time) + endif + endif + + if ( do_K_warm_rain ) then + liq_wat = get_tracer_index (MODEL_ATMOS, 'liq_wat') + rainwat = get_tracer_index (MODEL_ATMOS, 'rainwat') + moist_phys = .true. + zvir = rvgas/rdgas - 1. + + if ( K_cycle .eq. 0 ) then + K_cycle = max(1, nint(pdt/30.)) ! 30 sec base time step + if( master ) write(*,*) 'Kessler warm-rain-phys cycles', trim(gn), ' =', K_cycle + endif + if (do_terminator) then + Cl = get_tracer_index (MODEL_ATMOS, 'Cl') + Cl2 = get_tracer_index (MODEL_ATMOS, 'Cl2') + do k=1,npz + do j=js,je + do i=is,ie + q(i,j,k,Cl) = q(i,j,k,Cl)*delp(i,j,k) + enddo + enddo + enddo + do k=1,npz + do j=js,je + do i=is,ie + q(i,j,k,Cl2) = q(i,j,k,Cl2)*delp(i,j,k) + enddo + enddo + enddo + endif + call K_warm_rain(pdt, is, ie, js, je, ng, npz, nq, zvir, ua, va, & + w, u_dt, v_dt, q, pt, delp, delz, & + pe, peln, pk, ps, rain, Time, flagstruct%hydrostatic) + + if( K_sedi_transport ) no_tendency = .false. + if (do_terminator) then + do k=1,npz + do j=js,je + do i=is,ie + q(i,j,k,Cl) = q(i,j,k,Cl)/delp(i,j,k) + enddo + enddo + enddo + do k=1,npz + do j=js,je + do i=is,ie + q(i,j,k,Cl2) = q(i,j,k,Cl2)/delp(i,j,k) + enddo + enddo + enddo + endif + + if ( id_rain_k>0 ) then + prec_total(:,:) = prec_total(:,:) + rain(:,:) + used = send_data(id_rain_k, prec_total, time) + if (print_diag) then + prec = g_sum(prec_total, is, ie, js, je, gridstruct%area(is:ie,js:je), 1) + if(master) write(*,*) ' Accumulated rain (m)', trim(gn), ' =', prec + endif + !call prt_maxmin(' W', w, is, ie, js, je, ng, npz, 1.) + endif + if ( id_rain>0 ) then + rain(:,:) = rain (:,:) / pdt * 86400. ! kg/dA => mm over timestep, convert to mm/d + used = send_data(id_rain, rain, time) + if (print_diag) call prt_maxmin(' Kessler rain rate (mm/day): ', rain, & + is,ie,js,je,0,1,1.) + endif + endif + + + if ( do_GFDL_sim_phys ) then + moist_phys = .true. + call timing_on('GFDL_SIM_PHYS') + call GFDL_sim_phys(npx, npy, npz, is, ie, js, je, ng, nq, nwat, pk, pkz, & + u_dt, v_dt, t_dt, q_dt, u, v, w, ua, va, pt, delz, q, & + pe, delp, peln, ts, oro, hydrostatic, pdt, grid, ak, bk, & !ts --> sst + p_ref, Time, time_total, flagstruct%grid_type, gridstruct) + call timing_off('GFDL_SIM_PHYS') + no_tendency = .false. + endif + + if ( do_reed_sim_phys ) then + moist_phys = .true. + zvir = rvgas/rdgas - 1. + rgrav = 1./grav +!$omp parallel do default(shared) private(den,u2,v2,t2,q2,dp2,pm,rdelp,du2, dv2, dt2, dq2) + do j=js,je +! Input to Reed_phys are hydrostatic and probably don't understand total mass either + do k=1,npz + do i=is,ie + dp2(i,k) = delp(i,j,k) + rdelp(i,k) = 1./dp2(i,k) + u2(i,k) = ua(i,j,k) + v2(i,k) = va(i,j,k) + t2(i,k) = pt(i,j,k) + q2(i,k) = max(0., q(i,j,k,sphum)) + pm(i,k) = dp2(i,k)/(peln(i,k+1,j)-peln(i,k,j)) + enddo + enddo + do i=is,ie + zint(i,k) = phis(i,j)*rgrav + enddo + if (hydrostatic) then + do k=npz,1,-1 + do i=is,ie + zint(i,k) = zint(i,k+1) + rdgas*rgrav*pt(i,j,k)*(1.+zvir*q(i,j,k,sphum)) * & + (peln(i,k+1,j)-peln(i,k,j)) + enddo + enddo + else + do k=npz,1,-1 + do i=is,ie + zint(i,k) = zint(i,k+1) - delz(i,j,k) + enddo + enddo + endif + do i=is,ie + rain2(i) = 0. + enddo + + call reed_sim_physics( ie-is+1, npz, pdt, gridstruct%agrid(is:ie,j,2), t2, & + q2, u2, v2, pm, pe(is:ie,1:npz+1,j), dp2, rdelp, & + pe(is:ie,npz+1,j), zint, reed_test, do_reed_cond, reed_cond_only, & + reed_alt_mxg, rain2, du2, dv2, dt2, dq2 ) + do k=1,npz + do i=is,ie + u_dt(i,j,k) = u_dt(i,j,k) + du2(i,k) + v_dt(i,j,k) = v_dt(i,j,k) + dv2(i,k) + t_dt(i,j,k) = t_dt(i,j,k) + dt2(i,k) + q_dt(i,j,k,sphum) = q_dt(i,j,k,sphum) + dq2(i,k) + enddo + enddo + if (do_reed_cond) then + do i=is,ie + rain(i,j) = rain2(i) * 8.64e7 ! m/s => mm/d + enddo + endif + enddo + if ( do_reed_cond .and. id_rain_k>0 ) then + prec_total(:,:) = prec_total(:,:) + rain(:,:) * pdt/ 86400. ! mm over timestep + used = send_data(id_rain_k, prec_total, time) + if (print_diag) then + prec = g_sum(prec_total, is, ie, js, je, gridstruct%area(is:ie,js:je), 1) + if(master) write(*,*) ' Accumulated rain (m)', trim(gn), ' =', prec + endif + !call prt_maxmin(' W', w, is, ie, js, je, ng, npz, 1.) + endif + if (do_reed_cond .and. id_rain > 0) then + used = send_data(id_rain, rain, time) + if (print_diag) call prt_maxmin(' Reed rain rate (mm/d): ', rain, & + is,ie,js,je,0,1,1.) + endif + no_tendency = .false. + endif + + if( do_Held_Suarez ) then + moist_phys = .false. + call Held_Suarez_Tend(npx, npy, npz, is, ie, js, je, ng, nq, & + u, v, pt, q, pe, delp, peln, pkz, pdt, & + ua, va, u_dt, v_dt, t_dt, q_dt, grid, & + delz, phis, hydrostatic, ak, bk, ks, & + do_strat_HS_forcing, .false., master, Time, time_total) + no_tendency = .false. + elseif ( do_surf_drag ) then +! Bottom friction: +!$omp parallel do default(shared) private(sigl,tmp) + + do k=1,npz + do j=js,je + do i=is,ie +! pm(i,k) = delp(i,j,k)/(peln(i,k+1,j)-peln(i,k,j)) + sigl = delp(i,j,k) / ((peln(i,k+1,j)-peln(i,k,j))*pe(i,npz+1,j)) + sigl = (sigl-sigb)/(1.-sigb) * rkv + if (sigl > 0.) then + tmp = sigl / ((1.+sigl)*pdt) + u_dt(i,j,k) = u_dt(i,j,k) - ua(i,j,k)*tmp + v_dt(i,j,k) = v_dt(i,j,k) - va(i,j,k)*tmp + if ( hydrostatic ) then + pt(i,j,k) = pt(i,j,k) + pdt*tmp*(ua(i,j,k)**2+va(i,j,k)**2)/cp_air + else + pt(i,j,k) = pt(i,j,k) + pdt*tmp*(ua(i,j,k)**2+va(i,j,k)**2)/cv_air + endif + endif + enddo !i-loop + enddo !j-loop + enddo !k-loop + no_tendency = .false. + endif + + if (do_terminator) then + call DCMIP2016_terminator_advance(is,ie,js,je,isd,ied,jsd,jed,npz, & + q, delp, flagstruct%ncnst, & + gridstruct%agrid(isd,jsd,1),gridstruct%agrid(isd,jsd,2), pdt) + endif + + + if (id_dudt > 0) then + used=send_data(id_dudt, u_dt(is:ie,js:je,npz), time) + endif + if (id_dvdt > 0) then + used=send_data(id_dvdt, v_dt(is:ie,js:je,npz), time) + endif + if (id_dtdt > 0) then + used=send_data(id_dtdt, t_dt(:,:,:), time) + endif + if (id_dqdt > 0) then + used=send_data(id_dqdt, q_dt(:,:,:,sphum), time) + endif + + + if ( .not. no_tendency ) then + call timing_on('UPDATE_PHYS') + call fv_update_phys (pdt, is, ie, js, je, isd, ied, jsd, jed, ng, nq, & + u, v, w, delp, pt, q, qdiag, ua, va, ps, pe, peln, pk, pkz, & + ak, bk, phis, u_srf, v_srf, ts, & + delz, hydrostatic, u_dt, v_dt, t_dt, & + moist_phys, Time, .false., gridstruct, & + gridstruct%agrid(:,:,1), gridstruct%agrid(:,:,2), & + npx, npy, npz, flagstruct, neststruct, bd, domain, ptop, & + phys_diag, nudge_diag, q_dt=q_dt) + + call timing_off('UPDATE_PHYS') + endif + deallocate ( u_dt ) + deallocate ( v_dt ) + deallocate ( t_dt ) + deallocate ( q_dt ) + + first_call = .false. + + end subroutine fv_phys + + + subroutine GFDL_sim_phys(npx, npy, npz, is, ie, js, je, ng, nq, nwat, pk, pkz, & + u_dt, v_dt, t_dt, q_dt, u, v, w, ua, va, & + pt, delz, q, pe, delp, peln, sst, oro, hydrostatic, & + pdt, agrid, ak, bk, p_ref, & + Time, time_total, grid_type, gridstruct) +!----------------------- +! A simple moist physics +!----------------------- + + + integer, INTENT(IN) :: npx, npy, npz + integer, INTENT(IN) :: is, ie, js, je, ng, nq, nwat, grid_type + real , INTENT(IN) :: pdt + real , INTENT(IN) :: agrid(is-ng:ie+ng,js-ng:je+ng, 2) + real , INTENT(IN) :: ak(npz+1), bk(npz+1) + real, INTENT(IN):: p_ref + real, INTENT(IN):: oro(is:ie,js:je) ! land fraction + logical, INTENT(IN):: hydrostatic + + type(time_type), intent(in) :: Time + real, INTENT(IN), optional:: time_total + + real , INTENT(INOUT) :: u(is-ng:ie+ ng,js-ng:je+1+ng,npz) + real , INTENT(INOUT) :: v(is-ng:ie+1+ng,js-ng:je+ ng,npz) + real, INTENT(INOUT):: pk (is:ie,js:je,npz+1) + real, INTENT(INOUT):: pkz(is:ie,js:je,npz) + real, INTENT(INOUT):: pt(is-ng:ie+ng,js-ng:je+ng,npz) + real, INTENT(INOUT):: delp(is-ng:ie+ng,js-ng:je+ng,npz) + real, INTENT(INOUT):: q(is-ng:ie+ng,js-ng:je+ng,npz, nq) + real, INTENT(INOUT):: pe(is-1:ie+1 ,1:npz+1,js-1:je+1) + real, INTENT(INOUT):: peln(is :ie ,1:npz+1,js :je ) + real, INTENT(INOUT):: delz(is :ie ,js :je ,npz) + real, intent(inout):: w(is-ng:ie+ng,js-ng:je+ng,npz) + real, INTENT(INOUT):: sst(is:ie,js:je) + + type(fv_grid_type) :: gridstruct + +! Tendencies: + real, INTENT(INOUT):: u_dt(is-ng:ie+ng,js-ng:je+ng,npz) + real, INTENT(INOUT):: v_dt(is-ng:ie+ng,js-ng:je+ng,npz) + real, INTENT(INOUT):: t_dt(is:ie,js:je,npz) + real, INTENT(INOUT):: q_dt(is:ie,js:je,npz,nq) + real, INTENT(IN):: ua(is-ng:ie+ng,js-ng:je+ng,npz) + real, INTENT(IN):: va(is-ng:ie+ng,js-ng:je+ng,npz) +! Local + real, dimension(is:ie,js:je):: flux_t, flux_q, flux_u, flux_v, delm, drag_t, drag_q + logical:: phys_hydrostatic = .true. + real, parameter:: f1 = 2./3. + real, parameter:: f2 = 1./3. + real, dimension(is:ie,js:je,npz):: u3, v3, t3, p3, dz, zfull + real, dimension(is:ie,js:je,npz+1):: zhalf + real, dimension(is:ie,js:je,npz,nq):: q3 + real, dimension(is:ie,js:je):: rain, snow, ice, graup, land, mu + real, dimension(is:ie,js:je):: ps, qs, rho, clouds + real, dimension(is:ie,js:je):: olr, lwu, lwd, sw_surf, wet_t, net_rad +! Flux diag: + real, dimension(is:ie,js:je):: rflux, qflux + real, dimension(is:ie,npz):: den + real, dimension(is:ie,npz):: t_dt_rad + real, dimension(npz):: utmp, vtmp + real:: sday, rrg, tvm, olrm, swab, sstm, clds, hflux1, hflux2, hflux3, precip + real:: tmp, cooling, heating + real:: fac_sm, rate_w, rate_u, rate_v, rate_t, rate_q + real:: prec + integer i,j,k, km, iq, k_mp + integer isd, ied, jsd, jed + integer seconds, days + logical used + +! if (.not. sim_phys_initialized) call fv_phys_init(nwat) + + call get_time (time, seconds, days) + + km = npz + isd = is-ng; ied = ie + ng + jsd = js-ng; jed = je + ng + + zvir = rvgas/rdgas - 1. +! Factor for Small-Earth Approx. + fac_sm = radius / 6371.0e3 + rrg = rdgas / grav + sday = 24.*3600.*fac_sm !not sure this works right + + qflux = 0. + rflux = 0. + + + +! Compute zfull, zhalf + do j=js,je + do i=is,ie + zhalf(i,j,npz+1) = 0. + ps(i,j) = pe(i,km+1,j) + enddo + enddo + + if ( hydrostatic ) then + do k=km,1,-1 + do j=js,je + do i=is,ie + tvm = rrg*pt(i,j,k)*(1.+zvir*q(i,j,k,1)) + dz(i,j,k) = -tvm*(peln(i,k+1,j)-peln(i,k,j)) + p3(i,j,k) = delp(i,j,k)/(peln(i,k+1,j)-peln(i,k,j)) + zfull(i,j,k) = zhalf(i,j,k+1) + tvm*(1.-pe(i,k,j)/p3(i,j,k)) + zhalf(i,j,k) = zhalf(i,j,k+1) - dz(i,j,k) + enddo + enddo + enddo + else + do k=km,1,-1 + do j=js,je + do i=is,ie + dz(i,j,k) = delz(i,j,k) + p3(i,j,k) = delp(i,j,k)/(peln(i,k+1,j)-peln(i,k,j)) + zhalf(i,j,k) = zhalf(i,j,k+1) - dz(i,j,k) + zfull(i,j,k) = zhalf(i,j,k+1) - 0.5*dz(i,j,k) + enddo + enddo + enddo + endif + + do k=1, km + do j=js,je + do i=is,ie + u3(i,j,k) = ua(i,j,k) + pdt*u_dt(i,j,k) + v3(i,j,k) = va(i,j,k) + pdt*v_dt(i,j,k) + t3(i,j,k) = pt(i,j,k) + pdt*t_dt(i,j,k) + enddo + enddo + enddo + + do j=js,je + do i=is,ie + delm(i,j) = delp(i,j,km)/grav + rho(i,j) = -delm(i,j)/dz(i,j,km) + enddo + enddo + +!---------- +! Setup SST: +!---------- + +! Need to save sst in a restart file if mixed_layer = .T. + if ( .not. mixed_layer ) then +!!$ if ( uniform_sst ) then +!!$ sst(:,:) = sst0 +!!$ else +!!$ if (sst_type == 1) then !SST in equib with lower atmosphere +!!$ do j=js,je +!!$ do i=is,ie +!!$ !ts0(i,j) = pt(i,j,km) +!!$ sst(i,j) = ts0(i,j) +!!$ enddo +!!$ enddo +!!$ else +!!$ do j=js,je +!!$ do i=is,ie +!!$ ts0(i,j) = 270.5 + 32.*exp( -((agrid(i,j,2)-shift_n*deg2rad)/(pi/3.))**2 ) +!!$ enddo +!!$ enddo +!!$ endif +!!$ endif + do j=js,je + do i=is,ie + sst(i,j) = ts0(i,j) + enddo + enddo + endif + + + do iq=1,nq + do k=1,npz + do j=js,je + do i=is,ie + q3(i,j,k,iq) = q(i,j,k,iq) + pdt*q_dt(i,j,k,iq) + enddo + enddo + enddo + enddo + + +!---------------------------- +! Apply net radiative cooling +!---------------------------- + if ( gray_rad ) then + if ( prog_low_cloud ) then + call get_low_clouds( is,ie, js,je, km, q3(is,js,1,liq_wat), q3(is,js,1,ice_wat), & + q3(is,js,1,cld_amt), clouds ) + else + clouds(:,:) = low_cf0 + endif + + do j=js,je + do k=1, km + do i=is,ie + den(i,k) = -delp(i,j,k)/(grav*dz(i,j,k)) + enddo + enddo + call gray_radiation(seconds, is, ie, km, agrid(is:ie,j,1), agrid(is,j,2), clouds(is,j), & + sst(is,j), t3(is:ie,j,1:km), ps(is,j), pe(is:ie,1:km+1,j), & + dz(is:ie,j,1:km), den, t_dt_rad, & + olr(is,j), lwu(is,j), lwd(is,j), sw_surf(is,j)) + do k=1, km + do i=is,ie + t_dt(i,j,k) = t_dt(i,j,k) + t_dt_rad(i,k) + enddo + enddo + enddo + if ( print_diag ) then + if ( gray_rad ) then + olrm = g0_sum(olr, is, ie, js, je, 0, gridstruct%area(is:ie,js:je), 1) + swab = g0_sum(sw_surf, is, ie, js, je, 0, gridstruct%area(is:ie,js:je), 1) + + endif + + if ( prog_low_cloud ) & + clds = g0_sum(clouds, is, ie, js, je, 0, gridstruct%area(is:ie,js:je), 1) + + if( master ) then + if ( gray_rad ) then + write(*,*) 'Domain mean OLR', trim(gn), ' =', olrm + write(*,*) 'Domain mean SWA', trim(gn), ' =', swab + endif + if ( prog_low_cloud ) write(*,*) 'Domain mean low clouds fraction', trim(gn), ' =', clds + endif + endif + + else + +! Prescribed (non-interating) heating/cooling rate: + rate_t = 1. / (tau_strat*86400. + pdt ) +! cooling = cooling_rate/sday + + + if ( cooling_rate > 1.e-5 ) then + do k=1, km + do j=js, je + do i=is, ie + cooling = cooling_rate*(f1+f2*cos(agrid(i,j,2)))/sday + if ( p3(i,j,k) >= 100.E2 ) then + t_dt(i,j,k) = t_dt(i,j,k) - cooling*min(1.0, (p3(i,j,k)-100.E2)/200.E2) + elseif ( do_t_strat ) then + if ( p3(i,j,k) < p_strat) then + t_dt(i,j,k) = t_dt(i,j,k) + (t_strat - t3(i,j,k))*rate_t + endif + endif + enddo + enddo + enddo ! k-loop + endif + + endif + + + if ( strat_rad ) then +! Solar heating above 100 mb: + heating = heating_rate / 86400. + do k=1, km + do j=js,je + do i=is,ie + if ( p3(i,j,k) < 100.E2 ) then + t_dt(i,j,k) = t_dt(i,j,k) + heating*(100.E2-p3(i,j,k))/100.E2 + endif + enddo + enddo + enddo + endif + + + do k=1, km + do j=js,je + do i=is,ie + t3(i,j,k) = pt(i,j,k) + pdt*t_dt(i,j,k) + enddo + enddo + enddo + + + +!--------------- +! Surface fluxes +!--------------- + +if( do_mon_obkv ) then + + call qsmith(ie-is+1, je-js+1, 1, sst, ps, q3(is:ie,js:je,km,sphum), qs) + call qsmith(ie-is+1, je-js+1, 1, sst, ps, qs, qs) ! Iterate once + +! Need to save ustar in a restart file (sim_phys) +! Because u_star is prognostic but not saved +! simple physics will not reproduce across restarts. + if ( .not. allocated(u_star) ) then + allocate ( u_star(is:ie,js:je) ) +! u_star(:,:) = 1.E25 ! large enough to cause blowup if used + u_star(:,:) = 1.E-3 + endif + + call timing_on('mon_obkv') + call mon_obkv(zvir, ps, t3(is:ie,js:je, km), zfull(is:ie,js:je,km), & + rho, p3(is:ie,js:je,km), u3(is:ie,js:je,km), v3(is:ie,js:je,km), mo_u_mean, do_mo_fixed_cd, mo_cd, sst, & + qs, q3(is:ie,js:je,km,sphum), drag_t, drag_q, flux_t, flux_q, flux_u, flux_v, u_star, & + delm, pdt, mu, mo_t_fac, master) + call timing_off('mon_obkv') +!--------------------------------------------------- +! delp/grav = delm = kg/m**2 +! watts = J/s = N*m/s = kg * m**2 / s**3 +! CP = J/kg/deg +! flux_t = w/m**2 = J / (s*m**2) +!--------------------------------------------------- + do j=js,je + do i=is,ie + rate_u = flux_u(i,j)/delm(i,j) + u3(i,j,km) = u3(i,j,km) + pdt*rate_u + u_dt(i,j,km) = u_dt(i,j,km) + rate_u + rate_v = flux_v(i,j)/delm(i,j) + v3(i,j,km) = v3(i,j,km) + pdt*rate_v + v_dt(i,j,km) = v_dt(i,j,km) + rate_v + rate_t = flux_t(i,j)/(cp_air*delm(i,j)) + t_dt(i,j,km) = t_dt(i,j,km) + rate_t + t3(i,j,km) = t3(i,j,km) + rate_t*pdt + rate_q = flux_q(i,j)/delm(i,j) + q_dt(i,j,km,sphum) = q_dt(i,j,km,sphum) + rate_q + q3(i,j,km,sphum) = q3(i,j,km,sphum) + rate_q*pdt + enddo + enddo +endif + +!!$if (id_flux_t > 0) then +!!$ used=send_data(id_flux_t, flux_t(:,:), Time) +!!$endif +!!$if (id_flux_q > 0) then +!!$ used=send_data(id_flux_q, 2.5e6*flux_q(:,:), Time) +!!$ +!!$endif +!!$ +!!$if (id_drag_t > 0) then +!!$ used=send_data(id_drag_t, drag_t(:,:), Time) +!!$endif +!!$if (id_drag_q > 0) then +!!$ used=send_data(id_drag_q, drag_q(:,:), Time) +!!$ +!!$endif + +if ( zero_winds ) then + + if (grid_type /= 4) then + call mpp_error(FATAL, "fv_phys::GFDL_SIM_PHYS: zero_winds only works with doubly-periodic domain (grid_type = 4).") + endif + +! Zero out (doubly periodic) domain averaged winds with time-scale tau_zero: +! This loop can not be openMP-ed + do k=1, km + utmp(k) = g0_sum(u3(is,js,k), is, ie, js, je, 0, gridstruct%area(is:ie,js:je), 1) + vtmp(k) = g0_sum(v3(is,js,k), is, ie, js, je, 0, gridstruct%area(is:ie,js:je), 1) +#ifdef PRINT_W + if ( master ) then + if( sqrt(utmp(k)**2+vtmp(k)**2) > 1. ) then + write(*,*) k, 'Domain avg winds', trim(gn), '=', utmp, vtmp + endif + endif +#endif + enddo + + rate_w = min(1., 1./(tau_zero*86400.)) +!$omp parallel do default(shared) + do k=1, km + do j=js,je + do i=is,ie + u_dt(i,j,k) = u_dt(i,j,k) - utmp(k) * rate_w + v_dt(i,j,k) = v_dt(i,j,k) - vtmp(k) * rate_w + enddo + enddo + enddo + +endif + + if ( do_abl ) then +! ABL: vertical diffusion: + if (.not. do_mon_obkv ) then + do j=js,je + do i=is,ie + mu(i,j) = -sqrt(gridstruct%area(i,j)/area_ref)*dz(i,j,km)/tau_difz + enddo + enddo + endif + + call pbl_diff(hydrostatic, pdt, is, ie, js, je, ng, km, nq, u3, v3, t3, & + w, q3, delp, p3, pe, sst, mu, dz, u_dt, v_dt, t_dt, q_dt, & + gridstruct%area, print_diag, Time ) + endif + + + if ( mixed_layer ) then + do j=js, je + do i=is, ie +#ifdef RAIN_FLUX + !rain, etc. never defined + precip = (rain(i,j)+snow(i,j)+ice(i,j)+graup(i,j)) / 86400. +#ifdef NO_WET_T + if ( precip > 0. ) then + tmp = -delp(i,j,km)/(grav*dz(i,j,km)) + wet_t(i,j) = wet_bulb(q3(i,j,km,1), t3(i,j,km), tmp) + else + wet_t(i,j) = t3(i,j,km) + endif + rflux(i,j) = c_liq*precip*(sst(i,j)-wet_t(i,j)) +#else + rflux(i,j) = c_liq*precip*(sst(i,j)-t3(i,j,km)) +#endif +#else + rflux(i,j) = 0.0 +#endif + qflux(i,j) = hlv*flux_q(i,j) + enddo + enddo + + if ( gray_rad ) then + do j=js, je + do i=is, ie + sst(i,j) = sst(i,j)+pdt*(sw_surf(i,j) + lwd(i,j) - rflux(i,j) & + - flux_t(i,j) - qflux(i,j) - lwu(i,j))/ml_c0 + enddo + enddo + if ( print_diag ) then + net_rad = sw_surf + lwd - lwu + hflux1 = g0_sum(net_rad, is, ie, js, je, 0, gridstruct%area(is:ie,js:je), 1) + net_rad = net_rad - rflux - flux_t - qflux + hflux2 = g0_sum(net_rad, is, ie, js, je, 0, gridstruct%area(is:ie,js:je), 1) + if(master) write(*,*) 'Net_flux', trim(gn), '=',hflux2, 'net_rad', trim(gn), '=', hflux1 + endif + else +! Unit flux_q, moisture flux (kg/sm^2) + do j=js, je + do i=is, ie + sst(i,j) = sst(i,j) - pdt*(rflux(i,j) + flux_t(i,j) + qflux(i,j))/ml_c0 + enddo + enddo + endif + if ( sst_restore_timescale > 1.e-7 ) then + rate_t = pdt / (sst_restore_timescale*86400.) + do j=js, je + do i=is, ie + sst(i,j) = (sst(i,j)+rate_t*ts0(i,j)) / (1.+rate_t) + enddo + enddo + endif + + if ( print_diag ) then + do j=js, je + do i=is, ie + wet_t(i,j) = t3(i,j,km) - wet_t(i,j) + enddo + enddo + call prt_maxmin('WETB_DT:', wet_t, is, ie, js, je, 0, 1, 1.0) + call prt_maxmin('Mixed-layer SST:', sst, is, ie, js, je, 0, 1, 1.0) + sstm = g0_sum(sst, is, ie, js, je, 0, gridstruct%area(is:ie,js:je), 1) + if(master) write(*,*) 'Domain mean SST', trim(gn), '=', sstm +! Fluxes: + hflux1 = g0_sum(rflux, is, ie, js, je, 0, gridstruct%area(is:ie,js:je), 1) + hflux2 = g0_sum(qflux, is, ie, js, je, 0, gridstruct%area(is:ie,js:je), 1) + hflux3 = g0_sum(flux_t, is, ie, js, je, 0, gridstruct%area(is:ie,js:je), 1) + if(master) write(*,*) 'RainF', trim(gn), '=',hflux1, 'LatentF', trim(gn), '=', hflux2, 'SenHF', trim(gn), '=', hflux3 + call prt_maxmin('Rain_F', rflux, is, ie, js, je, 0, 1, 1.0) + call prt_maxmin('LatH_F', qflux, is, ie, js, je, 0, 1, 1.0) + call prt_maxmin('SenH_F', flux_t, is, ie, js, je, 0, 1, 1.0) + endif + + endif + + if (id_qflux > 0) used=send_data(id_qflux, qflux, time) + if (id_hflux > 0) used=send_data(id_hflux, flux_t, time) + + + end subroutine GFDL_sim_phys + + + subroutine pbl_diff(hydrostatic, dt, is, ie, js, je, ng, km, nq, ua, va, & + ta, w, q, delp, pm, pe, ts, mu, dz, udt, vdt, tdt, qdt, & + area, print_diag, Time ) + logical, intent(in):: hydrostatic + integer, intent(in):: is, ie, js, je, ng, km, nq + real, intent(in):: dt + real, intent(in), dimension(is:ie,js:je):: ts, mu + real, intent(in), dimension(is:ie,js:je,km):: dz, pm + real, intent(in):: pe(is-1:ie+1 ,1:km+1,js-1:je+1) + real, intent(inout), dimension(is:ie,js:je,km):: ua, va, ta, tdt + real, intent(inout), dimension(is-ng:ie+ng,js-ng:je+ng,km):: w, udt, vdt, delp + real, intent(inout), dimension(is:ie,js:je,km,nq):: q, qdt + logical, intent(in):: print_diag + real, intent(in) :: area(is-ng:ie+ng,js-ng:je+ng) + type(time_type), intent(in) :: Time +! Local: + real, dimension(is:ie,js:je):: pblh + real, dimension(is:ie,km+1):: gh + real, dimension(is:ie,km):: nu, a, f, r, q2, den + real, dimension(is:ie,km):: gz, hd, te + real, dimension(is:ie):: kz + real, parameter:: mu_min = 1.E-5 ! ~ molecular viscosity + real, parameter:: ustar2 = 1.E-4 + integer:: n, i, j, k + real:: cv, rcv, rdt, tmp, tvm, tv_surf, surf_h, rin + logical:: used + + cv = cp_air - rdgas + rcv = 1./cv + rdt = 1./dt + +! Put opnmp loop here + do 1000 j=js, je + + do i=is, ie + gh(i,km+1) = 0. + pblh(i,j) = 0. + enddo + do k=km, 1, -1 + do i=is, ie + gh(i,k) = gh(i,k+1) - dz(i,j,k) + enddo + enddo + +! Locate PBL top (m) + do 125 i=is, ie + tv_surf = ts(i,j)*(1.+zvir*q(i,j,km,sphum)) + do k=km, km/4,-1 + tvm = ta(i,j,k)*(1.+zvir*q(i,j,k,sphum)-q(i,j,k,liq_wat)- & + q(i,j,k,ice_wat)-q(i,j,k,snowwat)-q(i,j,k,rainwat)-q(i,j,k,graupel)) + tvm = tvm*(pe(i,km+1,j)/pm(i,j,k))**kappa + rin = grav*(gh(i,k+1)-0.5*dz(i,j,k))*(tvm-tv_surf) / ( 0.5*(tv_surf+tvm)* & + (ua(i,j,k)**2+va(i,j,k)**2+ustar2) ) + if ( rin > 1. ) then + pblh(i,j) = gh(i,k+1) + goto 125 + endif + enddo +125 continue + + do k=km, 1, -1 + do i=is, ie + if ( gh(i,k)>6.E3 .or. (pblh(i,j) < -0.5*dz(i,j,km)) ) then + nu(i,k) = mu_min + else + kz(i) = 0.5*mu(i,j)*gh(i,km) + surf_h = abl_s_fac*pblh(i,j) + if ( gh(i,k) <= surf_h) then + kz(i) = mu(i,j)*gh(i,k) + nu(i,k) = kz(i) + elseif (gh(i,k) <= pblh(i,j)) then +! Use Dargan's form: + nu(i,k) = kz(i)*gh(i,k)/surf_h*(1.-(gh(i,k)-surf_h)/(pblh(i,j)-surf_h))**2 + else + nu(i,k) = mu_min + endif + endif + enddo + enddo + + do k=1,km-1 + do i=is, ie + a(i,k) = -nu(i,k) / ( 0.5*(dz(i,j,k)+dz(i,j,k+1)) ) + enddo + enddo + do i=is, ie + a(i,km) = 0. + enddo + + if ( .not. hydrostatic ) then + do k=1, km + do i=is,ie + gz(i,k) = grav*(gh(i,k+1) - 0.5*dz(i,j,k)) + tmp = gz(i,k) + 0.5*(ua(i,j,k)**2+va(i,j,k)**2+w(i,j,k)**2) + tvm = ta(i,j,k)*(1.+zvir*q(i,j,k,sphum)) + hd(i,k) = cp_air*tvm + tmp + te(i,k) = cv*tvm + tmp + enddo + enddo + endif + +! u-diffusion + do k=1,km + do i=is, ie + den(i,k) = delp(i,j,k)/dz(i,j,k) + q2(i,k) = ua(i,j,k)*den(i,k) + f(i,k) = -dz(i,j,k)*rdt + r(i,k) = -f(i,k)*q2(i,k) + enddo + enddo + call trid_dif2(a, f, r, q2, is, ie, km) + do k=1,km + do i=is, ie + q2(i,k) = q2(i,k) / den(i,k) + udt(i,j,k) = udt(i,j,k) + rdt*(q2(i,k) - ua(i,j,k)) + ua(i,j,k) = q2(i,k) + enddo + enddo +!--- +! v-diffusion + do k=1,km + do i=is, ie + q2(i,k) = va(i,j,k)*den(i,k) + r(i,k) = -f(i,k)*q2(i,k) + enddo + enddo + call trid_dif2(a, f, r, q2, is, ie, km) + do k=1,km + do i=is, ie + q2(i,k) = q2(i,k) / den(i,k) + vdt(i,j,k) = vdt(i,j,k) + rdt*(q2(i,k) - va(i,j,k)) + va(i,j,k) = q2(i,k) + enddo + enddo +!--- + if ( .not. hydrostatic ) then +! w-diffusion + do k=1,km + do i=is, ie + q2(i,k) = w(i,j,k) * den(i,k) + r(i,k) = -f(i,k)*q2(i,k) + enddo + enddo + call trid_dif2(a, f, r, q2, is, ie, km) + do k=1,km + do i=is, ie + w(i,j,k) = q2(i,k) / den(i,k) + enddo + enddo + endif +!--- micro-physics + do n=1, nq +! if ( (n.ne.rainwat) .and. (n.ne.snowwat) .and. (n.ne.graupel) .and. (n.ne.cld_amt) ) then + if ( n.ne.cld_amt ) then + do k=1,km + do i=is, ie + q2(i,k) = q(i,j,k,n)*den(i,k) + r(i,k) = -f(i,k)*q2(i,k) + enddo + enddo + call trid_dif2(a, f, r, q2, is, ie, km) + do k=1,km + do i=is, ie + q2(i,k) = q2(i,k) / den(i,k) + qdt(i,j,k,n) = qdt(i,j,k,n) + rdt*(q2(i,k) - q(i,j,k,n)) + q(i,j,k,n) = q2(i,k) + enddo + enddo + endif + enddo + +! Diffusion of dry static energy + if ( .not. hydrostatic ) then + do k=1,km + do i=is, ie + q2(i,k) = hd(i,k)*den(i,k) + r(i,k) = -f(i,k)*q2(i,k) + enddo + enddo + call trid_dif2(a, f, r, q2, is, ie, km) + do k=1,km + do i=is, ie + te(i,k) = te(i,k) + q2(i,k)/den(i,k) - hd(i,k) + q2(i,k) = rcv*(te(i,k)-gz(i,k)-0.5*(ua(i,j,k)**2+va(i,j,k)**2+w(i,j,k)**2)) & + / (1.+zvir*q(i,j,k,sphum)) + tdt(i,j,k) = tdt(i,j,k) + rdt*(q2(i,k) - ta(i,j,k)) + ta(i,j,k) = q2(i,k) + enddo + enddo + endif + +1000 continue + + if ( print_diag ) then + tmp = g0_sum(pblh, is, ie, js, je, 0, area(is:ie,js:je), 1) + if (master) write(*,*) 'Mean PBL H (km)', trim(gn), '=', tmp*0.001 + call prt_maxmin('PBLH(km)', pblh, is, ie, js, je, 0, 1, 0.001) +! call prt_maxmin('K_ABL (m^2/s)', mu, is, ie, js, je, 0, 1, 1.) + endif + + if (id_pblh > 0) used=send_data(id_pblh, pblh, time) + + end subroutine pbl_diff + + subroutine trid_dif2(a, v, r, q, i1, i2, km) + integer, intent(in):: i1, i2 + integer, intent(in):: km ! vertical dimension + real, intent(in), dimension(i1:i2,km):: a, v, r + real, intent(out),dimension(i1:i2,km):: q +! Local: + real:: gam(i1:i2,km) + real:: bet(i1:i2) + integer:: i, k + +! Zero diffusive fluxes at top and bottom: +! top: k=1 + do i=i1,i2 + bet(i) = -(v(i,1) + a(i,1)) + q(i,1) = r(i,1) / bet(i) + enddo + + do k=2,km + do i=i1,i2 + gam(i,k) = a(i,k-1) / bet(i) + bet(i) = -( a(i,k-1)+v(i,k)+a(i,k) + a(i,k-1)*gam(i,k)) +! a(i,km) = 0 + q(i,k) = ( r(i,k) - a(i,k-1)*q(i,k-1) ) / bet(i) + enddo + enddo + + do k=km-1,1,-1 + do i=i1,i2 + q(i,k) = q(i,k) - gam(i,k+1)*q(i,k+1) + enddo + enddo + + end subroutine trid_dif2 + + + subroutine fv_nudge( npz, is, ie, js, je, ng, u, v, w, delz, delp, pt, dt, hydrostatic) +! +! Nudge the prognostic varaibles toward the IC +! This is only useful for generating balanced steady state IC + + real , INTENT(IN ) :: dt + integer, INTENT(IN ) :: npz, is, ie, js, je, ng + logical, INTENT(IN ) :: hydrostatic + real , INTENT(INOUT) :: u(is-ng:ie+ ng,js-ng:je+1+ng,npz) + real , INTENT(INOUT) :: v(is-ng:ie+1+ng,js-ng:je+ ng,npz) + real , INTENT(INOUT) :: w(is-ng:ie+ ng,js-ng:je+ ng,npz) + real , INTENT(INOUT) :: delp(is-ng:ie+ ng,js-ng:je+ ng,npz) + real , INTENT(INOUT) :: delz(is: ie ,js: je ,npz) + real , INTENT(INOUT) :: pt(is-ng:ie+ ng,js-ng:je+ ng,npz) + real c_w, c_p, c_t + integer i, j, k + + if ( .not. nudge_initialized ) then + + if( tau_winds > 0. ) then + allocate ( u0(is:ie, js:je+1,npz) ) + allocate ( v0(is:ie+1,js:je ,npz) ) + do k=1,npz + do j=js,je+1 + do i=is,ie + u0(i,j,k) = u(i,j,k) + enddo + enddo + do j=js,je + do i=is,ie+1 + v0(i,j,k) = v(i,j,k) + enddo + enddo + enddo + endif + + if( tau_press > 0. ) then + allocate ( dp(is:ie,js:je,npz) ) + do k=1,npz + do j=js,je + do i=is,ie + dp(i,j,k) = delp(i,j,k) + enddo + enddo + enddo + endif + + if( tau_temp > 0. ) then + allocate ( t0(is:ie,js:je,npz) ) + do k=1,npz + do j=js,je + do i=is,ie + t0(i,j,k) = pt(i,j,k) + enddo + enddo + enddo + endif + + nudge_initialized = .true. + if ( is_master() ) write(*,*) 'Nudging of IC initialized.' + return + endif + +! Nudge winds to initial condition: + + do k=1,npz + if( tau_winds > 0. ) then + c_w = dt/tau_winds + do j=js,je+1 + do i=is,ie + u(i,j,k) = (u(i,j,k)+c_w*u0(i,j,k)) / (1.+c_w) + enddo + enddo + do j=js,je + do i=is,ie+1 + v(i,j,k) = (v(i,j,k)+c_w*v0(i,j,k)) / (1.+c_w) + enddo + enddo + if ( .not.hydrostatic ) then + do j=js,je + do i=is,ie+1 + w(i,j,k) = w(i,j,k) / (1.+c_w) + enddo + enddo + endif + endif + if ( tau_temp > 0. ) then + c_t = dt/tau_temp + do j=js,je + do i=is,ie + pt(i,j,k) = (pt(i,j,k)+c_t*t0(i,j,k)) / (1.+c_t) + enddo + enddo + if ( .not.hydrostatic ) then +! delz + endif + endif + + if ( tau_press > 0. ) then + c_p = dt/tau_press + do j=js,je + do i=is,ie + delp(i,j,k) = (delp(i,j,k)+c_p*dp(i,j,k)) / (1.+c_p) + enddo + enddo + endif + enddo + + end subroutine fv_nudge + + subroutine gray_radiation(sec, is, ie, km, lon, lat, clouds, ts, temp, ps, phalf, & + delz, rho, t_dt, olr, lwu, lwd, sw_surf) + +! Gray-Radiation algorithms based on Frierson, Held, and Zurita-Gotor, 2006 JAS +! Note: delz is negative +! Coded by S.-J. Lin, June 20, 2012 + integer, intent(in):: sec + integer, intent(in):: is, ie, km + real, dimension(is:ie):: ts + real, intent(in), dimension(is:ie):: lon, lat + real, intent(in), dimension(is:ie,km):: temp, phalf, delz, rho + real, intent(in), dimension(is:ie):: ps, clouds + real, intent(out), dimension(is:ie,km):: t_dt + real, intent(out), dimension(is:ie):: olr, lwu, lwd, sw_surf +! local: + real, dimension(is:ie,km+1):: ur, dr + real, dimension(is:ie,km+1):: tau, lw + real, dimension(is:ie,km):: delt, b + real, dimension(is:ie):: tau0 + real, parameter:: t0e = 8. ! Dargan value= 6. + real, parameter:: t0p = 1.5 + real, parameter:: fl = 0.1 + real, parameter:: sbc = 5.6734E-8 + real, parameter:: cp = 1004.64 + real:: albd = 0. + real:: sig, sw_rad, solar_ang + integer:: i, k + + do i=is, ie + tau0(i) = t0e + (t0p-t0e) * sin(lat(i))**2 + enddo +! Annual & global mean solar_abs ~ 0.25 * 1367 * ( 1-0.3) ~ 240 +! Earth cross section/total_area = 0.25; 0.3 = Net cloud reflection and atm abs + + if ( diurnal_cycle ) then + sw_rad = solar_constant*(1. - sw_abs) + do i=is, ie + solar_ang = 2*pi*real(sec)/86400. + lon(i) + sw_surf(i) = sw_rad*(1.-clouds(i))*cos(lat(i))*max(0.,cos(solar_ang)) + sw_surf(i) = sw_surf(i)*(1.-albd) + enddo + else + sw_rad = (1./pi) * solar_constant*(1. - sw_abs) + do i=is, ie + sw_surf(i) = sw_rad*(1.-clouds(i))*max(0.,cos(lat(i)-shift_n*deg2rad))*(1.-albd) + enddo + endif + + do k=1, km+1 + do i=is, ie +#ifndef STRAT_OFF +! Dargan version: + sig = phalf(i,k)/ps(i) + tau(i,k) = tau0(i)*( sig*fl + (1.-fl)*sig**4 ) +#else +! SJL: less cooling for the stratosphere + tau(i,k) = tau0(i) * (phalf(i,k)/ps(i))**4 +#endif + enddo + enddo + do k=1, km + do i=is, ie + delt(i,k) = tau(i,k+1) - tau(i,k) + b(i,k) = sbc*temp(i,k)**4 + enddo + enddo + +! top down integration: + do i=is, ie + dr(i,1) = 0. + enddo + do k=1, km + do i=is, ie + dr(i,k+1) = (dr(i,k)+delt(i,k)*(b(i,k)-0.5*dr(i,k)))/(1.+0.5*delt(i,k)) + enddo + enddo +! Bottom up + do i=is, ie + ur(i,km+1) = sbc*ts(i)**4 + lwu(i) = ur(i,km+1) + enddo + do k=km, 1, -1 + do i=is, ie + ur(i,k) = (ur(i,k+1)+delt(i,k)*(b(i,k)-0.5*ur(i,k+1)))/(1.+0.5*delt(i,k)) + enddo + enddo + +! Compute net long wave cooling rate: + do k=1, km+1 + do i=is, ie + lw(i,k) = ur(i,k) - dr(i,k) + enddo + enddo + do k=1, km + do i=is, ie + t_dt(i,k) = (lw(i,k) - lw(i,k+1))/(cp*rho(i,k)*delz(i,k)) + enddo + enddo + + do i=is, ie + olr(i) = ur(i,1) + lwd(i) = dr(i,km+1) + enddo + + end subroutine gray_radiation + + + + subroutine get_low_clouds( is,ie, js,je, km, ql, qi, qa, clouds ) + integer, intent(in):: is,ie, js,je, km + real, intent(in), dimension(is:ie,js:je,km):: ql, qi, qa + real, intent(out), dimension(is:ie,js:je):: clouds + integer:: i, j, k + + do j=js, je + do i=is, ie + clouds(i,j) = 0. + do k=km/2,km + if ( (ql(i,j,k)>1.E-5 .or. qi(i,j,k)>2.e-4) .and. qa(i,j,k)>1.E-3 ) then +! Maximum overlap + clouds(i,j) = max(clouds(i,j), qa(i,j,k)) + endif + enddo + clouds(i,j) = min( 1., clouds(i,j) ) + enddo + enddo + + end subroutine get_low_clouds + + subroutine fv_phys_init(is, ie, js, je, km, nwat, ts, pt, time, axes, lat) + integer, intent(IN) :: is, ie, js, je, km + integer, intent(IN) :: nwat + real, INTENT(inout):: ts(is:ie,js:je) + real, INTENT(in):: pt(is:ie,js:je,km) + real, INTENT(IN) :: lat(is:ie,js:je) + integer, intent(in) :: axes(4) + type(time_type), intent(in) :: time + integer :: unit, ierr, io, i, j + real:: total_area + + master = is_master() + +! ----- read and write namelist ----- + if ( file_exist('input.nml')) then + unit = open_namelist_file ('input.nml') + read (unit, nml=sim_phys_nml, iostat=io, end=10) + ierr = check_nml_error(io,'sim_phys_nml') + + if (do_K_warm_rain) then + read (unit, nml=Kessler_sim_phys_nml, iostat=io, end=10) + ierr = check_nml_error(io,'Kessler_sim_phys_nml') + endif + + if (do_GFDL_sim_phys) then + read (unit, nml=GFDL_sim_phys_nml, iostat=io, end=10) + ierr = check_nml_error(io,'GFDL_sim_phys_nml') + endif + + if (do_reed_sim_phys) then + read (unit, nml=reed_sim_phys_nml, iostat=io, end=10) + ierr = check_nml_error(io,'reed_sim_phys_nml') + endif + + 10 call close_file (unit) + endif + +!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! +! A NOTE REGARDING FV_PHYS DIAGNOSTIC FIELDS ! +!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! +! Please note that these fields are registered ! +! as part of the 'sim_phys' module, **NOT** ! +! as part of the 'dynamics' module. If you ! +! add these fields to your diag_table be SURE ! +! to use 'sim_phys' as your module (first ! +! column) name!! ! +!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! + + id_rain = register_diag_field (mod_name, 'rain', axes(1:2), time, & + 'rain_sim_phys', 'mm/day', missing_value=missing_value ) + id_rain_k = register_diag_field (mod_name, 'rain_k', axes(1:2), time, & + 'accumuated rain', 'mm/day', missing_value=missing_value ) + if (do_K_warm_rain) then + id_vr_k = register_diag_field (mod_name, 'vr_k', axes(1:3), time, & + 'Terminal fall V_Kessler', 'm/s', missing_value=missing_value ) + endif + if (do_abl) then + id_pblh = register_diag_field(mod_name, 'pblh', axes(1:2), time, & + 'PBL Height', 'm', missing_value=missing_value) + endif + + if (id_rain_k > 0) then + allocate ( prec_total(is:ie,js:je) ) + prec_total(:,:) = 0. + endif + + if (do_GFDL_sim_phys) then + id_qflux = register_diag_field(mod_name, 'qflux', axes(1:3), time, & + 'Physics latent heat flux', 'J/m**2/s', missing_value=missing_value) + id_hflux = register_diag_field(mod_name, 'hflux', axes(1:3), time, & + 'Physics sensible heat flux', 'J/m**2/s', missing_value=missing_value) + endif + + id_dudt = register_diag_field( mod_name, 'dudt', axes(1:3), time, & + 'Physics U tendency', 'm/s/s', missing_value=missing_value) + id_dvdt = register_diag_field( mod_name, 'dvdt', axes(1:3), time, & + 'Physics V tendency', 'm/s/s', missing_value=missing_value) + id_dtdt = register_diag_field( mod_name, 'dtdt', axes(1:3), time, & + 'Physics T tendency', 'K/s', missing_value=missing_value) + id_dqdt = register_diag_field( mod_name, 'dqdt', axes(1:3), time, & + 'Physics Q tendency', 'kg/kg/s', missing_value=missing_value) + +! Initialize mixed layer ocean model + if( .not. allocated ( ts0) ) allocate ( ts0(is:ie,js:je) ) + + if ( uniform_sst ) then + ts0(:,:) = sst0 + else + if (sst_type == 1) then !SST in equib with lower atmosphere + do j=js,je + do i=is,ie + ts0(i,j) = pt(i,j,km) + enddo + enddo + else + do j=js,je + do i=is,ie + ts0(i,j) = 270.5 + 32.*exp( -((lat(i,j)-shift_n*deg2rad)/(pi/3.))**2 ) + enddo + enddo + endif + endif + do j=js,je + do i=is,ie + ts(i,j) = ts0(i,j) + enddo + enddo + + + + call prt_maxmin('TS initialized:', ts, is, ie, js, je, 0, 1, 1.0) + call qs_wat_init + + if ( master ) then + total_area = 4.*pi*radius**2 + write(*,*) 'Total surface area', trim(gn), ' =', total_area + endif + + sim_phys_initialized = .true. + + end subroutine fv_phys_init + + + real function g0_sum(p, ifirst, ilast, jfirst, jlast, ngc, area, mode) + use mpp_mod, only: mpp_sum + real, save :: global_area + +! Fast version of globalsum + integer, intent(IN) :: ifirst, ilast + integer, intent(IN) :: jfirst, jlast, ngc + integer, intent(IN) :: mode ! if ==1 divided by area + real, intent(IN) :: p(ifirst:ilast,jfirst:jlast) ! field to be summed + real, intent(IN) :: area(ifirst-ngc:ilast+ngc,jfirst-ngc:jlast+ngc) + integer :: i,j + real gsum + +!------------------------- +! Quick local sum algorithm +!------------------------- + if ( .not. g0_sum_initialized ) then + allocate (l_area(ifirst:ilast,jfirst:jlast)) + global_area = 0. + do j=jfirst,jlast + do i=ifirst,ilast + global_area = global_area + area(i,j) + l_area(i,j) = area(i,j) + enddo + enddo + call mpp_sum(global_area) +! if ( mpp_pe().eq.mpp_root_pe() ) write(*,*) 'Global Area=',global_area + g0_sum_initialized = .true. + end if + + gsum = 0. + do j=jfirst,jlast + do i=ifirst,ilast + gsum = gsum + p(i,j)*l_area(i,j) + enddo + enddo + call mpp_sum(gsum) + + if ( mode==1 ) then + g0_sum = gsum / global_area + else + g0_sum = gsum + endif + +! Make it reproducible by truncating to 32-bit precision: + g0_sum = real(g0_sum, 4) + + end function g0_sum + + subroutine K_warm_rain(dt, is, ie, js, je, ng, km, nq, zvir, u, v, w, u_dt, v_dt, & + q, pt, dp, delz, pe, peln, pk, ps, rain, Time, hydrostatic) + type (time_type), intent(in) :: Time + real, intent(in):: dt ! time step + real, intent(in):: zvir + integer, intent(in):: is, ie, js, je, km, ng, nq + logical, intent(in) :: hydrostatic + real, intent(inout), dimension(is-ng:ie+ng,js-ng:je+ng,km):: dp, pt, w, u, v, u_dt, v_dt + real, intent(inout), dimension(is :ie ,js :je ,km):: delz + real, intent(inout), dimension(is-ng:ie+ng,js-ng:je+ng,km,nq):: q + real, INTENT(INOUT):: pk(is:ie, js:je, km+1) + real, INTENT(INOUT) :: pe(is-1:ie+1,1:km+1,js-1:je+1) + real, INTENT(INOUT) :: peln(is:ie,1:km+1,js:je) + real, intent(inout), dimension(is-ng:ie+ng,js-ng:je+ng):: ps + real, intent(out), dimension(is:ie,js:je):: rain +! Local: + real, parameter:: qv_min = 1.e-7 + real, parameter:: qc_min = 1.e-8 + real, allocatable:: vr_k(:,:,:) + real, dimension(km):: t1, q0, q1, q2, q3, zm, drym, dm, dz, fac1, fac2 + real, dimension(km):: vr, qa, qb, qc, m1, u1, v1, w1, dgz, cvn, cvm + real, dimension(km):: rho + real, dimension(km+1):: ze + real:: sdt, qcon, rgrav + integer i,j,k,n + logical used + + allocate ( vr_k(is:ie,js:je,km) ) + + sdt = dt/real(K_cycle) + rgrav = 1./grav + +!$omp parallel do default(shared) private(ze,zm,rho,fac1,fac2,qcon,dz,vr,dgz,cvm,cvn,m1,u1,v1,w1,q0,qa,qb,qc,t1,dm,q1,q2,q3,drym) + do j=js, je + + do i=is, ie + rain(i,j) = 0. + enddo + do i=is, ie + if (hydrostatic) then + do k=1,km + dz(k) = rdgas*rgrav*pt(i,j,k)*(1.+zvir*q(i,j,k,sphum)) * & + (peln(i,k+1,j)-peln(i,k,j)) + enddo + else + do k=1,km + dz(k) = -delz(i,j,k) + enddo + endif + do k=1,km +! Moist air mass: + dm(k) = dp(i,j,k) !Pa = kg * (g/dA) +! Tracer mass: + qa(k) = q(i,j,k,sphum) !kg/kg + qb(k) = q(i,j,k,liq_wat) + qc(k) = q(i,j,k,rainwat) + q1(k) = qa(k) * dm(k) !kg * (g/dA) + q2(k) = qb(k) * dm(k) + q3(k) = qc(k) * dm(k) +!------------------------------------------- + qcon = q2(k) + q3(k) + if ( qcon > 0. ) then +! Fix negative condensates if for some reason it existed: + if ( q2(k) < 0. ) then + q2(k) = 0. + q3(k) = qcon + elseif ( q3(k) < 0. ) then + q3(k) = 0. + q2(k) = qcon + endif + endif +!------------------------------------------- +! Dry air mass per unit area + drym(k) = dm(k) - (q1(k)+q2(k)+q3(k)) ! kg * ( g/dA) + !dz(k) = -delz(i,j,k) !invalid for hydrostatic; not used unless EXP_MP enabled +! Dry air density +! Convert to dry mixing ratios: + qa(k) = q1(k) / drym(k) ! kg/kg + qb(k) = q2(k) / drym(k) + qc(k) = q3(k) / drym(k) +! Make the fields large enough to prevent problems in the k-scheme: + q1(k) = max(qa(k), qv_min) + q2(k) = max(qb(k), qc_min) + q3(k) = max(qc(k), qc_min) +! Differences (to be added back to conserve mass) + qa(k) = q1(k) - qa(k) ! kg/kg + qb(k) = q2(k) - qb(k) + qc(k) = q3(k) - qc(k) +!---- + t1(k) = pt(i,j,k) + u1(k) = u(i,j,k) + v1(k) = v(i,j,k) + w1(k) = w(i,j,k) + enddo + + do n=1,K_cycle +! Calling the K scheme, sub-cycling if time step is too large for sedimentation/evap + do k=1,km +! For condensate transport + qcon = q2(k) + q3(k) + q0(k) = q1(k) + qcon ! total water kg/kg (dry) + if ( qcon > 0. ) then +! Fix negative condensates if for some reason it existed: + if ( q2(k) < 0. ) then + q2(k) = 0. + q3(k) = qcon + elseif ( q3(k) < 0. ) then + q3(k) = 0. + q2(k) = qcon + endif + endif + enddo + call kessler_imp( t1, q1, q2, q3, vr, drym, sdt, dz, km ) + +! Retrive rain_flux from non-local changes in total water + m1(1) = drym(1)*(q0(1)-(q1(1)+q2(1)+q3(1))) ! Pa * kg/kg (dry) = kg * (g/dA) + do k=2,km + m1(k) = m1(k-1) + drym(k)*(q0(k)-(q1(k)+q2(k)+q3(k))) + enddo +! rain(i,j) = rain(i,j) + max(0., m1(km)) / (grav*sdt) + rain(i,j) = rain(i,j) + max(0., m1(km)) / grav ! kg / dA + + if ( K_sedi_transport ) then +! Momentum transport + if ( do_K_sedi_w ) then +! Momentum conservation: (note vr is downward) +!!! w1(1) = (dm(1)*w1(1)+m1(1)*vr(1))/(dm(1)-m1(1)) + do k=2, km + w1(k) = (dm(k)*w1(k) - m1(k-1)*vr(k-1) + m1(k)*vr(k)) / & + (dm(k)+m1(k-1)-m1(k)) + enddo + endif + do k=2,km +! dm is the total moist mass before terminal fall + fac1(k) = m1(k-1) / (dm(k)+m1(k-1)) + fac2(k) = 1. - fac1(k) + u1(k) = fac1(k)*u1(k-1) + fac2(k)*u1(k) + v1(k) = fac1(k)*v1(k-1) + fac2(k)*v1(k) +!!! w1(k) = fac1(k)*w1(k-1) + fac2(k)*w1(k) + enddo + endif + + if ( do_K_sedi_heat ) then +! Heat transport + do k=1, km + dgz(k) = -0.5*grav*delz(i,j,k) ! > 0 + cvn(k) = cv_air + q1(k)*cv_vap + (q2(k)+q3(k))*c_liq + enddo +! cvm(1) = cvn(1) + c_liq*m1(1)/drym(1) +! t1(1) = (drym(1)*cvm(1)*t1(1) + m1(1)*dgz(1) ) / (drym(1)*cvn(1) + m1(1)*c_liq) + do k=2, km + cvm(k) = cvn(k) - c_liq*(m1(k-1)-m1(k))/drym(k) + t1(k) = ( drym(k)*cvm(k)*t1(k) + m1(k-1)*c_liq*t1(k-1) + dgz(k)*(m1(k-1)+m1(k)) ) & + / ( drym(k)*cvn(k) + m1(k)*c_liq ) + enddo + endif + enddo ! K_cycle + + if ( id_vr_k>0 ) then + do k=1, km + vr_k(i,j,k) = vr(k) + enddo + endif + + do k=1,km + u_dt(i,j,k) = u_dt(i,j,k) + (u1(k)-u(i,j,k))/dt + v_dt(i,j,k) = v_dt(i,j,k) + (v1(k)-v(i,j,k))/dt + u(i,j,k) = u1(k) + v(i,j,k) = v1(k) + w(i,j,k) = w1(k) + pt(i,j,k) = t1(k) + ! Convert back to moist mixing ratios + q1(k) = (q1(k)+qa(k)) * drym(k) + q2(k) = (q2(k)+qb(k)) * drym(k) + q3(k) = (q3(k)+qc(k)) * drym(k) + ! Update total air mass: + dp(i,j,k) = drym(k) + q1(k)+q2(k)+q3(k) + ! Update tracers: + q(i,j,k, sphum) = q1(k) / dp(i,j,k) + q(i,j,k,liq_wat) = q2(k) / dp(i,j,k) + q(i,j,k,rainwat) = q3(k) / dp(i,j,k) + enddo + enddo ! i-loop + + ! Adjust pressure fields: + do k=2,km+1 + do i=is,ie + pe(i,k,j) = pe(i,k-1,j) + dp(i,j,k-1) + peln(i,k,j) = log( pe(i,k,j) ) + pk(i,j,k) = exp( kappa*peln(i,k,j) ) + enddo + enddo + do i=is,ie + ps(i,j) = pe(i,km+1,j) + enddo + + enddo ! j-loop + + if ( id_vr_k>0 ) then + used = send_data(id_vr_k, vr_k, time) + call prt_maxmin('VR_K', vr_k, is, ie, js, je, 0, km, 1.) + endif + deallocate (vr_k) + + end subroutine K_warm_rain + + !This is an upgraded version of kessler MP with modern + ! numerical techniques, implemented consistently with + ! the FV3 dynamics. You can think of this as a "lite" + ! version of the GFDL MP. + subroutine kessler_imp( T, qv, qc, qr, vr, drym, dt, dz, NZ ) +! T - TEMPERATURE (K) +! QV - WATER VAPOR MIXING RATIO (GM/GM) +! qc - CLOUD WATER MIXING RATIO (GM/GM) +! QR - RAIN WATER MIXING RATIO (GM/GM) +! R - DRY AIR DENSITY (GM/M^3) +! dt - TIME STEP (S) +! Z - HEIGHTS OF THERMODYNAMIC LEVELS IN THE GRID COLUMN (M) +! NZ - NUMBER OF THERMODYNAMIC LEVELS IN THE COLUMN +! VARIABLES IN THE GRID COLUMN ARE ORDERED FROM THE SURFACE TO THE TOP. +! k=1 is the top layer +! Dry mixing ratios? +! OUTPUT VARIABLES: + integer, intent(in):: nz + real, intent(in):: dt + REAL, intent(in) :: drym(nz), dz(nz) + REAL, intent(inout):: T(NZ), qv(NZ), qc(NZ), qr(NZ) + real, intent(out):: vr(nz) ! terminal fall speed of rain * dt +! Local: + real, parameter:: qr_min = 1.e-8 + real, parameter:: vr_min = 1.e-3 + real, dimension(nz):: r, pc, rho, rqr + REAL ERN, QRPROD, PROD, QVS, dqsdt, hlvm, dq + INTEGER K + +! Need to compute rho(nz) first: + do k=nz,1,-1 + rho(k) = drym(k)/(grav*dz(k)) + pc(k) = 3.8e2 / (rho(k)*rdgas*T(k)) + r(k) = 0.001*rho(k) + rqr(k) = r(k)*max(qr(k), qr_min) + vr(k) = 36.34 * sqrt(rho(nz)/rho(k)) * exp( 0.1364*log(rqr(k)) ) + vr(k) = max(vr_min, vr(k)) + enddo + + qr(1) = dz(1)*qr(1) / (dz(1)+dt*vr(1)) + do k=2, nz + qr(k) = (dz(k)*qr(k)+qr(k-1)*r(k-1)*dt*vr(k-1)/r(k)) / (dz(k)+dt*vr(k)) + enddo + + do k=1,nz +! Autoconversion and accretion rates following K&W78 Eq. 2.13a,b + QRPROD = qc(k) - (qc(k)-dt*max(.001*(qc(k)-.001),0.))/(1.+dt*2.2*qr(k)**.875) + qc(K) = qc(k) - QRPROD + qr(K) = qr(k) + QRPROD + rqr(k) = r(k)*max(qr(k), qr_min) + QVS = qs_wat(T(k), rho(k), dqsdt) +#ifdef MOIST_CAPPA + hlvm = (Lv0+dc_vap*T(k)) / (cv_air+qv(k)*cv_vap+(qc(k)+qr(k))*c_liq) +#else + hlvm = hlv / cv_air +#endif + PROD = (qv(k)-QVS) / (1.+dqsdt*hlvm) +! Evaporation rate following K&W78 Eq3. 3.8-3.10 + ERN = min(dt*(((1.6+124.9*rqr(k)**.2046) & + *rqr(k)**.525)/(2.55E6*pc(K) & + /(3.8 *QVS)+5.4E5))*(DIM(QVS,qv(K)) & + /(r(k)*QVS)),max(-PROD-qc(k),0.), qr(k)) +! Saturation adjustment following K&W78 Eq.2.14a,b + dq = max(PROD, -qc(k)) + T(k) = T(k) + hlvm*(dq-ERN) +! The following conserves total water + qv(K) = qv(K) - dq + ERN + qc(K) = qc(K) + dq + qr(K) = qr(K) - ERN + enddo + + end subroutine kessler_imp + + real function g_sum(p, ifirst, ilast, jfirst, jlast, area, mode) +!------------------------- +! Quick local sum algorithm +!------------------------- + use mpp_mod, only: mpp_sum + integer, intent(IN) :: ifirst, ilast + integer, intent(IN) :: jfirst, jlast + integer, intent(IN) :: mode ! if ==1 divided by area + real, intent(IN) :: p(ifirst:ilast,jfirst:jlast) ! field to be summed + real, intent(IN) :: area(ifirst:ilast,jfirst:jlast) + integer :: i,j + real gsum + + if( global_area < 0. ) then + global_area = 0. + do j=jfirst,jlast + do i=ifirst,ilast + global_area = global_area + area(i,j) + enddo + enddo + call mpp_sum(global_area) + end if + + gsum = 0. + do j=jfirst,jlast + do i=ifirst,ilast + gsum = gsum + p(i,j)*area(i,j) + enddo + enddo + call mpp_sum(gsum) + + if ( mode==1 ) then + g_sum = gsum / global_area + else + g_sum = gsum + endif + + end function g_sum + + subroutine reed_sim_physics (pcols, pver, dtime, lat, t, q, u, v, pmid, pint, pdel, rpdel, ps, zint, test, & + do_reed_cond, reed_cond_only, reed_alt_mxg, precl, dudt, dvdt, dtdt, dqdt) + +!----------------------------------------------------------------------- +! +! Purpose: Simple Physics Package +! +! Author: K. A. Reed (University of Michigan, kareed@umich.edu) +! version 5 +! July/8/2012 +! +! Change log: +! v2: removal of some NCAR CAM-specific 'use' associations +! v3: corrected precl(i) computation, the precipitation rate is now computed via a vertical integral, the previous single-level computation in v2 was a bug +! v3: corrected dtdt(i,1) computation, the term '-(i,1)' was missing the temperature variable: '-t(i,1)' +! v4: modified and enhanced parameter list to make the routine truly standalone, the number of columns and vertical levels have been added: pcols, pver +! v4: 'ncol' has been removed, 'pcols' is used instead +! v5: the sea surface temperature (SST) field Tsurf is now an array, the SST now depends on the latitude +! v5: addition of the latitude array 'lat' and the flag 'test' in the parameter list +! if test = 0: constant SST is used, correct setting for the tropical cyclone test case 5-1 +! if test = 1: newly added latitude-dependent SST is used, correct setting for the moist baroclinic wave test with simple-physics (test 4-3) +! +! Description: Includes large-scale precipitation, surface fluxes and +! boundary-leyer mixing. The processes are time-split +! in that order. A partially implicit formulation is +! used to foster numerical stability. +! The routine assumes that the model levels are ordered +! in a top-down approach, e.g. level 1 denotes the uppermost +! full model level. +! +! This routine is based on an implementation which was +! developed for the NCAR Community Atmosphere Model (CAM). +! Adjustments for other models will be necessary. +! +! The routine provides both updates of the state variables +! u, v, T, q (these are local copies of u,v,T,q within this physics +! routine) and also collects their time tendencies. +! The latter might be used to couple the physics and dynamics +! in a process-split way. For a time-split coupling, the final +! state should be given to the dynamical core for the next time step. +! Test: 0 = Reed and Jablonowski (2011) tropical cyclone test case (test 5-1) +! 1 = Moist baroclinic instability test (test 4-3) +! 2 = Moist baroclinic instability test (test 4-2) with NO surface fluxes +! +! +! Reference: Reed, K. A. and C. Jablonowski (2012), Idealized tropical cyclone +! simulations of intermediate complexity: A test case for AGCMs, +! J. Adv. Model. Earth Syst., Vol. 4, M04001, doi:10.1029/2011MS000099 +!----------------------------------------------------------------------- + ! use physics_types , only: physics_dme_adjust ! This is for CESM/CAM + ! use cam_diagnostics, only: diag_phys_writeout ! This is for CESM/CAM + + implicit none + + integer, parameter :: r8 = selected_real_kind(12) + +! +! Input arguments - MODEL DEPENDENT +! + integer, intent(in) :: pcols ! Set number of atmospheric columns + integer, intent(in) :: pver ! Set number of model levels + real, intent(in) :: dtime ! Set model physics timestep + real, intent(in) :: lat(pcols) ! Latitude + integer, intent(in) :: test ! Test number + logical, intent(IN) :: do_reed_cond, reed_cond_only, reed_alt_mxg + +! +! Input/Output arguments +! +! pcols is the maximum number of vertical columns per 'chunk' of atmosphere +! + real, intent(inout) :: t(pcols,pver) ! Temperature at full-model level (K) + real, intent(inout) :: q(pcols,pver) ! Specific Humidity at full-model level (kg/kg) + real, intent(inout) :: u(pcols,pver) ! Zonal wind at full-model level (m/s) + real, intent(inout) :: v(pcols,pver) ! Meridional wind at full-model level (m/s) + real, intent(in) :: pmid(pcols,pver) ! Pressure is full-model level (Pa) + real, intent(in) :: pint(pcols,pver+1) ! Pressure at model interfaces (Pa) + real, intent(in) :: pdel(pcols,pver) ! Layer thickness (Pa) + real, intent(in) :: rpdel(pcols,pver) ! Reciprocal of layer thickness (1/Pa) + real, intent(in) :: ps(pcols) ! Surface Pressue (Pa) + real, intent(in) :: zint(pcols,pver+1) ! Height at interfaces +! +! Output arguments + real, intent(out):: dtdt(pcols,pver) ! Temperature tendency + real, intent(out):: dqdt(pcols,pver) ! Specific humidity tendency + real, intent(out):: dudt(pcols,pver) ! Zonal wind tendency + real, intent(out):: dvdt(pcols,pver) ! Meridional wind tendency + real, intent(inout) :: precl(pcols) ! precipitation + +! +!---------------------------Local workspace----------------------------- +! + +! Integers for loops + + integer i,k ! Longitude, level indices + +! Physical Constants - Many of these may be model dependent + + real gravit ! Gravity + real rair ! Gas constant for dry air + real cpair ! Specific heat of dry air + real latvap ! Latent heat of vaporization + real rh2o ! Gas constant for water vapor + real epsilo ! Ratio of gas constant for dry air to that for vapor + real zvir ! Constant for virtual temp. calc. =(rh2o/rair) - 1 + real a ! Reference Earth's Radius (m) + real omega_r ! Reference rotation rate of the Earth (s^-1) +#ifdef USE_REED_CONST + real pi ! pi +#endif + +! Simple Physics Specific Constants + +!++++++++ + real Tsurf(pcols) ! Sea Surface Temperature (constant for tropical cyclone) +!++++++++ Tsurf needs to be dependent on latitude for the + ! moist baroclinic wave test 4-3 with simple-physics, adjust + + real SST_tc ! Sea Surface Temperature for tropical cyclone test + real T0 ! Control temp for calculation of qsat + real rhow ! Density of Liquid Water + real p0 ! Constant for calculation of potential temperature + real Cd0 ! Constant for calculating Cd from Smith and Vogl 2008 + real Cd1 ! Constant for calculating Cd from Smith and Vogl 2008 + real Cm ! Constant for calculating Cd from Smith and Vogl 2008 + real v20 ! Threshold wind speed for calculating Cd from Smith and Vogl 2008 + real C ! Drag coefficient for sensible heat and evaporation + real sqC ! sqrt(C) + real T00 ! Horizontal mean T at surface for moist baro test + real u0 ! Zonal wind constant for moist baro test + real latw ! halfwidth for for baro test + real eta0 ! Center of jets (hybrid) for baro test + real etav ! Auxiliary variable for baro test + real q0 ! Maximum specific humidity for baro test + +! Temporary variables for tendency calculations + + real tmp ! Temporary + real qsat ! Saturation vapor pressure + real qsats ! Saturation vapor pressure of SST + +! Variables for Boundary Layer Calculation + + real wind(pcols) ! Magnitude of Wind + real Cd(pcols) ! Drag coefficient for momentum + real Km(pcols,pver+1) ! Eddy diffusivity for boundary layer calculations + real Ke(pcols,pver+1) ! Eddy diffusivity for boundary layer calculations + real rho ! Density at lower/upper interface + real za(pcols) ! Heights at midpoints of first model level + real dlnpint ! Used for calculation of heights + real pbltop ! Top of boundary layer + real pbltopz ! Top of boundary layer (m) + real pblconst ! Constant for the calculation of the decay of diffusivity + real CA(pcols,pver) ! Matrix Coefficents for PBL Scheme + real CC(pcols,pver) ! Matrix Coefficents for PBL Scheme + real CE(pcols,pver+1) ! Matrix Coefficents for PBL Scheme + real CAm(pcols,pver) ! Matrix Coefficents for PBL Scheme + real CCm(pcols,pver) ! Matrix Coefficents for PBL Scheme + real CEm(pcols,pver+1) ! Matrix Coefficents for PBL Scheme + real CFu(pcols,pver+1) ! Matrix Coefficents for PBL Scheme + real CFv(pcols,pver+1) ! Matrix Coefficents for PBL Scheme + real CFt(pcols,pver+1) ! Matrix Coefficents for PBL Scheme + real CFq(pcols,pver+1) ! Matrix Coefficents for PBL Scheme + + +! Variable for Dry Mass Adjustment, this dry air adjustment is necessary to +! conserve the mass of the dry air + +!=============================================================================== +! +! Physical Constants - MAY BE MODEL DEPENDENT +! +!=============================================================================== + if ( test .eq. 2 ) return + +#ifdef USE_REED_CONST + gravit = 9.80616_r8 ! Gravity (9.80616 m/s^2) + rair = 287.0_r8 ! Gas constant for dry air: 287 J/(kg K) + cpair = 1.0045e3_r8 ! Specific heat of dry air: here we use 1004.5 J/(kg K) + a = 6371220.0_r8 ! Reference Earth's Radius (m) + omega_r = 7.29212d-5 ! Reference rotation rate of the Earth (s^-1) + pi = 4._r8*atan(1._r8) ! pi +#else + gravit = GRAV + rair = RDGAS !287.04 + cpair = CP_AIR ! RDGAS*7/2=1004.64 + a = RADIUS ! 6371.e3 + omega_r = OMEGA ! 7.292e-5 +#endif +! Common constants: + rh2o = 461.5_r8 ! Gas constant for water vapor: 461.5 J/(kg K) + latvap = 2.5e6_r8 ! Latent heat of vaporization (J/kg) + epsilo = rair/rh2o ! Ratio of gas constant for dry air to that for vapor + zvir = (rh2o/rair) - 1._r8 ! Constant for virtual temp. calc. =(rh2o/rair) - 1 is approx. 0.608 + +!=============================================================================== +! +! Local Constants for Simple Physics +! +!=============================================================================== + C = 0.0011_r8 ! From Smith and Vogl 2008 + sqC = sqrt(0.0011_r8)! From Smith and Vogl 2008 + SST_tc = 302.15_r8 ! Constant Value for SST for tropical cyclone test + T0 = 273.16_r8 ! control temp for calculation of qsat + rhow = 1000.0_r8 ! Density of Liquid Water + Cd0 = 0.0007_r8 ! Constant for Cd calc. Smith and Vogl 2008 + Cd1 = 0.000065_r8 ! Constant for Cd calc. Smith and Vogl 2008 + Cm = 0.002_r8 ! Constant for Cd calc. Smith and Vogl 2008 + v20 = 20.0_r8 ! Threshold wind speed for calculating Cd from Smith and Vogl 2008 + p0 = 100000.0_r8 ! Constant for potential temp calculation + pbltop = 85000._r8 ! Top of boundary layer + pbltopz = 1000._r8 ! Top of boundary layer (m) for 'save me' scheme + pblconst = 10000._r8 ! Constant for the calculation of the decay of diffusivity + T00 = 288.0_r8 ! Horizontal mean T at surface for moist baro test + u0 = 35.0_r8 ! Zonal wind constant for moist baro test + latw = 2.0_r8*pi/9.0_r8 ! Halfwidth for for baro test + eta0 = 0.252_r8 ! Center of jets (hybrid) for baro test + etav = (1._r8-eta0)*0.5_r8*pi ! Auxiliary variable for baro test + q0 = 0.021 ! Maximum specific humidity for baro test + +!=============================================================================== +! +! Definition of local arrays +! +!=============================================================================== +! +! Calculate hydrostatic height za of the lowest model level +! + do i=1,pcols + dlnpint = log(ps(i)) - log(pint(i,pver)) ! ps(i) is identical to pint(i,pver+1), note: this is the correct sign (corrects typo in JAMES paper) + za(i) = rair/gravit*t(i,pver)*(1._r8+zvir*q(i,pver))*0.5_r8*dlnpint + end do +! +!-------------------------------------------------------------- +! Set Sea Surface Temperature (constant for tropical cyclone) +! Tsurf needs to be dependent on latitude for the +! moist baroclinic wave test 4-3 with simple-physics +!-------------------------------------------------------------- + if (test .eq. 1) then ! moist baroclinic wave with simple-physics + do i=1,pcols + Tsurf(i) = (T00 + pi*u0/rair * 1.5_r8 * sin(etav) * (cos(etav))**0.5_r8 * & + ((-2._r8*(sin(lat(i)))**6 * ((cos(lat(i)))**2 + 1._r8/3._r8) + 10._r8/63._r8)* & + u0 * (cos(etav))**1.5_r8 + & + (8._r8/5._r8*(cos(lat(i)))**3 * ((sin(lat(i)))**2 + 2._r8/3._r8) - pi/4._r8)*a*omega_r*0.5_r8 ))/ & + (1._r8+zvir*q0*exp(-(lat(i)/latw)**4)) + + end do + elseif (test .eq. 0) then + do i=1,pcols ! constant SST for the tropical cyclone test case + Tsurf(i) = SST_tc + end do + else + Tsurf(:) = 1.E25 + end if + +!=============================================================================== +! +! Set initial physics time tendencies and precipitation field to zero +! +!=============================================================================== + dtdt(:pcols,:pver) = 0._r8 ! initialize temperature tendency with zero + dqdt(:pcols,:pver) = 0._r8 ! initialize specific humidity tendency with zero + dudt(:pcols,:pver) = 0._r8 ! initialize zonal wind tendency with zero + dvdt(:pcols,:pver) = 0._r8 ! initialize meridional wind tendency with zero +! +! Calculate Tendencies +! +!=============================================================================== +! +! Large-Scale Condensation and Precipitation Rate +! +!=============================================================================== +! +! Calculate Tendencies +! + if (do_reed_cond) then + do k=1,pver + do i=1,pcols + qsat = epsilo*e0/pmid(i,k)*exp(-latvap/rh2o*((1./t(i,k))-1./T0)) ! saturation specific humidity + if (q(i,k) > qsat) then ! saturated? + tmp = 1./dtime*(q(i,k)-qsat)/(1.+(latvap/cpair)*(epsilo*latvap*qsat/(rair*t(i,k)**2))) + dtdt(i,k) = dtdt(i,k)+latvap/cpair*tmp + dqdt(i,k) = dqdt(i,k)-tmp + precl(i) = precl(i) + tmp*pdel(i,k)/(gravit*rhow) ! precipitation rate, computed via a vertical integral + ! corrected in version 1.3 + end if + end do + end do + ! + ! Update moisture and temperature fields from Large-Scale Precipitation Scheme + ! + !!!NOTE: How to update mass???? + do k=1,pver + do i=1,pcols + t(i,k) = t(i,k) + dtdt(i,k)*dtime ! update the state variables T and q + q(i,k) = q(i,k) + dqdt(i,k)*dtime + end do + end do + + endif + + + if (reed_cond_only) return +!=============================================================================== +! +! Turbulent mixing coefficients for the PBL mixing of horizontal momentum, +! sensible heat and latent heat +! +! We are using Simplified Ekman theory to compute the diffusion coefficients +! Kx for the boundary-layer mixing. The Kx values are calculated at each time step +! and in each column. +! +!=============================================================================== +! +! Compute magnitude of the wind and drag coeffcients for turbulence scheme: +! they depend on the conditions at the lowest model level and stay constant +! up to the 850 hPa level. Above this level the coefficients are decreased +! and tapered to zero. At the 700 hPa level the strength of the K coefficients +! is about 10% of the maximum strength. +! + + do i=1,pcols + wind(i) = sqrt(u(i,pver)**2+v(i,pver)**2) ! wind magnitude at the lowest level + end do + + if (reed_alt_mxg) then + + do i=1,pcols + if( wind(i) .lt. v20) then + Cd(i) = Cd0+Cd1*wind(i) + else + Cd(i) = Cm + endif + end do + + do k=1,pver+1 + do i=1,pcols + if( zint(i,k) .gt. pbltopz) then + Km(i,k) = 0. + Ke(i,k) = 0. + else + Km(i,k) = 0.4*sqrt(Cd(i))*wind(i)*zint(i,k)*(1. - zint(i,k)/pbltopz)**2 + Ke(i,k) = 0.4*sqC *wind(i)*zint(i,k)*(1. - zint(i,k)/pbltopz)**2 + end if + end do + end do + + else + + do i=1,pcols + Ke(i,pver+1) = C*wind(i)*za(i) + if( wind(i) .lt. v20) then + Cd(i) = Cd0+Cd1*wind(i) + Km(i,pver+1) = Cd(i)*wind(i)*za(i) + else + Cd(i) = Cm + Km(i,pver+1) = Cm*wind(i)*za(i) + endif + end do + + do k=1,pver + do i=1,pcols + if( pint(i,k) .ge. pbltop) then + Km(i,k) = Km(i,pver+1) ! constant Km below 850 hPa level + Ke(i,k) = Ke(i,pver+1) ! constant Ke below 850 hPa level + else + Km(i,k) = Km(i,pver+1)*exp(-(pbltop-pint(i,k))**2/(pblconst)**2) ! Km tapered to 0 + Ke(i,k) = Ke(i,pver+1)*exp(-(pbltop-pint(i,k))**2/(pblconst)**2) ! Ke tapered to 0 + end if + end do + end do + + endif + +!=============================================================================== +! Update the state variables u, v, t, q with the surface fluxes at the +! lowest model level, this is done with an implicit approach +! see Reed and Jablonowski (JAMES, 2012) +! +! Sea Surface Temperature Tsurf is constant for tropical cyclone test 5-1 +! Tsurf needs to be dependent on latitude for the +! moist baroclinic wave test 4-3 with simple-physics, adjust +!=============================================================================== + + do i=1,pcols +! qsats = epsilo*e0/ps(i)*exp(-latvap/rh2o*((1._r8/Tsurf(i))-1._r8/T0)) ! saturation specific humidity at the surface + qsats = epsilo*e0/ps(i)*exp((dc_vap*log(Tsurf(i)/tice)+Lv0*(Tsurf(i)-tice)/(Tsurf(i)*tice))/rvgas) + dudt(i,pver) = dudt(i,pver) + (u(i,pver) & + /(1._r8+Cd(i)*wind(i)*dtime/za(i))-u(i,pver))/dtime + dvdt(i,pver) = dvdt(i,pver) + (v(i,pver) & + /(1._r8+Cd(i)*wind(i)*dtime/za(i))-v(i,pver))/dtime + u(i,pver) = u(i,pver)/(1._r8+Cd(i)*wind(i)*dtime/za(i)) + v(i,pver) = v(i,pver)/(1._r8+Cd(i)*wind(i)*dtime/za(i)) + dtdt(i,pver) = dtdt(i,pver) +((t(i,pver)+C*wind(i)*Tsurf(i)*dtime/za(i)) & + /(1._r8+C*wind(i)*dtime/za(i))-t(i,pver))/dtime + t(i,pver) = (t(i,pver)+C*wind(i)*Tsurf(i)*dtime/za(i)) & + /(1._r8+C*wind(i)*dtime/za(i)) + dqdt(i,pver) = dqdt(i,pver) +((q(i,pver)+C*wind(i)*qsats*dtime/za(i)) & + /(1._r8+C*wind(i)*dtime/za(i))-q(i,pver))/dtime + q(i,pver) = (q(i,pver)+C*wind(i)*qsats*dtime/za(i))/(1._r8+C*wind(i)*dtime/za(i)) + end do +!=============================================================================== + +!!! return ! SJL to turn OFF PBL + +!=============================================================================== +! Boundary layer mixing, see Reed and Jablonowski (JAMES, 2012) +!=============================================================================== +! Calculate Diagonal Variables for Implicit PBL Scheme +! + do k=1,pver-1 + do i=1,pcols + rho = (pint(i,k+1)/(rair*(t(i,k+1)+t(i,k))/2.0_r8)) + CAm(i,k) = rpdel(i,k)*dtime*gravit*gravit*Km(i,k+1)*rho*rho & + /(pmid(i,k+1)-pmid(i,k)) + CCm(i,k+1) = rpdel(i,k+1)*dtime*gravit*gravit*Km(i,k+1)*rho*rho & + /(pmid(i,k+1)-pmid(i,k)) + CA(i,k) = rpdel(i,k)*dtime*gravit*gravit*Ke(i,k+1)*rho*rho & + /(pmid(i,k+1)-pmid(i,k)) + CC(i,k+1) = rpdel(i,k+1)*dtime*gravit*gravit*Ke(i,k+1)*rho*rho & + /(pmid(i,k+1)-pmid(i,k)) + end do + end do + do i=1,pcols + CAm(i,pver) = 0._r8 + CCm(i,1) = 0._r8 + CEm(i,pver+1) = 0._r8 + CA(i,pver) = 0._r8 + CC(i,1) = 0._r8 + CE(i,pver+1) = 0._r8 + CFu(i,pver+1) = 0._r8 + CFv(i,pver+1) = 0._r8 + CFt(i,pver+1) = 0._r8 + CFq(i,pver+1) = 0._r8 + end do + do i=1,pcols + do k=pver,1,-1 + CE(i,k) = CC(i,k)/(1._r8+CA(i,k)+CC(i,k)-CA(i,k)*CE(i,k+1)) + CEm(i,k) = CCm(i,k)/(1._r8+CAm(i,k)+CCm(i,k)-CAm(i,k)*CEm(i,k+1)) + CFu(i,k) = (u(i,k)+CAm(i,k)*CFu(i,k+1)) & + /(1._r8+CAm(i,k)+CCm(i,k)-CAm(i,k)*CEm(i,k+1)) + CFv(i,k) = (v(i,k)+CAm(i,k)*CFv(i,k+1)) & + /(1._r8+CAm(i,k)+CCm(i,k)-CAm(i,k)*CEm(i,k+1)) + CFt(i,k) = ((p0/pmid(i,k))**(rair/cpair)*t(i,k)+CA(i,k)*CFt(i,k+1)) & + /(1._r8+CA(i,k)+CC(i,k)-CA(i,k)*CE(i,k+1)) + CFq(i,k) = (q(i,k)+CA(i,k)*CFq(i,k+1)) & + /(1._r8+CA(i,k)+CC(i,k)-CA(i,k)*CE(i,k+1)) + end do + end do + +! +! Calculate the updated temperature, specific humidity and horizontal wind +! +! First we need to calculate the updates at the top model level +! + do i=1,pcols + dudt(i,1) = dudt(i,1)+(CFu(i,1)-u(i,1))/dtime + dvdt(i,1) = dvdt(i,1)+(CFv(i,1)-v(i,1))/dtime + u(i,1) = CFu(i,1) + v(i,1) = CFv(i,1) + dtdt(i,1) = dtdt(i,1)+(CFt(i,1)*(pmid(i,1)/p0)**(rair/cpair)-t(i,1))/dtime ! corrected in version 1.3 + t(i,1) = CFt(i,1)*(pmid(i,1)/p0)**(rair/cpair) + dqdt(i,1) = dqdt(i,1)+(CFq(i,1)-q(i,1))/dtime + q(i,1) = CFq(i,1) + end do +! +! Loop over the remaining level +! + do i=1,pcols + do k=2,pver + dudt(i,k) = dudt(i,k)+(CEm(i,k)*u(i,k-1)+CFu(i,k)-u(i,k))/dtime + dvdt(i,k) = dvdt(i,k)+(CEm(i,k)*v(i,k-1)+CFv(i,k)-v(i,k))/dtime + u(i,k) = CEm(i,k)*u(i,k-1)+CFu(i,k) + v(i,k) = CEm(i,k)*v(i,k-1)+CFv(i,k) + dtdt(i,k) = dtdt(i,k)+((CE(i,k)*t(i,k-1) & + *(p0/pmid(i,k-1))**(rair/cpair)+CFt(i,k)) & + *(pmid(i,k)/p0)**(rair/cpair)-t(i,k))/dtime + t(i,k) = (CE(i,k)*t(i,k-1)*(p0/pmid(i,k-1))**(rair/cpair)+CFt(i,k)) & + *(pmid(i,k)/p0)**(rair/cpair) + dqdt(i,k) = dqdt(i,k)+(CE(i,k)*q(i,k-1)+CFq(i,k)-q(i,k))/dtime + q(i,k) = CE(i,k)*q(i,k-1)+CFq(i,k) + end do + end do + + end subroutine reed_sim_physics + + subroutine DCMIP2016_terminator_advance(i0, i1, j0, j1, ifirst, ilast, jfirst, jlast, & + km, q, delp, ncnst, lon, lat, pdt) + + !!! Currently assumes DRY mixing ratio?? + + integer, intent(in):: km ! vertical dimension + integer, intent(in):: i0, i1 ! compute domain dimension in E-W + integer, intent(in):: j0, j1 ! compute domain dimension in N-S + integer, intent(in):: ifirst, ilast, jfirst, jlast ! tracer array dimensions + integer, intent(in) :: ncnst + real, intent(in), dimension(ifirst:ilast,jfirst:jlast):: lon, lat + real, intent(in) :: pdt + real, intent(inout):: q(ifirst:ilast,jfirst:jlast,km,ncnst) + real, intent(in) :: delp(ifirst:ilast,jfirst:jlast,km) +! Local var: + real:: D, k1, r, ll, sinthc, costhc, qcly, el, cl_f, expdt, rdt, qCl, qCl2, dq + integer:: i,j,k + integer:: Cl, Cl2 + + !NOTE: If you change the reaction rates, then you will have to change it both + ! here and in fv_phys + real, parameter :: lc = 5.*pi/3. + real, parameter :: thc = pi/9. + real, parameter :: k2 = 1. + real, parameter :: cly0 = 4.e-6 + + sinthc = sin(thc) + costhc = cos(thc) + rdt = 1./pdt + + Cl = get_tracer_index (MODEL_ATMOS, 'Cl') + Cl2 = get_tracer_index (MODEL_ATMOS, 'Cl2') + + if (term_fill_negative) then + do k=1,km + do j=jfirst,jlast + do i=ifirst,ilast + + dq = min(q(i,j,k,Cl2),0.)*2.-min(q(i,j,k,Cl),0.) + q(i,j,k,Cl) = q(i,j,k,Cl) + dq + q(i,j,k,Cl2) = q(i,j,k,Cl2) - dq*0.5 + + enddo + enddo + enddo + endif + + do k=1,km + do j=jfirst,jlast + do i=ifirst,ilast + + qCl = q(i,j,k,Cl) + qCl2 = q(i,j,k,Cl2) + + k1 = max(0., sin(lat(i,j))*sinthc + cos(lat(i,j))*costhc*cos(lon(i,j) - lc)) + r = k1/k2 * 0.25 + qcly = qCl + 2.*qCl2 + D = sqrt(r*r + 2.*r*qcly) + expdt = exp( -4.*k2*D*pdt) + + if ( abs(D * k2 * pdt) .gt. 1e-16 ) then + el = (1. - expdt) /D *rdt + else + el = 4.*k2 + endif + + cl_f = -el * (qCl - D + r)*(qCl + D + r) / (1. + expdt + pdt*el*(qCl + r)) + + q(i,j,k,Cl) = qCl + cl_f*pdt + q(i,j,k,Cl2) = qCl2 - cl_f*0.5*pdt + + enddo + enddo + enddo + + end subroutine DCMIP2016_terminator_advance + +end module fv_phys_mod diff --git a/driver/solo/hswf.F90 b/driver/solo/hswf.F90 new file mode 100644 index 000000000..1eb213004 --- /dev/null +++ b/driver/solo/hswf.F90 @@ -0,0 +1,232 @@ +!*********************************************************************** +!* GNU Lesser General Public License +!* +!* This file is part of the FV3 dynamical core. +!* +!* The FV3 dynamical core is free software: you can redistribute it +!* and/or modify it under the terms of the +!* GNU Lesser General Public License as published by the +!* Free Software Foundation, either version 3 of the License, or +!* (at your option) any later version. +!* +!* The FV3 dynamical core is distributed in the hope that it will be +!* useful, but WITHOUT ANY WARRANTY; without even the implied warranty +!* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. +!* See the GNU General Public License for more details. +!* +!* You should have received a copy of the GNU Lesser General Public +!* License along with the FV3 dynamical core. +!* If not, see . +!*********************************************************************** + +module hswf_mod + + use constants_mod, only: grav, rdgas, cp_air, RADIAN, kappa, pi + use fv_arrays_mod, only: radius ! scaled for small earth + + use fv_grid_utils_mod, only: g_sum + use mpp_domains_mod, only: mpp_update_domains, domain2d + use time_manager_mod, only: time_type, get_date, get_time + use diag_manager_mod, only: send_data + use fv_timing_mod, only: timing_on, timing_off + + implicit none +!----------------------------------------------------------------------- + private + public :: Held_Suarez_Tend, age_of_air + +contains + +!----------------------------------------------------------------------- + + subroutine Held_Suarez_Tend(npx, npy, npz, is, ie, js, je, ng, nq, & + u, v, pt, q, pe, delp, peln, pkz, pdt, & + ua, va, u_dt, v_dt, t_dt, q_dt, agrid, & + delz, phis, hydrostatic, ak, bk, ks, & + strat, rayf, master, Time, time_total) + + integer, INTENT(IN ) :: npx, npy, npz + integer, INTENT(IN ) :: is, ie, js, je, ng, nq + logical, intent(IN) :: hydrostatic + real , INTENT(IN ) :: phis(is-ng:ie+ng,js-ng:je+ng) + real , INTENT(IN ) :: delz(is:,js:,1:) + real , INTENT(IN) :: pkz(is :ie ,js :je ,1:npz) + + real , INTENT(INOUT) :: u(is-ng:ie+ ng,js-ng:je+1+ng,npz) + real , INTENT(INOUT) :: v(is-ng:ie+1+ng,js-ng:je+ ng,npz) + real , INTENT(INOUT) :: pt(is-ng:ie+ ng,js-ng:je+ ng,npz) + real , INTENT(INOUT) :: delp(is-ng:ie+ ng,js-ng:je+ ng,npz) + real , INTENT(INOUT) :: q(is-ng:ie+ ng,js-ng:je+ ng,npz, nq) + real , INTENT(INOUT) :: pe(is-1:ie+1 ,1:npz+1,js-1:je+1) + real , INTENT(INOUT) :: peln(is :ie ,1:npz+1,js :je ) + + real , INTENT(INOUT) :: ua(is-ng:ie+ng,js-ng:je+ng,npz) + real , INTENT(INOUT) :: va(is-ng:ie+ng,js-ng:je+ng,npz) + +! Tendencies: + real, INTENT(INOUT):: u_dt(is-ng:ie+ng,js-ng:je+ng,npz) + real, INTENT(INOUT):: v_dt(is-ng:ie+ng,js-ng:je+ng,npz) + real, INTENT(INOUT):: t_dt(is:ie,js:je,npz) + real, INTENT(INOUT):: q_dt(is:ie,js:je,npz,nq) + + + real , INTENT(IN ) :: agrid(is-ng:ie+ng,js-ng:je+ng, 2) + real , INTENT(IN ) :: ak(npz+1), bk(npz+1) + integer, INTENT(IN ) :: ks + + real , INTENT(IN ) :: pdt + logical, INTENT(IN ) :: strat, rayf, master + + type(time_type), intent(in) :: Time + real, INTENT(IN), optional:: time_total + +! Local + real, dimension(is:ie,npz):: teq, pl + real, dimension(is:ie):: u1, v1 + integer i,j,k + integer seconds, days + real ty, tz, akap + real p0, t0, sday, rkv, rka, rks, rkt, sigb, rsgb + real tmp, solar_ang, solar_rate + real ap0k, algpk + real tey, tez, fac, pw, sigl + real h0, dz + real dt_tropic + real rmr, rms + real relx, tau + real t_st, t_ms + real rdt, f1 + real rad_ratio, kf_day + + ty = 60.0 + tz = 10.0 ! Original value from H-S was 10. + akap = 2./7. + + p0 = 100000. + t0 = 200. + h0 = 7. + sday = 24.*3600. + rdt = 1. / pdt + +!-------------------------- + rad_ratio = radius / 6371.0e3 + + kf_day = sday * rad_ratio + rkv = pdt / kf_day + rka = pdt / (40.*kf_day) + rks = pdt / (4.0*kf_day) + +! For strat-mesosphere + t_ms = 10.*rad_ratio + t_st = 40.*rad_ratio + + tau = (t_st - t_ms) / log(100.) + rms = pdt/(t_ms*sday) + rmr = 1./(1.+rms) + + sigb = 0.7 + rsgb = 1./(1.-sigb) + ap0k = 1./p0**akap + algpk = log(ap0k) + +! Temperature forcing... +!$OMP parallel do default(none) shared(is,ie,js,je,npz,delp,peln,ap0k,ty,agrid,tz,akap, & +!$OMP strat,h0,t_dt,pt,rms,rmr,rdt,t_ms,tau,pdt,sday,pe, & +!$OMP sigb,rsgb,pkz,algpk,t0,rka,rks,rkv,u_dt,ua,v_dt,va) & +!$OMP private(pl, teq, tey, tez, dz, relx, dt_tropic, sigl, f1, rkt,tmp,u1,v1) + do j=js,je + do k=1,npz + do i=is,ie + pl(i,k) = delp(i,j,k) / ( peln(i,k+1,j)-peln(i,k,j)) + enddo + enddo + do k=npz,1,-1 + do i=is,ie + tey = ap0k*( 315.0 - ty*SIN(agrid(i,j,2))*SIN(agrid(i,j,2)) ) + tez = tz*( ap0k/akap )*COS(agrid(i,j,2))*COS(agrid(i,j,2)) + if (strat .and. pl(i,k) <= 1.E2) then +! Mesosphere: defined as the region above 1 mb + dz = h0 * log(pl(i,k+1)/pl(i,k)) + dt_tropic = -2.25*COS(agrid(i,j,2)) * dz + teq(i,k) = teq(i,k+1) + dt_tropic + t_dt(i,j,k) = t_dt(i,j,k) + ((pt(i,j,k)+rms*teq(i,k))*rmr - pt(i,j,k))*rdt +! Stratosphere: + elseif (strat .and. pl(i,k)>1.E2 .and. pl(i,k)<=100.E2 ) then + dz = h0 * log(pl(i,k+1)/pl(i,k)) +! Lapse rate above tropic stratopause is 2.25 deg/km +! Relaxation time is t_st days at 100 mb (as H-S) and gradually +! decreases to t_ms Days at and above the stratopause + relx = t_ms + tau*log(0.01*pl(i,k)) + relx = pdt/(relx*sday) + dt_tropic = 2.25*COS(agrid(i,j,2)) * dz + teq(i,k) = teq(i,k+1) + dt_tropic + t_dt(i,j,k) = t_dt(i,j,k) + relx*(teq(i,k)-pt(i,j,k))/(1.+relx) * rdt + else +! Troposphere: standard Held-Suarez + sigl = pl(i,k)/pe(i,npz+1,j) + f1 = max(0., (sigl-sigb) * rsgb ) + teq(i,k) = tey - tez*(log(pkz(i,j,k))+algpk) + teq(i,k) = max(t0, teq(i,k)*pkz(i,j,k)) + rkt = rka + (rks-rka)*f1*(COS(agrid(i,j,2))**4.0) + t_dt(i,j,k) = t_dt(i,j,k) + rkt*(teq(i,k)-pt(i,j,k))/(1.+rkt) * rdt + ! Bottom friction: + sigl = pl(i,k) / pe(i,npz+1,j) + sigl = (sigl-sigb)*rsgb * rkv + if (sigl > 0.) then + tmp = sigl / (1.+sigl) * rdt + u1(i) = ua(i,j,k) + u_dt(i,j,k) + v1(i) = va(i,j,k) + v_dt(i,j,k) + u_dt(i,j,k) = u_dt(i,j,k) - u1(i)*tmp + v_dt(i,j,k) = v_dt(i,j,k) - v1(i)*tmp + endif + endif + enddo !i-loop + enddo !k-loop + enddo !j-loop + +#ifdef DO_AGE + if( nq/=0 ) & + call age_of_air(is, ie, js, je, npz, ng, time_total, pe, q(is-ng,js-ng,1,nq)) +#endif + + end subroutine Held_Suarez_Tend + + subroutine age_of_air(is, ie, js, je, km, ng, time, pe, q) + + integer is, ie, js, je + integer km + integer ng + +! q is the age tracer +! Need to be converted to mixing ratio (mass of tracer / dry_air-mass) +! Ignore this inconsistency for now. + + real, intent(inout):: pe(is-1:ie+1, km+1, js-1:je+1) + real, intent(in):: time ! accumulated time since init + real, intent(inout):: q(is-ng:ie+ng,js-ng:je+ng,km) + +! Local + integer i, j, k + real p_source ! source level (pa) + real ascale + real tiny + parameter ( tiny = 1.e-6 ) + parameter ( p_source = 75000. ) + parameter ( ascale = 5.e-6 / 60. ) + +!$OMP parallel do default(none) shared(is,ie,js,je,km,time,q,pe) + do k=1,km + do j=js,je + do i=is,ie + if( time < tiny ) then + q(i,j,k) = 0. + elseif( pe(i,k,j) >= p_source ) then + q(i,j,k) = ascale * time + endif + enddo + enddo ! j-loop + enddo ! k-loop + + end subroutine age_of_air + +end module hswf_mod diff --git a/driver/solo/monin_obukhov_drag.F90 b/driver/solo/monin_obukhov_drag.F90 new file mode 100644 index 000000000..f70cb0222 --- /dev/null +++ b/driver/solo/monin_obukhov_drag.F90 @@ -0,0 +1,668 @@ +!*********************************************************************** +!* GNU Lesser General Public License +!* +!* This file is part of the FV3 dynamical core. +!* +!* The FV3 dynamical core is free software: you can redistribute it +!* and/or modify it under the terms of the +!* GNU Lesser General Public License as published by the +!* Free Software Foundation, either version 3 of the License, or +!* (at your option) any later version. +!* +!* The FV3 dynamical core is distributed in the hope that it will be +!* useful, but WITHOUT ANY WARRANTY; without even the implied warranty +!* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. +!* See the GNU General Public License for more details. +!* +!* You should have received a copy of the GNU Lesser General Public +!* License along with the FV3 dynamical core. +!* If not, see . +!*********************************************************************** + +module monin_obukhov_mod + +!============================================================================== +! Kernel routines +!============================================================================== + +! explicit interface to all kernel routines + + use ocean_rough_mod, only: compute_ocean_roughness + + implicit none + private + + public :: Mon_obkv + + integer, parameter :: i8 = selected_int_kind(18) + integer(i8) :: ier_tot, ier + integer :: i, j, ier_l, n + + real, parameter :: grav = 9.80 + real, parameter :: vonkarm = 0.4 + real, parameter :: error = 1.0e-4 + real, parameter :: zeta_min = 1.0e-6 + integer, parameter :: max_iter = 20 + real, parameter :: small = 1.0e-4 + logical, parameter :: neutral = .false. + integer, parameter :: stable_option = 1 + real, parameter :: rich_crit =10.0 + real, parameter :: zeta_trans = 0.5 + real, parameter :: drag_min = 1.0e-5 + real, parameter :: ustar_min = 1.e-10 + real, parameter :: rdgas = 287.04 + real, parameter :: kappa = 2./7. + real, parameter :: cp_air = rdgas/kappa + real, parameter :: zref = 10. + real, parameter :: zref_t = 2. + +contains + + subroutine Mon_obkv(zvir, ps, t_atm, z, rho, p_atm, u_atm, v_atm,u_mean, do_fixed_cd, cd, & + t_surf0, q_surf0, q_atm, drag_t,drag_q,flux_t, flux_q, flux_u, & + flux_v, u_star, delm, dt, mu, t_fac, master) + +!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! +!! pt, virtual potential temperature at lowest model level (kelvin) +!! pt0, virtual potential temperature at surface (kelvin) +!! t_atm: temperature at the lowest model layer +!! z, height above surface of lowest model layer (meter) +!! rho, air density +!! p_atm, pressure at lowest model level (Pa) +!! u_atm, x-dir wind velocity at lowest model level (m/s) +!! v_atm, y-dir wind velocity at lowest model level (m/s) +!! t_surf0, SST (kelvin) +!! th_atm, potential temperature using surface pressure as reference +!! q_surf0, mixing ratio at surface +!! q_atm, mixing ratio at lowest model level +!! flux_t, heat flux (W/m^2) +!! flux_q, moisture flux (kg/sm^2) +!! flux_v, momentum flux (N/m^2, kg/ms^2) +!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! +! SJL: +! PS: surface pressure (Pa) + + logical:: master + logical, intent(in) :: do_fixed_cd + real, intent(in):: zvir, dt + real, intent(in):: t_fac ! t_flux enhancer! + real, intent(in), dimension(:,:):: ps, t_atm + real, intent(in) :: z(:,:), rho(:,:), delm(:,:) + real, intent(in) :: p_atm(:,:), u_atm(:,:), v_atm(:,:) + real, intent(in) :: u_mean, cd + real, intent(in) :: t_surf0(:,:), q_surf0(:,:), q_atm(:,:) + real, intent(inout) :: u_star(:,:) + real, intent(out) :: flux_t(:,:), flux_q(:,:), flux_u(:,:), flux_v(:,:) + real, intent(out) :: mu(:,:) + + logical, dimension(size(ps,1)) :: avail + logical :: lavail + real, dimension(size(ps,1),size(ps,2)) :: speed, drag_m, rho_drag + real, intent(inout), dimension(size(ps,1),size(ps,2)) :: drag_t, drag_q + real, dimension(size(ps,1),size(ps,2)) :: b_star, u_surf0, v_surf0 + real, dimension(size(ps,1),size(ps,2)) :: rough_mom, rough_heat, rough_moist +! +! Local: + real, dimension(size(ps,1),size(ps,2)) :: pt, pt0, p_fac, deno + real, parameter:: p00 = 1.E5 + integer:: i,j + + p_fac(:,:) = (ps(:,:)/p_atm(:,:)) ** kappa + pt(:,:) = t_atm(:,:)*(1.+zvir*q_atm(:,: ))*(p00/p_atm(:,:))**kappa + pt0(:,:) = t_surf0(:,:)*(1.+zvir*q_surf0(:,:))*(p00/ ps(:,:))**kappa + speed(:,:) = sqrt(u_atm(:,:)**2+v_atm(:,:)**2+u_mean**2) + + lavail = .false. + avail = .true. + +#ifdef MON_DEBUG + if ( master ) write(*,*) 'p_atm=',maxval(p_atm) + if ( master ) write(*,*) 'u_atm=',maxval(u_atm) + if ( master ) write(*,*) 'v_atm=',maxval(v_atm) + if ( master ) write(*,*) 't_surf0=',maxval(t_surf0) + if ( master ) write(*,*) 'q_surf0=',maxval(q_surf0) + if ( master ) write(*,*) 'q_atm=',maxval(q_atm) + if ( master ) write(*,*) 'u_star=',maxval(u_star) +#endif + +! u_star should be an output? + call compute_ocean_roughness ( u_star, speed, rough_mom, rough_heat, rough_moist, master ) + + n=size(ps,1) + do j = 1, size(ps,2) + call monin_obukhov_drag_1d(grav, vonkarm, error, zeta_min, max_iter, small, & + neutral, stable_option, rich_crit, zeta_trans, drag_min, & + n, pt(:,j), pt0(:,j), z(:,j), rough_mom(:,j), & + rough_heat(:,j), rough_moist(:,j), speed(:,j), drag_m(:,j), drag_t(:,j), & + drag_q(:,j), u_star(:,j), b_star(:,j), lavail, avail, ier_l) + end do + +! Ocean currents: + u_surf0(:,:) = 0. + v_surf0(:,:) = 0. + + if (do_fixed_cd) then + drag_m(:,:) = cd + drag_t(:,:) = cd + drag_q(:,:) = cd + end if + +! momentum flux + mu(:,:) = drag_m(:,:)*speed(:,:) ! diffusion coefficient / Z + rho_drag(:,:) = rho(:,:)*mu(:,:) + +#ifdef IMPLICIT_FLUX + flux_u(:,:) = rho_drag(:,:) * (u_surf0(:,:) - u_atm(:,:)) + flux_v(:,:) = rho_drag(:,:) * (v_surf0(:,:) - v_atm(:,:)) + +! flux of sensible heat (W/m**2) + rho_drag(:,:) = rho(:,:)*speed(:,:) + flux_t(:,:) = cp_air*drag_t(:,:)*rho_drag(:,:)*(t_surf0(:,:)-t_atm(:,:)*p_fac(:,:))*t_fac +! flux of water vapor (Kg/(m**2 s)) + flux_q(:,:) = drag_q(:,:)*rho_drag(:,:)*(q_surf0(:,:)-q_atm(:,:)) + +#else + deno(:,:) = 1. + dt*rho_drag(:,:)/delm(:,:) + flux_u(:,:) = rho_drag(:,:) * (u_surf0(:,:) - u_atm(:,:)) / deno(:,:) + flux_v(:,:) = rho_drag(:,:) * (v_surf0(:,:) - v_atm(:,:)) / deno(:,:) +! flux of sensible heat (W/m**2) +! flux of sensible heat (W/m**2) + rho_drag(:,:) = rho(:,:)*drag_t(:,:)*speed(:,:) * t_fac + deno(:,:) = delm(:,:) / ( delm(:,:) + dt*rho_drag(:,:)*p_fac(:,:)) + flux_t(:,:) = cp_air*rho_drag(:,:)*(t_surf0(:,:)-t_atm(:,:)*p_fac(:,:))*deno(:,:) +! flux of water vapor (Kg/(m**2 s)) + rho_drag(:,:) = rho(:,:)*drag_q(:,:)*speed(:,:) + deno(:,:) = 1. + dt*rho_drag(:,:)/delm(:,:) + flux_q(:,:) = rho_drag(:,:)*(q_surf0(:,:)-q_atm(:,:))/deno(:,:) +#endif + + end subroutine Mon_obkv + +!============================================================================== + subroutine monin_obukhov_drag_1d(grav, vonkarm, & + & error, zeta_min, max_iter, small, & + & neutral, stable_option, rich_crit, zeta_trans, drag_min, & + & n, pt, pt0, z, z0, zt, zq, speed, drag_m, drag_t, & + & drag_q, u_star, b_star, lavail, avail, ier) + + implicit none + + real , intent(in ) :: grav + real , intent(in ) :: vonkarm + real , intent(in ) :: error ! = 1.e-04 + real , intent(in ) :: zeta_min ! = 1.e-06 + integer, intent(in ) :: max_iter ! = 20 + real , intent(in ) :: small ! = 1.e-04 + logical, intent(in ) :: neutral + integer, intent(in ) :: stable_option + real , intent(in ) :: rich_crit, zeta_trans, drag_min + integer, intent(in ) :: n + real , intent(in ), dimension(n) :: pt, pt0, z, z0, zt, zq, speed + real , intent(inout), dimension(n) :: drag_m, drag_t, drag_q, u_star, b_star + logical, intent(in ) :: lavail ! whether to use provided mask or not + logical, intent(in ), dimension(n) :: avail ! provided mask + integer, intent(out ) :: ier + + real , dimension(n) :: rich, fm, ft, fq, zz + logical, dimension(n) :: mask, mask_1, mask_2 + real , dimension(n) :: delta_b !!, us, bs, qs + real :: r_crit, sqrt_drag_min + real :: us, bs, qs + integer :: i + + r_crit = 0.95*rich_crit ! convergence can get slow if one is + ! close to rich_crit + sqrt_drag_min = 0.0 + if(drag_min.ne.0.0) sqrt_drag_min = sqrt(drag_min) + + mask = .true. +! if(lavail) mask = avail + + where(mask) + delta_b = grav*(pt0 - pt)/pt0 + rich = - z*delta_b/(speed*speed + small) + zz = max(z,z0,zt,zq) + elsewhere + rich = 0.0 + end where + + if(neutral) then + + do i = 1, n + if(mask(i)) then + fm(i) = log(zz(i)/z0(i)) + ft(i) = log(zz(i)/zt(i)) + fq(i) = log(zz(i)/zq(i)) + us = vonkarm/fm(i) + bs = vonkarm/ft(i) + qs = vonkarm/fq(i) + drag_m(i) = us*us + drag_t(i) = us*bs + drag_q(i) = us*qs + u_star(i) = us*speed(i) + b_star(i) = bs*delta_b(i) + end if + enddo + + else + + mask_1 = mask .and. rich < r_crit + mask_2 = mask .and. rich >= r_crit + + do i = 1, n + if(mask_2(i)) then + drag_m(i) = drag_min + drag_t(i) = drag_min + drag_q(i) = drag_min + us = sqrt_drag_min + bs = sqrt_drag_min + u_star(i) = us*speed(i) + b_star(i) = bs*delta_b(i) + end if + enddo + + call monin_obukhov_solve_zeta (error, zeta_min, max_iter, small, & + & stable_option, rich_crit, zeta_trans, & + & n, rich, zz, z0, zt, zq, fm, ft, fq, mask_1, ier) + + do i = 1, n + if(mask_1(i)) then + us = max(vonkarm/fm(i), sqrt_drag_min) + bs = max(vonkarm/ft(i), sqrt_drag_min) + qs = max(vonkarm/fq(i), sqrt_drag_min) + drag_m(i) = us*us + drag_t(i) = us*bs + drag_q(i) = us*qs + u_star(i) = us*speed(i) + b_star(i) = bs*delta_b(i) + endif + enddo + + end if + +end subroutine monin_obukhov_drag_1d +!============================================================================== + subroutine monin_obukhov_solve_zeta(error, zeta_min, max_iter, small, & + & stable_option, rich_crit, zeta_trans, & + & n, rich, z, z0, zt, zq, f_m, f_t, f_q, mask, ier) + + implicit none + + real , intent(in ) :: error ! = 1.e-04 + real , intent(in ) :: zeta_min ! = 1.e-06 + integer, intent(in ) :: max_iter ! = 20 + real , intent(in ) :: small ! = 1.e-04 + integer, intent(in ) :: stable_option + real , intent(in ) :: rich_crit, zeta_trans + integer, intent(in ) :: n + real , intent(in ), dimension(n) :: rich, z, z0, zt, zq + logical, intent(in ), dimension(n) :: mask + real , intent( out), dimension(n) :: f_m, f_t, f_q + integer, intent( out) :: ier + + + real :: max_cor + integer :: iter + + real, dimension(n) :: & + d_rich, rich_1, correction, corr, z_z0, z_zt, z_zq, & + ln_z_z0, ln_z_zt, ln_z_zq, zeta, & + phi_m, phi_m_0, phi_t, phi_t_0, rzeta, & + zeta_0, zeta_t, zeta_q, df_m, df_t + + logical, dimension(n) :: mask_1 + + ier = 0 + + z_z0 = z/z0 + z_zt = z/zt + z_zq = z/zq + ln_z_z0 = log(z_z0) + ln_z_zt = log(z_zt) + ln_z_zq = log(z_zq) + + corr = 0.0 + mask_1 = mask + + ! initial guess + + zeta = 0.0 + where(mask_1) + zeta = rich*ln_z_z0*ln_z_z0/ln_z_zt + end where + + where (mask_1 .and. rich >= 0.0) + zeta = zeta/(1.0 - rich/rich_crit) + end where + + iter_loop: do iter = 1, max_iter + + where (mask_1 .and. abs(zeta).lt.zeta_min) + zeta = 0.0 + f_m = ln_z_z0 + f_t = ln_z_zt + f_q = ln_z_zq + mask_1 = .false. ! don't do any more calculations at these pts + end where + + + zeta_0 = 0.0 + zeta_t = 0.0 + zeta_q = 0.0 + where (mask_1) + rzeta = 1.0/zeta + zeta_0 = zeta/z_z0 + zeta_t = zeta/z_zt + zeta_q = zeta/z_zq + end where + + call monin_obukhov_derivative_m(stable_option, rich_crit, zeta_trans, & + & n, phi_m , zeta , mask_1, ier) + call monin_obukhov_derivative_m(stable_option, rich_crit, zeta_trans, & + & n, phi_m_0, zeta_0, mask_1, ier) + call monin_obukhov_derivative_t(stable_option, rich_crit, zeta_trans, & + & n, phi_t , zeta , mask_1, ier) + call monin_obukhov_derivative_t(stable_option, rich_crit, zeta_trans, & + & n, phi_t_0, zeta_t, mask_1, ier) + + call monin_obukhov_integral_m(stable_option, rich_crit, zeta_trans, & + & n, f_m, zeta, zeta_0, ln_z_z0, mask_1, ier) + call monin_obukhov_integral_tq(stable_option, rich_crit, zeta_trans, & + & n, f_t, f_q, zeta, zeta_t, zeta_q, ln_z_zt, ln_z_zq, mask_1, ier) + + where (mask_1) + df_m = (phi_m - phi_m_0)*rzeta + df_t = (phi_t - phi_t_0)*rzeta + rich_1 = zeta*f_t/(f_m*f_m) + d_rich = rich_1*( rzeta + df_t/f_t - 2.0 *df_m/f_m) + correction = (rich - rich_1)/d_rich + corr = min(abs(correction),abs(correction/zeta)) + ! the criterion corr < error seems to work ok, but is a bit arbitrary + ! when zeta is small the tolerance is reduced + end where + + max_cor= maxval(corr) + + if(max_cor > error) then + mask_1 = mask_1 .and. (corr > error) + ! change the mask so computation proceeds only on non-converged points + where(mask_1) + zeta = zeta + correction + end where + cycle iter_loop + else + return + end if + + end do iter_loop + + ier = 1 ! surface drag iteration did not converge + +end subroutine monin_obukhov_solve_zeta +!============================================================================== + subroutine monin_obukhov_derivative_t(stable_option, rich_crit, zeta_trans, & + & n, phi_t, zeta, mask, ier) + + ! the differential similarity function for buoyancy and tracers + ! Note: seems to be the same as monin_obukhov_derivative_m? + + implicit none + + integer, intent(in ) :: stable_option + real , intent(in ) :: rich_crit, zeta_trans + integer, intent(in ) :: n + real , intent( out), dimension(n) :: phi_t + real , intent(in ), dimension(n) :: zeta + logical, intent(in ), dimension(n) :: mask + integer, intent( out) :: ier + + logical, dimension(n) :: stable, unstable + real :: b_stab, lambda + + ier = 0 + b_stab = 1.0/rich_crit + + stable = mask .and. zeta >= 0.0 + unstable = mask .and. zeta < 0.0 + + where (unstable) + phi_t = (1 - 16.0*zeta)**(-0.5) + end where + + if(stable_option == 1) then + + where (stable) + phi_t = 1.0 + zeta*(5.0 + b_stab*zeta)/(1.0 + zeta) + end where + + else if(stable_option == 2) then + + lambda = 1.0 + (5.0 - b_stab)*zeta_trans + + where (stable .and. zeta < zeta_trans) + phi_t = 1 + 5.0*zeta + end where + where (stable .and. zeta >= zeta_trans) + phi_t = lambda + b_stab*zeta + end where + + endif + +end subroutine monin_obukhov_derivative_t +!============================================================================= + subroutine monin_obukhov_derivative_m(stable_option, rich_crit, zeta_trans, & + & n, phi_m, zeta, mask, ier) + + ! the differential similarity function for momentum + + implicit none + + integer, intent(in ) :: stable_option + real , intent(in ) :: rich_crit, zeta_trans + integer, intent(in ) :: n + real , intent( out), dimension(n) :: phi_m + real , intent(in ), dimension(n) :: zeta + logical, intent(in ), dimension(n) :: mask + integer, intent(out ) :: ier + + logical, dimension(n) :: stable, unstable + real , dimension(n) :: x + real :: b_stab, lambda + + + ier = 0 + b_stab = 1.0/rich_crit + + stable = mask .and. zeta >= 0.0 + unstable = mask .and. zeta < 0.0 + + where (unstable) + x = (1 - 16.0*zeta )**(-0.5) + phi_m = sqrt(x) ! phi_m = (1 - 16.0*zeta)**(-0.25) + end where + + if(stable_option == 1) then + + where (stable) + phi_m = 1.0 + zeta *(5.0 + b_stab*zeta)/(1.0 + zeta) + end where + + else if(stable_option == 2) then + + lambda = 1.0 + (5.0 - b_stab)*zeta_trans + + where (stable .and. zeta < zeta_trans) + phi_m = 1 + 5.0*zeta + end where + where (stable .and. zeta >= zeta_trans) + phi_m = lambda + b_stab*zeta + end where + + endif + +end subroutine monin_obukhov_derivative_m +!============================================================================== + subroutine monin_obukhov_integral_m(stable_option, rich_crit, zeta_trans, & + & n, psi_m, zeta, zeta_0, ln_z_z0, mask, ier) + + ! the integral similarity function for momentum + + implicit none + + integer, intent(in ) :: stable_option + real , intent(in ) :: rich_crit, zeta_trans + integer, intent(in ) :: n + real , intent( out), dimension(n) :: psi_m + real , intent(in) , dimension(n) :: zeta, zeta_0, ln_z_z0 + logical, intent(in) , dimension(n) :: mask + integer, intent(out) :: ier + + real :: b_stab, lambda + + real, dimension(n) :: x, x_0, x1, x1_0, num, denom, y + logical, dimension(n) :: stable, unstable, & + weakly_stable, strongly_stable + + ier = 0 + + b_stab = 1.0/rich_crit + + stable = mask .and. zeta >= 0.0 + unstable = mask .and. zeta < 0.0 + + where(unstable) + + x = sqrt(1 - 16.0*zeta) + x_0 = sqrt(1 - 16.0*zeta_0) + + x = sqrt(x) + x_0 = sqrt(x_0) + + x1 = 1.0 + x + x1_0 = 1.0 + x_0 + + num = x1*x1*(1.0 + x*x) + denom = x1_0*x1_0*(1.0 + x_0*x_0) + y = atan(x) - atan(x_0) + psi_m = ln_z_z0 - log(num/denom) + 2*y + + end where + + if( stable_option == 1) then + + where (stable) + psi_m = ln_z_z0 + (5.0 - b_stab)*log((1.0 + zeta)/(1.0 + zeta_0)) & + + b_stab*(zeta - zeta_0) + end where + + else if (stable_option == 2) then + + lambda = 1.0 + (5.0 - b_stab)*zeta_trans + + weakly_stable = stable .and. zeta <= zeta_trans + strongly_stable = stable .and. zeta > zeta_trans + + where (weakly_stable) + psi_m = ln_z_z0 + 5.0*(zeta - zeta_0) + end where + + where(strongly_stable) + x = (lambda - 1.0)*log(zeta/zeta_trans) + b_stab*(zeta - zeta_trans) + endwhere + + where (strongly_stable .and. zeta_0 <= zeta_trans) + psi_m = ln_z_z0 + x + 5.0*(zeta_trans - zeta_0) + end where + where (strongly_stable .and. zeta_0 > zeta_trans) + psi_m = lambda*ln_z_z0 + b_stab*(zeta - zeta_0) + endwhere + + end if + +end subroutine monin_obukhov_integral_m +!============================================================================== + subroutine monin_obukhov_integral_tq(stable_option, rich_crit, zeta_trans, & + & n, psi_t, psi_q, zeta, zeta_t, zeta_q, & + & ln_z_zt, ln_z_zq, mask, ier) + + ! the integral similarity function for moisture and tracers + + implicit none + + integer, intent(in ) :: stable_option + real, intent(in ) :: rich_crit, zeta_trans + integer, intent(in ) :: n + real , intent( out), dimension(n) :: psi_t, psi_q + real , intent(in) , dimension(n) :: zeta, zeta_t, zeta_q, ln_z_zt, ln_z_zq + logical, intent(in) , dimension(n) :: mask + integer, intent( out) :: ier + + real, dimension(n) :: x, x_t, x_q + logical, dimension(n) :: stable, unstable, & + weakly_stable, strongly_stable + real :: b_stab, lambda + + ier = 0 + + b_stab = 1.0/rich_crit + +stable = mask .and. zeta >= 0.0 +unstable = mask .and. zeta < 0.0 + +where(unstable) + + x = sqrt(1 - 16.0*zeta) + x_t = sqrt(1 - 16.0*zeta_t) + x_q = sqrt(1 - 16.0*zeta_q) + + psi_t = ln_z_zt - 2.0*log( (1.0 + x)/(1.0 + x_t) ) + psi_q = ln_z_zq - 2.0*log( (1.0 + x)/(1.0 + x_q) ) + +end where + +if( stable_option == 1) then + + where (stable) + + psi_t = ln_z_zt + (5.0 - b_stab)*log((1.0 + zeta)/(1.0 + zeta_t)) & + + b_stab*(zeta - zeta_t) + psi_q = ln_z_zq + (5.0 - b_stab)*log((1.0 + zeta)/(1.0 + zeta_q)) & + + b_stab*(zeta - zeta_q) + + end where + +else if (stable_option == 2) then + + lambda = 1.0 + (5.0 - b_stab)*zeta_trans + + weakly_stable = stable .and. zeta <= zeta_trans + strongly_stable = stable .and. zeta > zeta_trans + + where (weakly_stable) + psi_t = ln_z_zt + 5.0*(zeta - zeta_t) + psi_q = ln_z_zq + 5.0*(zeta - zeta_q) + end where + + where(strongly_stable) + x = (lambda - 1.0)*log(zeta/zeta_trans) + b_stab*(zeta - zeta_trans) + endwhere + + where (strongly_stable .and. zeta_t <= zeta_trans) + psi_t = ln_z_zt + x + 5.0*(zeta_trans - zeta_t) + end where + where (strongly_stable .and. zeta_t > zeta_trans) + psi_t = lambda*ln_z_zt + b_stab*(zeta - zeta_t) + endwhere + + where (strongly_stable .and. zeta_q <= zeta_trans) + psi_q = ln_z_zq + x + 5.0*(zeta_trans - zeta_q) + end where + where (strongly_stable .and. zeta_q > zeta_trans) + psi_q = lambda*ln_z_zq + b_stab*(zeta - zeta_q) + endwhere + +end if + +end subroutine monin_obukhov_integral_tq + +end module monin_obukhov_mod diff --git a/driver/solo/ocean_rough.F90 b/driver/solo/ocean_rough.F90 new file mode 100644 index 000000000..514b511a0 --- /dev/null +++ b/driver/solo/ocean_rough.F90 @@ -0,0 +1,225 @@ +!*********************************************************************** +!* GNU Lesser General Public License +!* +!* This file is part of the FV3 dynamical core. +!* +!* The FV3 dynamical core is free software: you can redistribute it +!* and/or modify it under the terms of the +!* GNU Lesser General Public License as published by the +!* Free Software Foundation, either version 3 of the License, or +!* (at your option) any later version. +!* +!* The FV3 dynamical core is distributed in the hope that it will be +!* useful, but WITHOUT ANY WARRANTY; without even the implied warranty +!* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. +!* See the GNU General Public License for more details. +!* +!* You should have received a copy of the GNU Lesser General Public +!* License along with the FV3 dynamical core. +!* If not, see . +!*********************************************************************** + +module ocean_rough_mod + +!----------------------------------------------------------------------- + +use fms_mod, only: error_mesg, FATAL, file_exist, open_namelist_file, & + check_nml_error, mpp_pe, mpp_root_pe, close_file, & + write_version_number, stdlog + +implicit none +private + +public :: compute_ocean_roughness, fixed_ocean_roughness + +!----------------------------------------------------------------------- +!----- namelist ----- + + real :: roughness_init = 0.00044 ! not used in this version + real :: roughness_min = 1.e-6 + real :: charnock = 0.032 + + real :: roughness_mom = 5.8e-5 + real :: roughness_heat = 5.8e-5 ! was 4.00e-4 + real :: roughness_moist = 5.8e-5 +! real, parameter :: zcoh1 = 1.4e-5 +! real, parameter :: zcoq1 = 1.3e-4 + real :: zcoh1 = 0.0 !miz + real :: zcoq1 = 0.0 !miz + logical :: do_highwind = .false. + logical :: do_cap40 = .false. + real :: v10m = 32.5 !jhc + real :: v10n = 17.5 !jhc + logical :: do_init = .true. + + character(len=32) :: rough_scheme = 'fixed' ! possible values: + ! 'fixed' + ! 'charnock' + ! 'beljaars' + logical:: read_namelist = .true. + +namelist /ocean_rough_nml/ roughness_init, roughness_heat, & + roughness_mom, roughness_moist, & + roughness_min, & + charnock, & + rough_scheme, do_highwind, &!miz + v10m, v10n, do_cap40, do_init, zcoh1, zcoq1 !sjl + +!----------------------------------------------------------------------- +! ---- constants ---- + +! ..... high wind speed - rough sea + real, parameter :: zcom1 = 1.8e-2 ! Charnock's constant +! ..... low wind speed - smooth sea + real, parameter :: gnu = 1.5e-5 + real, parameter :: zcom2 = 0.11 + real, parameter :: zcoh2 = 0.40 + real, parameter :: zcoq2 = 0.62 + real, parameter :: grav = 9.80 + real, parameter :: us10_adj = 0.9 ! reduction factor; added by SJL + +contains + +!####################################################################### + + subroutine compute_ocean_roughness (u_star, speed, & + rough_mom, rough_heat, rough_moist, master ) + + real, intent(in) :: speed(:,:) + real, intent(inout) :: u_star(:,:) + real, intent(out) :: rough_mom(:,:), rough_heat(:,:), rough_moist(:,:) + logical:: master +!----------------------------------------------------------------------- +! computes ocean roughness for momentum using wind stress +! and sets roughness for heat/moisture using namelist value +!----------------------------------------------------------------------- + + real, dimension(size(speed,1),size(speed,2)) :: ustar2, xx1, xx2, w10 !miz + real:: zt1 + integer :: i, j + integer :: unit, ierr, io + +! ----- read and write namelist ----- + if ( read_namelist .and. file_exist('input.nml')) then + unit = open_namelist_file ('input.nml') + if(master) write(*,*)'read input, unit', unit + ierr=1; do while (ierr /= 0) + read (unit, nml=ocean_rough_nml, iostat=io, end=10) + ierr = check_nml_error(io,'ocean_rough_nml') + if(master) write(*,*)'ierr =',ierr + enddo + 10 call close_file (unit) + if(master) write(*,*)'do_init=',do_init + if(master) write(*,*)'rough_scheme=',rough_scheme + read_namelist = .false. + endif + + + if (do_init) then + + call ocean_rough_init(us10_adj*speed, rough_mom, rough_heat, rough_moist) +! SJL: compute u_star using Eq (2), Moon et al. + u_star(:,:) = 0.4*speed(:,:)*us10_adj/log(10./rough_mom(:,:)) + + else + if (trim(rough_scheme) == 'fixed') then +! --- set roughness for momentum and heat/moisture --- + + call fixed_ocean_roughness (speed, rough_mom, rough_heat, rough_moist ) + + +! --- compute roughness for momentum, heat, moisture --- + + else if (trim(rough_scheme) == 'beljaars' .or. & + trim(rough_scheme) == 'charnock') then + + ustar2(:,:) = max(gnu*gnu, u_star(:,:)*u_star(:,:)) + xx1(:,:) = gnu / sqrt(ustar2(:,:)) + xx2(:,:) = ustar2(:,:) / grav + + if (trim(rough_scheme) == 'charnock') then + rough_mom (:,:) = charnock * xx2(:,:) + rough_mom (:,:) = max( rough_mom(:,:), roughness_min ) + rough_heat (:,:) = rough_mom (:,:) + rough_moist(:,:) = rough_mom (:,:) + else if (trim(rough_scheme) == 'beljaars') then + if (do_highwind) then ! Moon et al. formular +! --- SJL ---- High Wind correction following Moon et al 2007 ------ + do j=1,size(speed,2) + do i=1,size(speed,1) + w10(i,j) = 2.458 + u_star(i,j)*(20.255-0.56*u_star(i,j)) ! Eq(7) Moon et al. + if ( w10(i,j) > 12.5 ) then + rough_mom(i,j) = 0.001*(0.085*w10(i,j) - 0.58) ! Eq(8b) Moon et al. +! SJL mods: cap the growth of z0 with w10 up to 40 m/s +! z0 (w10=40) = 2.82E-3 + if(do_cap40) rough_mom(i,j) = min( rough_mom(i,j), 2.82E-3) + else + rough_mom(i,j) = 0.0185/grav*u_star(i,j)**2 ! (8a) Moon et al. + endif +! Ramp up the coefficient: + zt1 = min( 1., (w10(i,j)-v10n)/(v10m-v10n) ) + rough_heat (i,j) = zcoh1*zt1*xx2(i,j) + zcoh2 * xx1(i,j) + rough_moist(i,j) = zcoq1*zt1*xx2(i,j) + zcoq2 * xx1(i,j) +! --- lower limit on roughness? --- + rough_mom (i,j) = max( rough_mom (i,j), roughness_min ) + rough_heat (i,j) = max( rough_heat (i,j), roughness_min ) + rough_moist(i,j) = max( rough_moist(i,j), roughness_min ) + enddo + enddo +! SJL ----------------------------------------------------------------------------------- + else + rough_mom (:,:) = zcom1 * xx2(:,:) + zcom2 * xx1(:,:) + rough_heat (:,:) = zcoh1 * xx2(:,:) + zcoh2 * xx1(:,:) + rough_moist(:,:) = zcoq1 * xx2(:,:) + zcoq2 * xx1(:,:) +! --- lower limit on roughness? --- + rough_mom (:,:) = max( rough_mom (:,:), roughness_min ) + rough_heat (:,:) = max( rough_heat (:,:), roughness_min ) + rough_moist(:,:) = max( rough_moist(:,:), roughness_min ) + endif + endif + endif + endif +!----------------------------------------------------------------------- + + end subroutine compute_ocean_roughness + +!####################################################################### + + subroutine fixed_ocean_roughness ( speed, rough_mom, rough_heat, rough_moist ) + + real, intent(in) :: speed(:,:) + real, intent(out) :: rough_mom(:,:), rough_heat(:,:), rough_moist(:,:) + + rough_mom = roughness_mom + rough_heat = roughness_heat + rough_moist = roughness_moist + end subroutine fixed_ocean_roughness + +!####################################################################### + + subroutine ocean_rough_init(speed, z0, zt, zq) + + real, intent(in) :: speed(:,:) ! 10-m wind speed + real, intent(out) :: z0(:,:), zt(:,:), zq(:,:) + integer i,j + integer :: unit, ierr, io + + do j=1, size(speed,2) + do i=1, size(speed,1) + if ( speed(i,j) > 12.5 ) then + z0(i,j) = 0.001*(0.085*speed(i,j) - 0.58) + else + z0(i,j) = 0.0185/grav*(0.001*speed(i,j)**2+0.028*speed(i,j))**2 + endif + z0(i,j) = max(z0(i,j), roughness_min) ! prevents blowup if cold start (V=0) + zt(i,j) = z0(i,j) + zq(i,j) = z0(i,j) + enddo + enddo + + do_init = .false. + + end subroutine ocean_rough_init + +end module ocean_rough_mod + diff --git a/driver/solo/qs_tables.F90 b/driver/solo/qs_tables.F90 new file mode 100644 index 000000000..83b7f26fe --- /dev/null +++ b/driver/solo/qs_tables.F90 @@ -0,0 +1,135 @@ +!*********************************************************************** +!* GNU Lesser General Public License +!* +!* This file is part of the FV3 dynamical core. +!* +!* The FV3 dynamical core is free software: you can redistribute it +!* and/or modify it under the terms of the +!* GNU Lesser General Public License as published by the +!* Free Software Foundation, either version 3 of the License, or +!* (at your option) any later version. +!* +!* The FV3 dynamical core is distributed in the hope that it will be +!* useful, but WITHOUT ANY WARRANTY; without even the implied warranty +!* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. +!* See the GNU General Public License for more details. +!* +!* You should have received a copy of the GNU Lesser General Public +!* License along with the FV3 dynamical core. +!* If not, see . +!*********************************************************************** + +module qs_tables_mod + +use constants_mod, only: rdgas, rvgas, cp_air, cp_vapor, hlv + +implicit none +logical:: qs_table_is_initialized = .false. +real, allocatable, dimension(:,:) :: table_w(:), des_w(:) +public :: qs_wat0, qs_wat, qs_wat_init + + real, parameter:: e0 = 610.71 ! saturation vapor pressure at T0 + real, parameter:: tice = 273.16 +! real, parameter:: c_liq = 4190. ! heat capacity of water at 0C + real, parameter:: c_liq = 4218.0 ! heat capacity of water at 0C + real, parameter:: cp_vap = cp_vapor ! 1846. +! For consistency, cv_vap derived FMS constants: + real, parameter:: cv_vap = cp_vap - rvgas ! 1384.5 + real, parameter:: cv_air = cp_air - rdgas +#ifdef SIM_NGGPS + real, parameter:: dc_vap = 0. +#else + real, parameter:: dc_vap = cp_vap - c_liq ! = -2344. isobaric heating/cooling +#endif + real, parameter:: Lv0 = hlv - dc_vap*tice +! L = hlv + (Cp_vapor-C_liq)*(T-T_ice) + +contains + + real function qs_wat0(ta, den) +! Pure water phase; universal dry/moist formular using air density +! Input "den" can be either dry or moist air density + real, intent(in):: ta, den +! local: + real es, ap1, dem + real, parameter:: tmin = tice - 160. + integer it + +! if (.not. qs_table_is_initialized) call qs_wat_init + ap1 = 10.*dim(ta, tmin) + 1. ! lower bound enforced + ap1 = min(2621., ap1) ! upper bound enforced + it = ap1 + es = table_w(it) + (ap1-it)*des_w(it) + dem = rvgas*ta*den + qs_wat0 = es / dem + + end function qs_wat0 + + real function qs_wat(ta, den, dqdt) +! Pure water phase; universal dry/moist formular using air density +! Input "den" can be either dry or moist air density +! Full-form: +! qsat = e0*rdgas/(rvgas*p_in)*exp((dc_vap*log(T_in/tice)+Lv0*(T_in-tice)/(T_in*tice))/rvgas) +! simple-form: +! qsat = e0*rdgas/(rvgas*p_in)*exp( hlv/rvgas*(T_in-tice)/(T_in*tice) ) +! + real, intent(in):: ta, den + real, intent(out):: dqdt +! local: + real es, ap1, dem + real, parameter:: tmin = tice - 160. + integer it + +! if (.not. qs_table_is_initialized) call qs_wat_init + ap1 = 10.*dim(ta, tmin) + 1. ! lower bound enforced + ap1 = min(2621., ap1) ! upper bound enforced + it = ap1 + es = table_w(it) + (ap1-it)*des_w(it) + dem = rvgas*ta*den + qs_wat = es / dem + it = ap1 - 0.5 +! Finite diff, del_T = 0.1: + dqdt = 10.*(des_w(it) + (ap1-it)*(des_w(it+1)-des_w(it))) / dem + + end function qs_wat + + subroutine qs_wat_init + integer, parameter:: length=2621 + integer i + + if( .not. qs_table_is_initialized ) then +! generate es table (dt = 0.1 deg. c) + allocate ( table_w(length) ) + allocate ( des_w(length) ) + + call qs_table_w(length ) + + do i=1,length-1 + des_w(i) = max(0., table_w(i+1) - table_w(i)) + enddo + des_w(length) = des_w(length-1) + + qs_table_is_initialized = .true. + endif + + end subroutine qs_wat_init + + subroutine qs_table_w(n) + integer, intent(in):: n + real, parameter:: del_t=0.1 + real:: tmin, tem, f0 + integer i + +! constants + tmin = tice - 160. + + do i=1,n + tem = tmin + del_t*real(i-1) +! compute es over water +! Lv0 = hlv - dc_vap*tice + table_w(i) = e0*exp((dc_vap*log(tem/tice)+Lv0*(tem-tice)/(tem*tice))/rvgas) + enddo + + end subroutine qs_table_w + +end module qs_tables_mod diff --git a/model/a2b_edge.F90 b/model/a2b_edge.F90 index 2bcd26966..9b2a4ae5c 100644 --- a/model/a2b_edge.F90 +++ b/model/a2b_edge.F90 @@ -10,7 +10,7 @@ !* (at your option) any later version. !* !* The FV3 dynamical core is distributed in the hope that it will be -!* useful, but WITHOUT ANYWARRANTY; without even the implied warranty +!* useful, but WITHOUT ANY WARRANTY; without even the implied warranty !* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. !* See the GNU General Public License for more details. !* @@ -18,6 +18,7 @@ !* License along with the FV3 dynamical core. !* If not, see . !*********************************************************************** + module a2b_edge_mod use fv_grid_utils_mod, only: great_circle_dist diff --git a/model/boundary.F90 b/model/boundary.F90 index 3d59114ce..8c02048fa 100644 --- a/model/boundary.F90 +++ b/model/boundary.F90 @@ -10,7 +10,7 @@ !* (at your option) any later version. !* !* The FV3 dynamical core is distributed in the hope that it will be -!* useful, but WITHOUT ANYWARRANTY; without even the implied warranty +!* useful, but WITHOUT ANY WARRANTY; without even the implied warranty !* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. !* See the GNU General Public License for more details. !* @@ -18,6 +18,7 @@ !* License along with the FV3 dynamical core. !* If not, see . !*********************************************************************** + module boundary_mod use fv_mp_mod, only: is_master @@ -29,7 +30,6 @@ module boundary_mod use mpp_domains_mod, only: AGRID, BGRID_NE, CGRID_NE, DGRID_NE use mpp_mod, only: mpp_error, FATAL, mpp_sum, mpp_sync, mpp_npes, mpp_broadcast, WARNING, mpp_pe - use fv_mp_mod, only: mp_bcst use fv_arrays_mod, only: fv_atmos_type, fv_nest_BC_type_3D, fv_grid_bounds_type use mpp_mod, only: mpp_send, mpp_recv use fv_timing_mod, only: timing_on, timing_off diff --git a/driver/SHiELD/cloud_diagnosis.F90 b/model/cld_eff_rad.F90 similarity index 79% rename from driver/SHiELD/cloud_diagnosis.F90 rename to model/cld_eff_rad.F90 index d36abe7be..fc7caee12 100644 --- a/driver/SHiELD/cloud_diagnosis.F90 +++ b/model/cld_eff_rad.F90 @@ -10,7 +10,7 @@ !* (at your option) any later version. !* !* The FV3 dynamical core is distributed in the hope that it will be -!* useful, but WITHOUT ANYWARRANTY; without even the implied warranty +!* useful, but WITHOUT ANY WARRANTY; without even the implied warranty !* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. !* See the GNU General Public License for more details. !* @@ -22,55 +22,36 @@ ! cloud radii diagnosis built for gfdl cloud microphysics ! authors: linjiong zhou and shian - jiann lin ! ======================================================================= -module cloud_diagnosis_mod +module cld_eff_rad_mod + + use gfdl_cld_mp_mod, only: rdgas, grav, pi, zvir, t_ice, ql0_max, & + ccn_o, ccn_l, rhow, rhor, rhos, rhog, qi0_max implicit none private - public cloud_diagnosis, cloud_diagnosis_init - - real, parameter :: grav = 9.80665 ! gfs: acceleration due to gravity - real, parameter :: rdgas = 287.05 ! gfs: gas constant for dry air - real, parameter :: rvgas = 461.50 ! gfs: gas constant for water vapor - real, parameter :: pi = 3.1415926535897931 ! gfs: ratio of circle circumference to diameter - - real, parameter :: zvir = rvgas / rdgas - 1. ! 0.6077338443 + public cld_eff_rad, cld_eff_rad_init - real :: tice = 273.16 ! set tice = 165. to trun off ice - phase phys (kessler emulator) - - real :: ql0_max = 2.0e-3 ! max cloud water value (auto converted to rain) - real :: qi0_max = 2.0e-4 ! max cloud ice value (by other sources) real :: qi0_rei = 0.8e-4 ! max cloud ice value (by other sources) - real :: ccn_o = 100. ! ccn over ocean (cm^ - 3) - real :: ccn_l = 300. ! ccn over land (cm^ - 3) - - ! cloud diagnosis - real :: qmin = 1.0e-12 ! minimum mass mixing ratio (kg / kg) - ! real :: beta = 1.22 ! defined in heymsfield and mcfarquhar, 1996 - real :: beta = 1. - ! real :: beta = 0.5 ! testing - - ! real :: rewmin = 1.0, rewmax = 25.0 - ! real :: reimin = 10.0, reimax = 300.0 - ! real :: rermin = 25.0, rermax = 225.0 - ! real :: resmin = 300, resmax = 1000.0 - ! real :: regmin = 1000.0, regmax = 1.0e5 - ! lz - ! real :: rewmin = 5.0, rewmax = 10.0 - ! real :: reimin = 10.0, reimax = 150.0 - ! real :: rermin = 0.0, rermax = 10000.0 - ! real :: resmin = 0.0, resmax = 10000.0 - ! real :: regmin = 0.0, regmax = 10000.0 - ! sjl - !!! real :: reimin = 10.0, reimax = 150.0 + real :: beta = 1.22 ! defined in heymsfield and mcfarquhar, 1996 + +#ifdef SJ_CLD_TEST real :: rewmin = 4.0, rewmax = 10.0 real :: reimin = 4.0, reimax = 250.0 real :: rermin = 5.0, rermax = 2000.0 real :: resmin = 5.0, resmax = 2000.0 real :: regmin = 5.0, regmax = 2000.0 +#else + real :: rewmin = 5.0, rewmax = 10.0 + real :: reimin = 10.0, reimax = 150.0 + real :: rermin = 0.0, rermax = 10000.0 + real :: resmin = 0.0, resmax = 10000.0 + real :: regmin = 0.0, regmax = 10000.0 +#endif + ! rewmax = 15.0, rermin = 15.0 ! Kokhanovsky 2004 real :: betaw = 1.0 real :: betai = 1.0 @@ -79,6 +60,7 @@ module cloud_diagnosis_mod real :: betag = 1.0 logical :: liq_ice_combine = .true. + logical :: snow_grauple_combine = .false. integer :: rewflag = 1 ! 1: martin et al., 1994 @@ -91,10 +73,10 @@ module cloud_diagnosis_mod ! 4: kristjansson et al., 2000 ! 5: wyser, 1998 - namelist / cloud_diagnosis_nml / & - ql0_max, qi0_max, qi0_rei, ccn_o, ccn_l, qmin, beta, liq_ice_combine, rewflag, reiflag, & - rewmin, rewmax, reimin, reimax, rermin, rermax, resmin, resmax, regmin, regmax, & - betaw, betai, betar, betas, betag + namelist / cld_eff_rad_nml / & + qi0_rei, qmin, beta, liq_ice_combine, rewflag, reiflag, rewmin, rewmax, reimin, & + reimax, rermin, rermax, resmin, resmax, regmin, regmax, betaw, betai, betar, betas, & + betag contains @@ -102,7 +84,7 @@ module cloud_diagnosis_mod ! radius of cloud species diagnosis ! ======================================================================= -subroutine cloud_diagnosis (is, ie, ks, ke, lsm, p, delp, t, qw, qi, qr, qs, qg, & +subroutine cld_eff_rad (is, ie, ks, ke, lsm, p, delp, t, qw, qi, qr, qs, qg, & qcw, qci, qcr, qcs, qcg, rew, rei, rer, res, reg, & cld, cloud, snowd, cnvw, cnvi, cnvc) @@ -118,12 +100,12 @@ subroutine cloud_diagnosis (is, ie, ks, ke, lsm, p, delp, t, qw, qi, qr, qs, qg, real, intent (in), dimension (is:ie, ks:ke) :: cloud ! cloud fraction real, intent (in), dimension (is:ie, ks:ke) :: qw, qi, qr, qs, qg ! mass mixing ratio (kg / kg) - real, intent (in), dimension (is:ie, ks:ke), optional :: cnvw, cnvi ! convective cloud water, cloud ice mass mixing ratio (kg / kg) + real, intent (in), dimension (is:ie, ks:ke), optional :: cnvw, cnvi ! convective cloud water / ice mass mixing ratio (kg / kg) real, intent (in), dimension (is:ie, ks:ke), optional :: cnvc ! convective cloud fraction - real, intent (out), dimension (is:ie, ks:ke) :: qcw, qci, qcr, qcs, qcg ! units: g / m^2 - real, intent (out), dimension (is:ie, ks:ke) :: rew, rei, rer, res, reg ! radii (micron) - real, intent (out), dimension (is:ie, ks:ke) :: cld ! total cloud fraction + real, intent (inout), dimension (is:ie, ks:ke) :: qcw, qci, qcr, qcs, qcg ! units: g / m^2 + real, intent (inout), dimension (is:ie, ks:ke) :: rew, rei, rer, res, reg ! radii (micron) + real, intent (inout), dimension (is:ie, ks:ke) :: cld ! total cloud fraction ! local variables @@ -142,10 +124,9 @@ subroutine cloud_diagnosis (is, ie, ks, ke, lsm, p, delp, t, qw, qi, qr, qs, qg, real :: lambdar, lambdas, lambdag real :: rei_fac - real :: rhow = 1.0e3, rhor = 1.0e3, rhos = 1.0e2, rhog = 4.0e2 ! density (kg / m^3) - real :: n0r = 8.0e6, n0s = 3.0e6, n0g = 4.0e6 ! intercept parameters (m^ - 4) - real :: alphar = 0.8, alphas = 0.25, alphag = 0.5 ! parameters in terminal equation in lin et al., 1983 - real :: gammar = 17.837789, gammas = 8.2850630, gammag = 11.631769 ! gamma values as a result of different alpha + real, parameter :: n0r = 8.0e6, n0s = 3.0e6, n0g = 4.0e6 ! intercept parameters (m^ - 4) in lin et al. (1983) + real, parameter :: alphar = 0.8, alphas = 0.25, alphag = 0.5 ! parameters in terminal equation in lin et al., (1983) + real, parameter :: gammar = 17.837789, gammas = 8.2850630, gammag = 11.631769 ! gamma values as a result of different alpha real, parameter :: rho_0 = 50.e-3 real :: retab (138) = (/ & @@ -193,10 +174,10 @@ subroutine cloud_diagnosis (is, ie, ks, ke, lsm, p, delp, t, qw, qi, qr, qs, qg, if (liq_ice_combine) then do k = ks, ke do i = is, ie - +#ifdef SJ_CLD_TEST ! frozen condensates: ! cloud ice treated as snow above freezing and graupel exists - if (t (i, k) > tice) then + if (t (i, k) > t_ice) then qms (i, k) = qmi (i, k) + qms (i, k) qmi (i, k) = 0. else @@ -209,8 +190,16 @@ subroutine cloud_diagnosis (is, ie, ks, ke, lsm, p, delp, t, qw, qi, qr, qs, qg, endif qmg (i, k) = 0. ! treating all graupel as "snow" endif +#else + qmw (i, k) = qmw (i, k) + qmr (i, k) + qmr (i, k) = 0.0 + qmi (i, k) = qmi (i, k) + qms (i, k) + qmg (i, k) + qms (i, k) = 0.0 + qmg (i, k) = 0.0 +#endif enddo enddo +#ifdef SJ_CLD_TEST else ! treating snow as ice, graupel as snow ! qmi (:, :) = qmi (:, :) + qms (:, :) @@ -229,10 +218,19 @@ subroutine cloud_diagnosis (is, ie, ks, ke, lsm, p, delp, t, qw, qi, qr, qs, qg, endif enddo enddo +#endif endif - ! liquid condensates: + if (snow_grauple_combine) then + do k = ks, ke + do i = is, ie + qms (i, k) = qms (i, k) + qmg (i, k) + qmg (i, k) = 0.0 + enddo + enddo + endif + ! liquid condensates: ! sjl: 20180825 #ifdef COMBINE_QR do k = ks, ke @@ -265,12 +263,11 @@ subroutine cloud_diagnosis (is, ie, ks, ke, lsm, p, delp, t, qw, qi, qr, qs, qg, mask = min (max (lsm (i), 0.0), 2.0) dpg = abs (delp (i, k)) / grav - ! sjl: ! rho = p (i, k) / (rdgas * t (i, k) * (1. + zvir * qv)) ! needs qv rho = p (i, k) / (rdgas * t (i, k)) ! use rho = dpg / delz ! needs delz - tc0 = t (i, k) - tice + tc0 = t (i, k) - t_ice if (rewflag .eq. 1) then @@ -278,8 +275,12 @@ subroutine cloud_diagnosis (is, ie, ks, ke, lsm, p, delp, t, qw, qi, qr, qs, qg, ! cloud water (martin et al., 1994) ! ----------------------------------------------------------------------- +#ifndef MARTIN_CCN + ccnw = ccn_o * abs (mask - 1.0) + ccn_l * (1.0 - abs (mask - 1.0)) +#else ccnw = 0.80 * (- 1.15e-3 * (ccn_o ** 2) + 0.963 * ccn_o + 5.30) * abs (mask - 1.0) + & - 0.67 * (- 2.10e-4 * (ccn_l ** 2) + 0.568 * ccn_l - 27.9) * (1.0 - abs (mask - 1.0)) + 0.67 * (- 2.10e-4 * (ccn_l ** 2) + 0.568 * ccn_l - 27.9) * (1.0 - abs (mask - 1.0)) +#endif if (qmw (i, k) .gt. qmin) then qcw (i, k) = betaw * dpg * qmw (i, k) * 1.0e3 @@ -302,7 +303,7 @@ subroutine cloud_diagnosis (is, ie, ks, ke, lsm, p, delp, t, qw, qi, qr, qs, qg, if (qmw (i, k) .gt. qmin) then qcw (i, k) = betaw * dpg * qmw (i, k) * 1.0e3 - rew (i, k) = exp (1.0 / 3.0 * log ((3.0 * qmw (i, k) / cld (i, k) * rho) / (4.0 * pi * rhow * ccnw))) * 1.0e4 + rew (i, k) = exp (1.0 / 3.0 * log ((3.0 * qmw (i, k) * rho) / (4.0 * pi * rhow * ccnw))) * 1.0e4 rew (i, k) = max (rewmin, min (rewmax, rew (i, k))) else qcw (i, k) = 0.0 @@ -320,7 +321,7 @@ subroutine cloud_diagnosis (is, ie, ks, ke, lsm, p, delp, t, qw, qi, qr, qs, qg, if (qmw (i, k) .gt. qmin) then qcw (i, k) = betaw * dpg * qmw (i, k) * 1.0e3 rew (i, k) = 14.0 * abs (mask - 1.0) + & - (8.0 + (14.0 - 8.0) * min (1.0, max (0.0, - tc0 / 30.0))) * (1.0 - abs (mask - 1.0)) + (8.0 + (14.0 - 8.0) * min (1.0, max (0.0, - tc0 / 30.0))) * (1.0 - abs (mask - 1.0)) rew (i, k) = rew (i, k) + (14.0 - rew (i, k)) * min (1.0, max (0.0, snowd (i) / 1000.0)) rew (i, k) = max (rewmin, min (rewmax, rew (i, k))) else @@ -338,20 +339,18 @@ subroutine cloud_diagnosis (is, ie, ks, ke, lsm, p, delp, t, qw, qi, qr, qs, qg, if (qmi (i, k) .gt. qmin) then qci (i, k) = betai * dpg * qmi (i, k) * 1.0e3 - ! sjl - ! rei_fac = log (1.0e3 * qmi (i, k) * rho) +#ifdef SJ_CLD_TEST rei_fac = log (1.0e3 * min (qi0_rei, qmi (i, k)) * rho) +#else + rei_fac = log (1.0e3 * qmi (i, k) * rho) +#endif if (tc0 .lt. - 50) then - ! rei (i, k) = beta / 9.917 * exp ((1. - 0.891) * rei_fac) * 1.0e3 rei (i, k) = beta / 9.917 * exp (0.109 * rei_fac) * 1.0e3 elseif (tc0 .lt. - 40) then - ! rei (i, k) = beta / 9.337 * exp ((1. - 0.920) * rei_fac) * 1.0e3 - rei (i, k) = beta / 9.337 * exp (0.08 * rei_fac) * 1.0e3 + rei (i, k) = beta / 9.337 * exp (0.080 * rei_fac) * 1.0e3 elseif (tc0 .lt. - 30) then - ! rei (i, k) = beta / 9.208 * exp ((1. - 0.945) * rei_fac) * 1.0e3 rei (i, k) = beta / 9.208 * exp (0.055 * rei_fac) * 1.0e3 else - ! rei (i, k) = beta / 9.387 * exp ((1. - 0.969) * rei_fac) * 1.0e3 rei (i, k) = beta / 9.387 * exp (0.031 * rei_fac) * 1.0e3 endif rei (i, k) = max (reimin, min (reimax, rei (i, k))) @@ -403,6 +402,7 @@ subroutine cloud_diagnosis (is, ie, ks, ke, lsm, p, delp, t, qw, qi, qr, qs, qg, if (qmi (i, k) .gt. qmin) then qci (i, k) = betai * dpg * qmi (i, k) * 1.0e3 +#ifdef SJ_CLD_TEST ! use fu2007 form below - 10 c if (tc0 > - 10) then ! tc = - 10, rei = 40.6 @@ -412,6 +412,10 @@ subroutine cloud_diagnosis (is, ie, ks, ke, lsm, p, delp, t, qw, qi, qr, qs, qg, endif ! rei (i, k) = max (reimin, min (reimax, rei (i, k))) rei (i, k) = max (reimin, rei (i, k)) +#else + rei (i, k) = 47.05 + tc0 * (0.6624 + 0.001741 * tc0) + rei (i, k) = max (reimin, min (reimax, rei (i, k))) +#endif else qci (i, k) = 0.0 rei (i, k) = reimin @@ -446,10 +450,9 @@ subroutine cloud_diagnosis (is, ie, ks, ke, lsm, p, delp, t, qw, qi, qr, qs, qg, if (qmi (i, k) .gt. qmin) then qci (i, k) = betai * dpg * qmi (i, k) * 1.0e3 - bw = - 2. + 1.e-3 * log10 (rho * qmi (i, k) / rho_0) * exp (1.5 * log (- min (- 1.e-6, tc0))) + bw = - 2. + 1.e-3 * log10 (rho * qmi (i, k) / rho_0) * max (0.0, - tc0) ** 1.5 rei (i, k) = 377.4 + bw * (203.3 + bw * (37.91 + 2.3696 * bw)) - ! rei (i, k) = max (reimin, min (reimax, rei (i, k))) - rei (i, k) = max (reimin, rei (i, k)) + rei (i, k) = max (reimin, min (reimax, rei (i, k))) else qci (i, k) = 0.0 rei (i, k) = reimin @@ -503,36 +506,24 @@ subroutine cloud_diagnosis (is, ie, ks, ke, lsm, p, delp, t, qw, qi, qr, qs, qg, enddo -end subroutine cloud_diagnosis +end subroutine cld_eff_rad -subroutine cloud_diagnosis_init (nlunit, input_nml_file, logunit, fn_nml) +subroutine cld_eff_rad_init (input_nml_file, logunit) implicit none - integer, intent (in) :: nlunit - integer, intent (in) :: logunit - - character (len = 64), intent (in) :: fn_nml character (len = *), intent (in) :: input_nml_file (:) + integer, intent (in) :: logunit - integer :: ios logical :: exists -#ifdef INTERNAL_FILE_NML - read (input_nml_file, nml = cloud_diagnosis_nml, iostat = ios) -#else - inquire (file = trim (fn_nml), exist = exists) - if (.not. exists) then - write (6, *) 'cloud_diagnosis :: namelist file: ', trim (fn_nml), ' does not exist' - stop - else - open (unit = nlunit, file = fn_nml, readonly, status = 'old', iostat = ios) - endif - rewind (nlunit) - read (nlunit, nml = cloud_diagnosis_nml) - close (nlunit) -#endif + read (input_nml_file, nml = cld_eff_rad_nml) + + ! write version number and namelist to log file + write (logunit, *) " ================================================================== " + write (logunit, *) "cld_eff_rad_mod" + write (logunit, nml = cld_eff_rad_nml) -end subroutine cloud_diagnosis_init +end subroutine cld_eff_rad_init -end module cloud_diagnosis_mod +end module cld_eff_rad_mod diff --git a/model/dyn_core.F90 b/model/dyn_core.F90 index bfce3d1d5..4ab79c9a0 100644 --- a/model/dyn_core.F90 +++ b/model/dyn_core.F90 @@ -10,7 +10,7 @@ !* (at your option) any later version. !* !* The FV3 dynamical core is distributed in the hope that it will be -!* useful, but WITHOUT ANYWARRANTY; without even the implied warranty +!* useful, but WITHOUT ANY WARRANTY; without even the implied warranty !* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. !* See the GNU General Public License for more details. !* @@ -18,9 +18,11 @@ !* License along with the FV3 dynamical core. !* If not, see . !*********************************************************************** + module dyn_core_mod - use constants_mod, only: rdgas, radius, cp_air, pi + use constants_mod, only: rdgas, cp_air, pi + use fv_arrays_mod, only: radius ! scaled for small earth use mpp_mod, only: mpp_pe use mpp_domains_mod, only: CGRID_NE, DGRID_NE, mpp_get_boundary, mpp_update_domains, & domain2d @@ -33,7 +35,7 @@ module dyn_core_mod use nh_core_mod, only: Riem_Solver3, Riem_Solver_C, update_dz_c, update_dz_d, nh_bc use tp_core_mod, only: copy_corners use fv_timing_mod, only: timing_on, timing_off - use fv_diagnostics_mod, only: prt_maxmin, fv_time, prt_mxm + use fv_diagnostics_mod, only: prt_maxmin, fv_time, prt_mxm, is_ideal_case use fv_diag_column_mod, only: do_diag_debug_dyn, debug_column_dyn #ifdef ROT3 use fv_update_phys_mod, only: update_dwinds_phys @@ -87,7 +89,7 @@ subroutine dyn_core(npx, npy, npz, ng, sphum, nq, bdt, n_map, n_split, zvir, cp, u, v, w, delz, pt, q, delp, pe, pk, phis, ws, omga, ptop, pfull, ua, va, & uc, vc, mfx, mfy, cx, cy, pkz, peln, q_con, ak, bk, & ks, gridstruct, flagstruct, neststruct, idiag, bd, domain, & - init_step, i_pack, end_step, time_total) + init_step, i_pack, end_step, diss_est, time_total) integer, intent(IN) :: npx integer, intent(IN) :: npy integer, intent(IN) :: npz @@ -111,6 +113,7 @@ subroutine dyn_core(npx, npy, npz, ng, sphum, nq, bdt, n_map, n_split, zvir, cp, real, intent(inout) :: pt( bd%isd:bd%ied ,bd%jsd:bd%jed ,npz) ! temperature (K) real, intent(inout) :: delp(bd%isd:bd%ied ,bd%jsd:bd%jed ,npz) ! pressure thickness (pascal) real, intent(inout) :: q( bd%isd:bd%ied ,bd%jsd:bd%jed ,npz, nq) ! + real, intent(inout) :: diss_est(bd%isd:bd%ied ,bd%jsd:bd%jed ,npz) !< skeb dissipation real, intent(in), optional:: time_total ! total time (seconds) since start !----------------------------------------------------------------------- @@ -169,6 +172,8 @@ subroutine dyn_core(npx, npy, npz, ng, sphum, nq, bdt, n_map, n_split, zvir, cp, real wk(bd%isd:bd%ied,bd%jsd:bd%jed) real fz(bd%is: bd%ie+1,bd%js: bd%je+1) real heat_s(bd%is:bd%ie,bd%js:bd%je) +! new array for stochastic kinetic energy backscatter (SKEB) + real diss_e(bd%is:bd%ie,bd%js:bd%je) real damp_vt(npz+1) integer nord_v(npz+1) !------------------------------------- @@ -267,6 +272,7 @@ subroutine dyn_core(npx, npy, npz, ng, sphum, nq, bdt, n_map, n_split, zvir, cp, allocate( dv(isd:ied+1,jsd:jed, npz) ) call init_ijk_mem(isd,ied+1, jsd,jed , npz, dv, 0.) endif + call init_ijk_mem(isd,ied, jsd,jed, npz, diss_est, 0.) endif ! end init_step ! Empty the "flux capacitors" @@ -330,6 +336,7 @@ subroutine dyn_core(npx, npy, npz, ng, sphum, nq, bdt, n_map, n_split, zvir, cp, call timing_off('COMM_TOTAL') endif +#ifndef SW_DYNAMICS if ( .not. hydrostatic ) then call timing_on('COMM_TOTAL') call start_group_halo_update(i_pack(7), w, domain) @@ -373,14 +380,12 @@ subroutine dyn_core(npx, npy, npz, ng, sphum, nq, bdt, n_map, n_split, zvir, cp, call timing_off('COMM_TOTAL') endif - endif - + endif +#endif #ifdef SW_DYNAMICS if (test_case>1) then -#ifdef USE_OLD - if (test_case==9) call case9_forcing1(phis, time_total) -#endif + if (test_case==9) call case9_forcing1(phis, time_total, isd, ied, jsd, jed) #endif if ( it==1 ) then @@ -454,13 +459,13 @@ subroutine dyn_core(npx, npy, npz, ng, sphum, nq, bdt, n_map, n_split, zvir, cp, isd, ied, jsd, jed, npz, & is, ie, js, je, & isd, ied, jsd, jed, & - reg_bc_update_time ) + reg_bc_update_time,it ) #ifndef SW_DYNAMICS call regional_boundary_update(ptc, 'pt', & isd, ied, jsd, jed, npz, & is, ie, js, je, & isd, ied, jsd, jed, & - reg_bc_update_time ) + reg_bc_update_time,it ) #endif endif if ( hydrostatic ) then @@ -559,16 +564,20 @@ subroutine dyn_core(npx, npy, npz, ng, sphum, nq, bdt, n_map, n_split, zvir, cp, call start_group_halo_update(i_pack(9), uc, vc, domain, gridtype=CGRID_NE) call timing_off('COMM_TOTAL') #ifdef SW_DYNAMICS -#ifdef USE_OLD - if (test_case==9) call case9_forcing2(phis) -#endif + if (test_case==9) call case9_forcing2(phis, isd, ied, jsd, jed) endif !test_case>1 #endif call timing_on('COMM_TOTAL') if (flagstruct%inline_q .and. nq>0) call complete_group_halo_update(i_pack(10), domain) - if (flagstruct%nord > 0) call complete_group_halo_update(i_pack(3), domain) - call complete_group_halo_update(i_pack(9), domain) +#ifdef SW_DYNAMICS + if (test_case > 1) then +#endif + if (flagstruct%nord > 0) call complete_group_halo_update(i_pack(3), domain) + call complete_group_halo_update(i_pack(9), domain) +#ifdef SW_DYNAMICS + endif +#endif call timing_off('COMM_TOTAL') if (gridstruct%nested) then @@ -606,12 +615,12 @@ subroutine dyn_core(npx, npy, npz, ng, sphum, nq, bdt, n_map, n_split, zvir, cp, isd, ied, jsd, jed+1, npz, & is, ie, js, je, & isd, ied, jsd, jed, & - reg_bc_update_time ) + reg_bc_update_time,it ) call regional_boundary_update(uc, 'uc', & isd, ied+1, jsd, jed, npz, & is, ie, js, je, & isd, ied, jsd, jed, & - reg_bc_update_time ) + reg_bc_update_time,it ) call mpp_update_domains(uc, vc, domain, gridtype=CGRID_NE) !!! Currently divgd is always 0.0 in the regional domain boundary area. reg_bc_update_time=current_time_in_seconds+bdt*(n_map-1)+(it-1)*dt @@ -619,7 +628,7 @@ subroutine dyn_core(npx, npy, npz, ng, sphum, nq, bdt, n_map, n_split, zvir, cp, isd, ied+1, jsd, jed+1, npz, & is, ie, js, je, & isd, ied, jsd, jed, & - reg_bc_update_time ) + reg_bc_update_time,it ) endif if ( flagstruct%inline_q ) then @@ -637,7 +646,7 @@ subroutine dyn_core(npx, npy, npz, ng, sphum, nq, bdt, n_map, n_split, zvir, cp, isd, ied, jsd, jed, npz, & is, ie, js, je, & isd, ied, jsd, jed, & - reg_bc_update_time ) + reg_bc_update_time,it ) enddo endif @@ -649,9 +658,9 @@ subroutine dyn_core(npx, npy, npz, ng, sphum, nq, bdt, n_map, n_split, zvir, cp, !$OMP is,ie,js,je,isd,ied,jsd,jed,omga,delp,gridstruct,npx,npy, & !$OMP ng,zh,vt,ptc,pt,u,v,w,uc,vc,ua,va,divgd,mfx,mfy,cx,cy, & !$OMP crx,cry,xfx,yfx,q_con,zvir,sphum,nq,q,dt,bd,rdt,iep1,jep1, & -!$OMP heat_source) & +!$OMP heat_source,is_ideal_case,diss_est,radius) & !$OMP private(nord_k, nord_w, nord_t, damp_w, damp_t, d2_divg, & -!$OMP d_con_k,kgb, hord_m, hord_v, hord_t, hord_p, wk, heat_s, z_rat) +!$OMP d_con_k,kgb, hord_m, hord_v, hord_t, hord_p, wk, heat_s, diss_e, z_rat) do k=1,npz hord_m = flagstruct%hord_mt hord_t = flagstruct%hord_tm @@ -688,7 +697,12 @@ subroutine dyn_core(npx, npy, npz, ng, sphum, nq, bdt, n_map, n_split, zvir, cp, ! no special damping of potential temperature in sponge layers if ( k==1 ) then ! Divergence damping: - nord_k=0; d2_divg = max(0.01, flagstruct%d2_bg, flagstruct%d2_bg_k1) + nord_k=0; + if (is_ideal_case) then + d2_divg = max(flagstruct%d2_bg, flagstruct%d2_bg_k1) + else + d2_divg = max(0.01, flagstruct%d2_bg, flagstruct%d2_bg_k1) + endif ! Vertical velocity: nord_w=0; damp_w = d2_divg if ( flagstruct%do_vort_damp ) then @@ -716,7 +730,7 @@ subroutine dyn_core(npx, npy, npz, ng, sphum, nq, bdt, n_map, n_split, zvir, cp, endif endif - if( hydrostatic .and. (.not.flagstruct%use_old_omega) .and. last_step ) then + if( (.not.flagstruct%use_old_omega) .and. last_step ) then ! Average horizontal "convergence" to cell center do j=js,je do i=is,ie @@ -725,7 +739,7 @@ subroutine dyn_core(npx, npy, npz, ng, sphum, nq, bdt, n_map, n_split, zvir, cp, enddo endif -!--- external mode divergence damping --- + !--- external mode divergence damping --- if ( flagstruct%d_ext > 0. ) & call a2b_ord2(delp(isd,jsd,k), wk, gridstruct, npx, npy, is, & ie, js, je, ng, .false.) @@ -748,12 +762,12 @@ subroutine dyn_core(npx, npy, npz, ng, sphum, nq, bdt, n_map, n_split, zvir, cp, #else q_con(isd:,jsd:,1), z_rat(isd,jsd), & #endif - kgb, heat_s, zvir, sphum, nq, q, k, npz, flagstruct%inline_q, dt, & + kgb, heat_s, diss_e, zvir, sphum, nq, q, k, npz, flagstruct%inline_q, dt, & flagstruct%hord_tr, hord_m, hord_v, hord_t, hord_p, & nord_k, nord_v(k), nord_w, nord_t, flagstruct%dddmp, d2_divg, flagstruct%d4_bg, & damp_vt(k), damp_w, damp_t, d_con_k, hydrostatic, gridstruct, flagstruct, bd) - if( hydrostatic .and. (.not.flagstruct%use_old_omega) .and. last_step ) then + if((.not.flagstruct%use_old_omega) .and. last_step ) then ! Average horizontal "convergence" to cell center do j=js,je do i=is,ie @@ -769,11 +783,12 @@ subroutine dyn_core(npx, npy, npz, ng, sphum, nq, bdt, n_map, n_split, zvir, cp, enddo enddo endif - if ( flagstruct%d_con > 1.0E-5 ) then + if ( flagstruct%d_con > 1.0E-5 .OR. flagstruct%do_diss_est ) then ! Average horizontal "convergence" to cell center do j=js,je do i=is,ie heat_source(i,j,k) = heat_source(i,j,k) + heat_s(i,j) + diss_est(i,j,k) = diss_est(i,j,k) + diss_e(i,j) enddo enddo endif @@ -855,20 +870,20 @@ subroutine dyn_core(npx, npy, npz, ng, sphum, nq, bdt, n_map, n_split, zvir, cp, isd, ied, jsd, jed, npz, & is, ie, js, je, & isd, ied, jsd, jed, & - reg_bc_update_time ) + reg_bc_update_time,it ) #ifndef SW_DYNAMICS call regional_boundary_update(pt, 'pt', & isd, ied, jsd, jed, npz, & is, ie, js, je, & isd, ied, jsd, jed, & - reg_bc_update_time ) + reg_bc_update_time,it ) #ifdef USE_COND call regional_boundary_update(q_con, 'q_con', & isd, ied, jsd, jed, npz, & is, ie, js, je, & isd, ied, jsd, jed, & - reg_bc_update_time ) + reg_bc_update_time,it ) #endif #endif @@ -1081,7 +1096,7 @@ subroutine dyn_core(npx, npy, npz, ng, sphum, nq, bdt, n_map, n_split, zvir, cp, endif #ifndef ROT3 - if ( it/=n_split) & + if ( .not. flagstruct%regional .and. it/=n_split) & call start_group_halo_update(i_pack(8), u, v, domain, gridtype=DGRID_NE) #endif call timing_off('COMM_TOTAL') @@ -1095,7 +1110,7 @@ subroutine dyn_core(npx, npy, npz, ng, sphum, nq, bdt, n_map, n_split, zvir, cp, #ifdef SW_DYNAMICS #else - if ( hydrostatic .and. last_step ) then + if ( last_step ) then if ( flagstruct%use_old_omega ) then !$OMP parallel do default(none) shared(is,ie,js,je,npz,omga,pe,pem,rdt) do k=1,npz @@ -1138,7 +1153,8 @@ subroutine dyn_core(npx, npy, npz, ng, sphum, nq, bdt, n_map, n_split, zvir, cp, enddo used=send_data(idiag%id_ws, ws, fv_time) endif - endif + endif + #endif if (gridstruct%nested) then @@ -1163,14 +1179,14 @@ subroutine dyn_core(npx, npy, npz, ng, sphum, nq, bdt, n_map, n_split, zvir, cp, if (flagstruct%regional) then + reg_bc_update_time=current_time_in_seconds+bdt*(n_map-1)+it*dt #ifndef SW_DYNAMICS if (.not. hydrostatic) then - reg_bc_update_time=current_time_in_seconds+bdt*(n_map-1)+it*dt call regional_boundary_update(w, 'w', & isd, ied, jsd, jed, ubound(w,3), & is, ie, js, je, & isd, ied, jsd, jed, & - reg_bc_update_time ) + reg_bc_update_time,it ) endif #endif SW_DYNAMICS @@ -1178,15 +1194,19 @@ subroutine dyn_core(npx, npy, npz, ng, sphum, nq, bdt, n_map, n_split, zvir, cp, isd, ied, jsd, jed+1, npz, & is, ie, js, je, & isd, ied, jsd, jed, & - reg_bc_update_time ) + reg_bc_update_time,it ) call regional_boundary_update(v, 'v', & isd, ied+1, jsd, jed, npz, & is, ie, js, je, & isd, ied, jsd, jed, & - reg_bc_update_time ) + reg_bc_update_time,it ) - call mpp_update_domains(u, v, domain, gridtype=DGRID_NE) - end if +#ifndef ROT3 + if (it/=n_split) & + call start_group_halo_update(i_pack(8), u, v, domain, gridtype=DGRID_NE) +#endif + + endif if ( do_diag_debug_dyn ) then call debug_column_dyn( pt, delp, delz, u, v, w, q, heat_source, cappa, akap, & diff --git a/model/fv_cmp.F90 b/model/fast_sat_adj.F90 similarity index 76% rename from model/fv_cmp.F90 rename to model/fast_sat_adj.F90 index ddfec99f7..3abda323a 100644 --- a/model/fv_cmp.F90 +++ b/model/fast_sat_adj.F90 @@ -10,7 +10,7 @@ !* (at your option) any later version. !* !* The FV3 dynamical core is distributed in the hope that it will be -!* useful, but WITHOUT ANYWARRANTY; without even the implied warranty +!* useful, but WITHOUT ANY WARRANTY; without even the implied warranty !* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. !* See the GNU General Public License for more details. !* @@ -19,64 +19,33 @@ !* If not, see . !*********************************************************************** ! ======================================================================= -! fast saturation adjustment is part of the gfdl cloud microphysics +! fast saturation adjustment is part of the gfdl cloud microphysics. +! it mainly consists of melting / freezing, condensation / evaporation, +! sublimation / deposition, and autoconversion processes. ! developer: shian - jiann lin, linjiong zhou ! ======================================================================= -module fv_cmp_mod +module fast_sat_adj_mod - use constants_mod, only: rvgas, rdgas, grav, hlv, hlf, cp_air - !use fv_mp_mod, only: is_master use fv_arrays_mod, only: r_grid - use gfdl_cloud_microphys_mod, only: ql_gen, qi_gen, qi0_max, ql_mlt, ql0_max, qi_lim, qs_mlt - use gfdl_cloud_microphys_mod, only: icloud_f, sat_adj0, t_sub, cld_min - use gfdl_cloud_microphys_mod, only: tau_r2g, tau_smlt, tau_i2s, tau_v2l, tau_l2v, tau_imlt, tau_l2r - use gfdl_cloud_microphys_mod, only: rad_rain, rad_snow, rad_graupel, dw_ocean, dw_land + use gfdl_mp_mod, only: rvgas, rdgas, grav, hlv, hlf, cp_air, ql_gen, qi_gen, qi0_max, & + ql_mlt, ql0_max, qi_lim, qs_mlt, icloud_f, sat_adj0, t_sub, cld_min, tau_r2g, tau_smlt, & + tau_i2s, tau_v2l, tau_l2v, tau_imlt, tau_l2r, rad_rain, rad_snow, rad_graupel, & + dw_ocean, dw_land, cp_vap, cv_air, cv_vap, c_ice, c_liq, dc_vap, dc_ice, t_ice, & + t_wfr, e00, rgrav, consv_checker, zvir, do_qa, te_err, prog_ccn, ccn_l, ccn_o, rhow, inflag implicit none private - public fv_sat_adj, qs_init, c_ice, c_liq + public fast_sat_adj, qsmith_init + public wqs2_vect, qs_table, qs_tablew, qs_table2, wqs1, iqs1, wqs2, iqs2 - ! real, parameter :: cp_air = cp_air ! 1004.6, heat capacity of dry air at constant pressure, come from constants_mod - real, parameter :: cp_vap = 4.0 * rvgas ! 1846.0, heat capacity of water vapor at constant pressure - real, parameter :: cv_air = cp_air - rdgas ! 717.55, heat capacity of dry air at constant volume - real, parameter :: cv_vap = 3.0 * rvgas ! 1384.5, heat capacity of water vapor at constant volume + real, parameter :: lv0 = hlv - dc_vap * t_ice + real, parameter :: li00 = hlf - dc_ice * t_ice - ! http: // www.engineeringtoolbox.com / ice - thermal - properties - d_576.html - ! c_ice = 2050.0 at 0 deg c - ! c_ice = 1972.0 at - 15 deg c - ! c_ice = 1818.0 at - 40 deg c - ! http: // www.engineeringtoolbox.com / water - thermal - properties - d_162.html - ! c_liq = 4205.0 at 4 deg c - ! c_liq = 4185.5 at 15 deg c - ! c_liq = 4178.0 at 30 deg c - - real, parameter :: c_ice = 2106.0 ! ifs: heat capacity of ice at 0 deg c - real, parameter :: c_liq = 4218.0 ! ifs: heat capacity of liquid at 0 deg c - ! real, parameter :: c_ice = 1972.0 ! gfdl: heat capacity of ice at - 15 deg c - ! real, parameter :: c_liq = 4185.5 ! gfdl: heat capacity of liquid at 15 deg c - - real, parameter :: dc_vap = cp_vap - c_liq ! - 2339.5, isobaric heating / cooling - real, parameter :: dc_ice = c_liq - c_ice ! 2213.5, isobaric heating / colling - - real, parameter :: tice = 273.16 ! freezing temperature - real, parameter :: t_wfr = tice - 40. ! homogeneous freezing temperature - - real, parameter :: lv0 = hlv - dc_vap * tice ! 3.13905782e6, evaporation latent heat coefficient at 0 deg k - real, parameter :: li00 = hlf - dc_ice * tice ! - 2.7105966e5, fussion latend heat coefficient at 0 deg k - - ! real (kind = r_grid), parameter :: e00 = 610.71 ! gfdl: saturation vapor pressure at 0 deg c - real (kind = r_grid), parameter :: e00 = 611.21 ! ifs: saturation vapor pressure at 0 deg c - - real (kind = r_grid), parameter :: d2ice = dc_vap + dc_ice ! - 126, isobaric heating / cooling - real (kind = r_grid), parameter :: li2 = lv0 + li00 ! 2.86799816e6, sublimation latent heat coefficient at 0 deg k - - real, parameter :: lat2 = (hlv + hlf) ** 2 ! used in bigg mechanism - - real :: d0_vap ! the same as dc_vap, except that cp_vap can be cp_vap or cv_vap - real :: lv00 ! the same as lv0, except that cp_vap can be cp_vap or cv_vap + real (kind = r_grid), parameter :: d2ice = cp_vap - c_ice + real (kind = r_grid), parameter :: li2 = lv0 + li00 real, allocatable :: table (:), table2 (:), tablew (:), des2 (:), desw (:) @@ -87,60 +56,63 @@ module fv_cmp_mod ! ======================================================================= ! fast saturation adjustments ! this is designed for single - moment 6 - class cloud microphysics schemes -! handles the heat release due to in situ phase changes +! handles the heat release due to in situ phase changes. ! ======================================================================= -subroutine fv_sat_adj (mdt, zvir, is, ie, js, je, ng, hydrostatic, consv_te, & - te0, qv, ql, qi, qr, qs, qg, hs, dpln, delz, pt, dp, q_con, cappa, & - area, dtdt, out_dt, last_step, do_qa, qa) +subroutine fast_sat_adj (mdt, is, ie, js, je, ng, hydrostatic, consv_te, & + te, qv, ql, qi, qr, qs, qg, qa, qnl, qni, hs, dpln, delz, pt, delp, & + q_con, cappa, gsize, dtdt, out_dt, last_step) implicit none - integer, intent (in) :: is, ie, js, je, ng + logical, intent (in) :: hydrostatic, consv_te, out_dt, last_step - logical, intent (in) :: hydrostatic, consv_te, out_dt, last_step, do_qa + integer, intent (in) :: is, ie, js, je, ng - real, intent (in) :: zvir, mdt ! remapping time step + real, intent (in) :: mdt - real, intent (in), dimension (is - ng:ie + ng, js - ng:je + ng) :: dp, hs + real, intent (in), dimension (is - ng:ie + ng, js - ng:je + ng) :: delp, hs real, intent (in), dimension (is:ie, js:je) :: dpln - real, intent (in), dimension (is:, js:) :: delz + real, intent (in), dimension (is:ie, js:je) :: delz + + real (kind = r_grid), intent (in), dimension (is:ie, js:je) :: gsize - real, intent (inout), dimension (is - ng:ie + ng, js - ng:je + ng) :: pt, qv, ql, qi, qr, qs, qg + real, intent (inout), dimension (is - ng:ie + ng, js - ng:je + ng) :: pt, qv, ql, qr + real, intent (inout), dimension (is - ng:ie + ng, js - ng:je + ng) :: qi, qs, qg real, intent (inout), dimension (is - ng:, js - ng:) :: q_con, cappa real, intent (inout), dimension (is:ie, js:je) :: dtdt - real, intent (out), dimension (is - ng:ie + ng, js - ng:je + ng) :: qa, te0 + real, intent (inout), dimension (is - ng:ie + ng, js - ng:je + ng) :: qa, te, qnl, qni - real (kind = r_grid), intent (in), dimension (is - ng:ie + ng, js - ng:je + ng) :: area + real (kind = r_grid), dimension (is:ie, js:je) :: te_beg, te_end, tw_beg, tw_end real, dimension (is:ie) :: wqsat, dq2dt, qpz, cvm, t0, pt1, qstar real, dimension (is:ie) :: icp2, lcp2, tcp2, tcp3 real, dimension (is:ie) :: den, q_liq, q_sol, q_cond, src, sink, hvar - real, dimension (is:ie) :: mc_air, lhl, lhi + real, dimension (is:ie) :: mc_air, lhl, lhi, ccn, cin - real :: qsw, rh + real :: d0_vap ! the same as dc_vap, except that cp_vap can be cp_vap or cv_vap + real :: lv00 ! the same as lv0, except that cp_vap can be cp_vap or cv_vap + real :: qsw, rh, lat2, ccn0 real :: tc, qsi, dqsdt, dq, dq0, pidep, qi_crt, tmp, dtmp real :: tin, rqi, q_plus, q_minus real :: sdt, dt_bigg, adj_fac real :: fac_smlt, fac_r2g, fac_i2s, fac_imlt, fac_l2r, fac_v2l, fac_l2v - real :: factor, qim, tice0, c_air, c_vap, dw + real :: factor, qim, c_air, c_vap, dw integer :: i, j - sdt = 0.5 * mdt ! half remapping time step - dt_bigg = mdt ! bigg mechinism time step - - tice0 = tice - 0.01 ! 273.15, standard freezing temperature + sdt = 0.5 * mdt + dt_bigg = mdt ! ----------------------------------------------------------------------- - ! define conversion scalar / factor + ! conversion scalar / factor ! ----------------------------------------------------------------------- fac_i2s = 1. - exp (- mdt / tau_i2s) - fac_v2l = 1. - exp (- sdt / tau_v2l) fac_r2g = 1. - exp (- mdt / tau_r2g) fac_l2r = 1. - exp (- mdt / tau_l2r) + fac_v2l = 1. - exp (- sdt / tau_v2l) fac_l2v = 1. - exp (- sdt / tau_l2v) fac_l2v = min (sat_adj0, fac_l2v) @@ -149,7 +121,7 @@ subroutine fv_sat_adj (mdt, zvir, is, ie, js, je, ng, hydrostatic, consv_te, & fac_smlt = 1. - exp (- mdt / tau_smlt) ! ----------------------------------------------------------------------- - ! define heat capacity of dry air and water vapor based on hydrostatical property + ! heat capacity of dry air and water vapor based on hydrostatical property ! ----------------------------------------------------------------------- if (hydrostatic) then @@ -160,70 +132,105 @@ subroutine fv_sat_adj (mdt, zvir, is, ie, js, je, ng, hydrostatic, consv_te, & c_vap = cv_vap endif d0_vap = c_vap - c_liq - lv00 = hlv - d0_vap * tice - ! dc_vap = cp_vap - c_liq ! - 2339.5 - ! d0_vap = cv_vap - c_liq ! - 2801.0 + lv00 = hlv - d0_vap * t_ice + + lat2 = (hlv + hlf) ** 2 - do j = js, je ! start j loop + do j = js, je + + ! ----------------------------------------------------------------------- + ! compute true temperature + ! ----------------------------------------------------------------------- do i = is, ie q_liq (i) = ql (i, j) + qr (i, j) q_sol (i) = qi (i, j) + qs (i, j) + qg (i, j) qpz (i) = q_liq (i) + q_sol (i) -#ifdef USE_COND +#ifdef MOIST_CAPPA pt1 (i) = pt (i, j) / ((1 + zvir * qv (i, j)) * (1 - qpz (i))) #else pt1 (i) = pt (i, j) / (1 + zvir * qv (i, j)) #endif - t0 (i) = pt1 (i) ! true temperature - qpz (i) = qpz (i) + qv (i, j) ! total_wat conserved in this routine + t0 (i) = pt1 (i) + qpz (i) = qpz (i) + qv (i, j) enddo ! ----------------------------------------------------------------------- - ! define air density based on hydrostatical property + ! moist air density based on hydrostatical property ! ----------------------------------------------------------------------- if (hydrostatic) then do i = is, ie - den (i) = dp (i, j) / (dpln (i, j) * rdgas * pt (i, j)) + den (i) = delp (i, j) / (dpln (i, j) * rdgas * pt (i, j)) enddo else do i = is, ie - den (i) = - dp (i, j) / (grav * delz (i, j)) ! moist_air density + den (i) = - delp (i, j) / (grav * delz (i, j)) enddo endif ! ----------------------------------------------------------------------- - ! define heat capacity and latend heat coefficient + ! calculate cloud condensation nuclei (ccn) + ! the following is based on klein eq. 15 + ! ----------------------------------------------------------------------- + + if (prog_ccn) then + do i = is, ie + ccn (i) = max (10.0, qnl (i, j)) * 1.e6 + cin (i) = max (10.0, qni (i, j)) * 1.e6 + ccn (i) = ccn (i) / den (i) + enddo + else + do i = is, ie + ccn0 = (ccn_l * min (1., abs (hs (i, j)) / (10. * grav)) + & + ccn_o * (1. - min (1., abs (hs (i, j)) / (10. * grav)))) * 1.e6 + ccn (i) = ccn0 / den (i) + enddo + endif + + ! ----------------------------------------------------------------------- + ! moist heat capacity and latend heat coefficient ! ----------------------------------------------------------------------- do i = is, ie - mc_air (i) = (1. - qpz (i)) * c_air ! constant + mc_air (i) = (1. - qpz (i)) * c_air cvm (i) = mc_air (i) + qv (i, j) * c_vap + q_liq (i) * c_liq + q_sol (i) * c_ice lhi (i) = li00 + dc_ice * pt1 (i) icp2 (i) = lhi (i) / cvm (i) enddo ! ----------------------------------------------------------------------- - ! fix energy conservation + ! for energy fixer ! ----------------------------------------------------------------------- if (consv_te) then if (hydrostatic) then do i = is, ie - te0 (i, j) = - c_air * t0 (i) + te (i, j) = - c_air * t0 (i) enddo else do i = is, ie -#ifdef USE_COND - te0 (i, j) = - cvm (i) * t0 (i) +#ifdef MOIST_CAPPA + te (i, j) = - cvm (i) * t0 (i) #else - te0 (i, j) = - c_air * t0 (i) + te (i, j) = - c_air * t0 (i) #endif enddo endif endif + ! ----------------------------------------------------------------------- + ! total energy checker + ! ----------------------------------------------------------------------- + + if (consv_checker) then + do i = is, ie + te_beg (i, j) = cvm (i) * pt1 (i) + lv00 * qv (i, j) - li00 * q_sol (i) + te_beg (i, j) = rgrav * te_beg (i, j) * delp (i, j) * gsize (i, j) ** 2.0 + tw_beg (i, j) = rgrav * (qv (i, j) + q_liq (i) + q_sol (i)) * delp (i, j) * gsize (i, j) ** 2.0 + enddo + endif + ! ----------------------------------------------------------------------- ! fix negative cloud ice with snow ! ----------------------------------------------------------------------- @@ -240,15 +247,12 @@ subroutine fv_sat_adj (mdt, zvir, is, ie, js, je, ng, hydrostatic, consv_te, & ! ----------------------------------------------------------------------- do i = is, ie - if (qi (i, j) > 1.e-8 .and. pt1 (i) > tice) then - sink (i) = min (qi (i, j), fac_imlt * (pt1 (i) - tice) / icp2 (i)) + if (qi (i, j) > 1.e-8 .and. pt1 (i) > t_ice) then + sink (i) = min (qi (i, j), fac_imlt * (pt1 (i) - t_ice) / icp2 (i)) qi (i, j) = qi (i, j) - sink (i) - ! sjl, may 17, 2017 - ! tmp = min (sink (i), dim (ql_mlt, ql (i, j))) ! max ql amount - ! ql (i, j) = ql (i, j) + tmp - ! qr (i, j) = qr (i, j) + sink (i) - tmp - ! sjl, may 17, 2017 - ql (i, j) = ql (i, j) + sink (i) + tmp = min (sink (i), dim (ql_mlt, ql (i, j))) + ql (i, j) = ql (i, j) + tmp + qr (i, j) = qr (i, j) + sink (i) - tmp q_liq (i) = q_liq (i) + sink (i) q_sol (i) = q_sol (i) - sink (i) cvm (i) = mc_air (i) + qv (i, j) * c_vap + q_liq (i) * c_liq + q_sol (i) * c_ice @@ -280,8 +284,6 @@ subroutine fv_sat_adj (mdt, zvir, is, ie, js, je, ng, hydrostatic, consv_te, & endif enddo - ! after this point cloud ice & snow are positive definite - ! ----------------------------------------------------------------------- ! fix negative cloud water with rain or rain with available cloud water ! ----------------------------------------------------------------------- @@ -300,10 +302,11 @@ subroutine fv_sat_adj (mdt, zvir, is, ie, js, je, ng, hydrostatic, consv_te, & ! ----------------------------------------------------------------------- ! enforce complete freezing of cloud water to cloud ice below - 48 c + ! it can be - 50 c, straka, 2009 ! ----------------------------------------------------------------------- do i = is, ie - dtmp = tice - 48. - pt1 (i) + dtmp = t_ice - 48. - pt1 (i) if (ql (i, j) > 0. .and. dtmp > 0.) then sink (i) = min (ql (i, j), dtmp / icp2 (i)) ql (i, j) = ql (i, j) - sink (i) @@ -324,7 +327,7 @@ subroutine fv_sat_adj (mdt, zvir, is, ie, js, je, ng, hydrostatic, consv_te, & lhi (i) = li00 + dc_ice * pt1 (i) lcp2 (i) = lhl (i) / cvm (i) icp2 (i) = lhi (i) / cvm (i) - tcp3 (i) = lcp2 (i) + icp2 (i) * min (1., dim (tice, pt1 (i)) / 48.) + tcp3 (i) = lcp2 (i) + icp2 (i) * min (1., dim (t_ice, pt1 (i)) / 48.) enddo ! ----------------------------------------------------------------------- @@ -336,14 +339,15 @@ subroutine fv_sat_adj (mdt, zvir, is, ie, js, je, ng, hydrostatic, consv_te, & adj_fac = sat_adj0 do i = is, ie dq0 = (qv (i, j) - wqsat (i)) / (1. + tcp3 (i) * dq2dt (i)) - if (dq0 > 0.) then ! whole grid - box saturated + if (dq0 > 0.) then src (i) = min (adj_fac * dq0, max (ql_gen - ql (i, j), fac_v2l * dq0)) - else ! evaporation of ql - ! sjl 20170703 added ql factor to prevent the situation of high ql and rh < 1 - ! factor = - min (1., fac_l2v * sqrt (max (0., ql (i, j)) / 1.e-5) * 10. * (1. - qv (i, j) / wqsat (i))) + else + ! sjl, 20170703 + ! factor = - min (1., fac_l2v * sqrt (max (0., ql (i, j)) / 1.e-5) * & + ! 10. * (1. - qv (i, j) / wqsat (i))) ! factor = - fac_l2v ! factor = - 1 - factor = - min (1., fac_l2v * 10. * (1. - qv (i, j) / wqsat (i))) ! the rh dependent factor = 1 at 90% + factor = - min (1., fac_l2v * 10. * (1. - qv (i, j) / wqsat (i))) src (i) = - min (ql (i, j), factor * dq0) endif qv (i, j) = qv (i, j) - src (i) @@ -362,13 +366,13 @@ subroutine fv_sat_adj (mdt, zvir, is, ie, js, je, ng, hydrostatic, consv_te, & lhi (i) = li00 + dc_ice * pt1 (i) lcp2 (i) = lhl (i) / cvm (i) icp2 (i) = lhi (i) / cvm (i) - tcp3 (i) = lcp2 (i) + icp2 (i) * min (1., dim (tice, pt1 (i)) / 48.) + tcp3 (i) = lcp2 (i) + icp2 (i) * min (1., dim (t_ice, pt1 (i)) / 48.) enddo if (last_step) then ! ----------------------------------------------------------------------- - ! condensation / evaporation between water vapor and cloud water, last time step + ! condensation / evaporation between water vapor and cloud water at last time step ! enforce upper (no super_sat) & lower (critical rh) bounds ! final iteration: ! ----------------------------------------------------------------------- @@ -377,13 +381,15 @@ subroutine fv_sat_adj (mdt, zvir, is, ie, js, je, ng, hydrostatic, consv_te, & do i = is, ie dq0 = (qv (i, j) - wqsat (i)) / (1. + tcp3 (i) * dq2dt (i)) - if (dq0 > 0.) then ! remove super - saturation, prevent super saturation over water + if (dq0 > 0.) then src (i) = dq0 - else ! evaporation of ql - ! factor = - min (1., fac_l2v * sqrt (max (0., ql (i, j)) / 1.e-5) * 10. * (1. - qv (i, j) / wqsat (i))) ! the rh dependent factor = 1 at 90% + else + ! sjl, 20170703 + ! factor = - min (1., fac_l2v * sqrt (max (0., ql (i, j)) / 1.e-5) * & + ! 10. * (1. - qv (i, j) / wqsat (i))) ! factor = - fac_l2v ! factor = - 1 - factor = - min (1., fac_l2v * 10. * (1. - qv (i, j) / wqsat (i))) ! the rh dependent factor = 1 at 90% + factor = - min (1., fac_l2v * 10. * (1. - qv (i, j) / wqsat (i))) src (i) = - min (ql (i, j), factor * dq0) endif adj_fac = 1. @@ -408,11 +414,12 @@ subroutine fv_sat_adj (mdt, zvir, is, ie, js, je, ng, hydrostatic, consv_te, & endif ! ----------------------------------------------------------------------- - ! homogeneous freezing of cloud water to cloud ice + ! homogeneous freezing of cloud water to cloud ice, - 40 c to - 48 c + ! it can be - 50 c, straka, 2009 ! ----------------------------------------------------------------------- do i = is, ie - dtmp = t_wfr - pt1 (i) ! [ - 40, - 48] + dtmp = t_wfr - pt1 (i) if (ql (i, j) > 0. .and. dtmp > 0.) then sink (i) = min (ql (i, j), ql (i, j) * dtmp * 0.125, dtmp / icp2 (i)) ql (i, j) = ql (i, j) - sink (i) @@ -438,9 +445,9 @@ subroutine fv_sat_adj (mdt, zvir, is, ie, js, je, ng, hydrostatic, consv_te, & ! ----------------------------------------------------------------------- do i = is, ie - tc = tice0 - pt1 (i) + tc = t_ice - pt1 (i) if (ql (i, j) > 0.0 .and. tc > 0.) then - sink (i) = 3.3333e-10 * dt_bigg * (exp (0.66 * tc) - 1.) * den (i) * ql (i, j) ** 2 + sink (i) = 100. / (rhow * ccn (i)) * dt_bigg * (exp (0.66 * tc) - 1.) * ql (i, j) ** 2 sink (i) = min (ql (i, j), tc / icp2 (i), sink (i)) ql (i, j) = ql (i, j) - sink (i) qi (i, j) = qi (i, j) + sink (i) @@ -461,13 +468,13 @@ subroutine fv_sat_adj (mdt, zvir, is, ie, js, je, ng, hydrostatic, consv_te, & enddo ! ----------------------------------------------------------------------- - ! freezing of rain to graupel + ! freezing of rain to graupel, complete freezing below - 40 c ! ----------------------------------------------------------------------- do i = is, ie - dtmp = (tice - 0.1) - pt1 (i) + dtmp = (t_ice - 0.1) - pt1 (i) if (qr (i, j) > 1.e-7 .and. dtmp > 0.) then - tmp = min (1., (dtmp * 0.025) ** 2) * qr (i, j) ! no limit on freezing below - 40 deg c + tmp = min (1., (dtmp * 0.025) ** 2) * qr (i, j) sink (i) = min (tmp, fac_r2g * dtmp / icp2 (i)) qr (i, j) = qr (i, j) - sink (i) qg (i, j) = qg (i, j) + sink (i) @@ -488,18 +495,19 @@ subroutine fv_sat_adj (mdt, zvir, is, ie, js, je, ng, hydrostatic, consv_te, & enddo ! ----------------------------------------------------------------------- - ! melting of snow to rain or cloud water + ! melting of snow to rain or cloud water, complete melting above 10 c ! ----------------------------------------------------------------------- do i = is, ie - dtmp = pt1 (i) - (tice + 0.1) + dtmp = pt1 (i) - (t_ice + 0.1) if (qs (i, j) > 1.e-7 .and. dtmp > 0.) then - tmp = min (1., (dtmp * 0.1) ** 2) * qs (i, j) ! no limter on melting above 10 deg c + tmp = min (1., (dtmp * 0.1) ** 2) * qs (i, j) sink (i) = min (tmp, fac_smlt * dtmp / icp2 (i)) - tmp = min (sink (i), dim (qs_mlt, ql (i, j))) ! max ql due to snow melt + tmp = min (sink (i), dim (qs_mlt, ql (i, j))) qs (i, j) = qs (i, j) - sink (i) ql (i, j) = ql (i, j) + tmp qr (i, j) = qr (i, j) + sink (i) - tmp + ! ljz, 20190716 ! qr (i, j) = qr (i, j) + sink (i) q_liq (i) = q_liq (i) + sink (i) q_sol (i) = q_sol (i) - sink (i) @@ -525,8 +533,8 @@ subroutine fv_sat_adj (mdt, zvir, is, ie, js, je, ng, hydrostatic, consv_te, & ! ----------------------------------------------------------------------- do i = is, ie - lhi (i) = li00 + dc_ice * pt1 (i) lhl (i) = lv00 + d0_vap * pt1 (i) + lhi (i) = li00 + dc_ice * pt1 (i) lcp2 (i) = lhl (i) / cvm (i) icp2 (i) = lhi (i) / cvm (i) tcp2 (i) = lcp2 (i) + icp2 (i) @@ -538,20 +546,38 @@ subroutine fv_sat_adj (mdt, zvir, is, ie, js, je, ng, hydrostatic, consv_te, & do i = is, ie src (i) = 0. - if (pt1 (i) < t_sub) then ! too cold to be accurate; freeze qv as a fix + if (pt1 (i) < t_sub) then src (i) = dim (qv (i, j), 1.e-6) - elseif (pt1 (i) < tice0) then + elseif (pt1 (i) < t_ice) then qsi = iqs2 (pt1 (i), den (i), dqsdt) dq = qv (i, j) - qsi sink (i) = adj_fac * dq / (1. + tcp2 (i) * dqsdt) if (qi (i, j) > 1.e-8) then - pidep = sdt * dq * 349138.78 * exp (0.875 * log (qi (i, j) * den (i))) & + if (.not. prog_ccn) then + if (inflag .eq. 1) & + ! hong et al., 2004 + cin (i) = 5.38e7 * exp (0.75 * log (qi (i, j) * den (i))) + if (inflag .eq. 2) & + ! meyers et al., 1992 + cin (i) = exp (-2.80 + 0.262 * (t_ice - pt1 (i))) * 1000.0 ! convert from L^-1 to m^-3 + if (inflag .eq. 3) & + ! meyers et al., 1992 + cin (i) = exp (-0.639 + 12.96 * (qv (i, j) / qsi - 1.0)) * 1000.0 ! convert from L^-1 to m^-3 + if (inflag .eq. 4) & + ! cooper, 1986 + cin (i) = 5.e-3 * exp (0.304 * (t_ice - pt1 (i))) * 1000.0 ! convert from L^-1 to m^-3 + if (inflag .eq. 5) & + ! flecther, 1962 + cin (i) = 1.e-5 * exp (0.5 * (t_ice - pt1 (i))) * 1000.0 ! convert from L^-1 to m^-3 + endif + pidep = sdt * dq * 4.0 * 11.9 * exp (0.5 * log (qi (i, j) * den (i) * cin (i))) & / (qsi * den (i) * lat2 / (0.0243 * rvgas * pt1 (i) ** 2) + 4.42478e4) else pidep = 0. endif - if (dq > 0.) then ! vapor - > ice - tmp = tice - pt1 (i) + if (dq > 0.) then + tmp = t_ice - pt1 (i) + ! qi_crt = 4.92e-11 * exp (1.33 * log (1.e3 * exp (0.1 * tmp))) / den (i) qi_crt = qi_gen * min (qi_lim, 0.1 * tmp) / den (i) src (i) = min (sink (i), max (qi_crt - qi (i, j), pidep), tmp / tcp2 (i)) else @@ -566,22 +592,6 @@ subroutine fv_sat_adj (mdt, zvir, is, ie, js, je, ng, hydrostatic, consv_te, & pt1 (i) = pt1 (i) + src (i) * (lhl (i) + lhi (i)) / cvm (i) enddo - ! ----------------------------------------------------------------------- - ! virtual temp updated - ! ----------------------------------------------------------------------- - - do i = is, ie -#ifdef USE_COND - q_con (i, j) = q_liq (i) + q_sol (i) - tmp = 1. + zvir * qv (i, j) - pt (i, j) = pt1 (i) * tmp * (1. - q_con (i, j)) - tmp = rdgas * tmp - cappa (i, j) = tmp / (tmp + cvm (i)) -#else - pt (i, j) = pt1 (i) * (1. + zvir * qv (i, j)) -#endif - enddo - ! ----------------------------------------------------------------------- ! fix negative graupel with available cloud ice ! ----------------------------------------------------------------------- @@ -607,6 +617,34 @@ subroutine fv_sat_adj (mdt, zvir, is, ie, js, je, ng, hydrostatic, consv_te, & endif enddo + ! ----------------------------------------------------------------------- + ! total energy checker + ! ----------------------------------------------------------------------- + + if (consv_checker) then + do i = is, ie + te_end (i, j) = cvm (i) * pt1 (i) + lv00 * qv (i, j) - li00 * q_sol (i) + te_end (i, j) = rgrav * te_end (i, j) * delp (i, j) * gsize (i, j) ** 2.0 + tw_end (i, j) = rgrav * (qv (i, j) + q_liq (i) + q_sol (i)) * delp (i, j) * gsize (i, j) ** 2.0 + enddo + endif + + ! ----------------------------------------------------------------------- + ! update virtual temperature + ! ----------------------------------------------------------------------- + + do i = is, ie +#ifdef MOIST_CAPPA + q_con (i, j) = q_liq (i) + q_sol (i) + tmp = 1. + zvir * qv (i, j) + pt (i, j) = pt1 (i) * tmp * (1. - q_con (i, j)) + tmp = rdgas * tmp + cappa (i, j) = tmp / (tmp + cvm (i)) +#else + pt (i, j) = pt1 (i) * (1. + zvir * qv (i, j)) +#endif + enddo + if (out_dt) then do i = is, ie dtdt (i, j) = dtdt (i, j) + pt1 (i) - t0 (i) @@ -614,18 +652,18 @@ subroutine fv_sat_adj (mdt, zvir, is, ie, js, je, ng, hydrostatic, consv_te, & endif ! ----------------------------------------------------------------------- - ! fix energy conservation + ! for energy fixer ! ----------------------------------------------------------------------- if (consv_te) then do i = is, ie if (hydrostatic) then - te0 (i, j) = dp (i, j) * (te0 (i, j) + c_air * pt1 (i)) + te (i, j) = delp (i, j) * (te (i, j) + c_air * pt1 (i)) else -#ifdef USE_COND - te0 (i, j) = dp (i, j) * (te0 (i, j) + cvm (i) * pt1 (i)) +#ifdef MOIST_CAPPA + te (i, j) = delp (i, j) * (te (i, j) + cvm (i) * pt1 (i)) #else - te0 (i, j) = dp (i, j) * (te0 (i, j) + c_air * pt1 (i)) + te (i, j) = delp (i, j) * (te (i, j) + c_air * pt1 (i)) #endif endif enddo @@ -636,8 +674,8 @@ subroutine fv_sat_adj (mdt, zvir, is, ie, js, je, ng, hydrostatic, consv_te, & ! ----------------------------------------------------------------------- do i = is, ie - lhi (i) = li00 + dc_ice * pt1 (i) lhl (i) = lv00 + d0_vap * pt1 (i) + lhi (i) = li00 + dc_ice * pt1 (i) cvm (i) = mc_air (i) + (qv (i, j) + q_liq (i) + q_sol (i)) * c_vap lcp2 (i) = lhl (i) / cvm (i) icp2 (i) = lhi (i) / cvm (i) @@ -682,54 +720,52 @@ subroutine fv_sat_adj (mdt, zvir, is, ie, js, je, ng, hydrostatic, consv_te, & enddo ! ----------------------------------------------------------------------- - ! use the "liquid - frozen water temperature" (tin) to compute saturated specific humidity + ! use the "liquid - frozen water temperature" (tin) to compute saturated + ! specific humidity ! ----------------------------------------------------------------------- do i = is, ie - tin = pt1 (i) - (lcp2 (i) * q_cond (i) + icp2 (i) * q_sol (i)) ! minimum temperature - ! tin = pt1 (i) - ((lv00 + d0_vap * pt1 (i)) * q_cond (i) + & - ! (li00 + dc_ice * pt1 (i)) * q_sol (i)) / (mc_air (i) + qpz (i) * c_vap) + tin = pt1 (i) - (lcp2 (i) * q_cond (i) + icp2 (i) * q_sol (i)) ! ----------------------------------------------------------------------- - ! determine saturated specific humidity + ! compute saturated specific humidity ! ----------------------------------------------------------------------- if (tin <= t_wfr) then - ! ice phase: qstar (i) = iqs1 (tin, den (i)) - elseif (tin >= tice) then - ! liquid phase: + elseif (tin >= t_ice) then qstar (i) = wqs1 (tin, den (i)) else - ! mixed phase: qsi = iqs1 (tin, den (i)) qsw = wqs1 (tin, den (i)) if (q_cond (i) > 1.e-6) then rqi = q_sol (i) / q_cond (i) else - ! mostly liquid water clouds at initial cloud development stage - rqi = ((tice - tin) / (tice - t_wfr)) + rqi = ((t_ice - tin) / (t_ice - t_wfr)) endif qstar (i) = rqi * qsi + (1. - rqi) * qsw endif - ! higher than 10 m is considered "land" and will have higher subgrid variability + ! ----------------------------------------------------------------------- + ! compute sub - grid variability + ! ----------------------------------------------------------------------- + dw = dw_ocean + (dw_land - dw_ocean) * min (1., abs (hs (i, j)) / (10. * grav)) - ! "scale - aware" subgrid variability: 100 - km as the base - hvar (i) = min (0.2, max (0.01, dw * sqrt (sqrt (area (i, j)) / 100.e3))) + hvar (i) = min (0.2, max (0.01, dw * sqrt (gsize (i, j) / 100.e3))) ! ----------------------------------------------------------------------- ! partial cloudiness by pdf: - ! assuming subgrid linear distribution in horizontal; this is effectively a smoother for the - ! binary cloud scheme; qa = 0.5 if qstar (i) == qpz + ! assuming subgrid linear distribution in horizontal; + ! this is effectively a smoother for the binary cloud scheme; + ! qa = 0.5 if qstar == qpz; ! ----------------------------------------------------------------------- rh = qpz (i) / qstar (i) ! ----------------------------------------------------------------------- ! icloud_f = 0: bug - fxied - ! icloud_f = 1: old fvgfs gfdl) mp implementation + ! icloud_f = 1: old fvgfs gfdl_mp implementation ! icloud_f = 2: binary cloud scheme (0 / 1) ! ----------------------------------------------------------------------- @@ -754,12 +790,12 @@ subroutine fv_sat_adj (mdt, zvir, is, ie, js, je, ng, hydrostatic, consv_te, & if (icloud_f == 0) then qa (i, j) = (q_plus - qstar (i)) / (dq + dq) else - qa (i, j) = (q_plus - qstar (i)) / (2. * dq * (1. - q_cond (i))) + qa (i, j) = (q_plus - qstar (i)) / & + (2. * dq * (1. - q_cond (i))) endif else qa (i, j) = 0. endif - ! impose minimum cloudiness if substantial q_cond (i) exist if (q_cond (i) > 1.e-6) then qa (i, j) = max (cld_min, qa (i, j)) endif @@ -774,9 +810,26 @@ subroutine fv_sat_adj (mdt, zvir, is, ie, js, je, ng, hydrostatic, consv_te, & endif - enddo ! end j loop + enddo + + ! ----------------------------------------------------------------------- + ! total energy checker + ! ----------------------------------------------------------------------- + + if (consv_checker) then + if (abs (sum (te_end) - sum (te_beg)) / sum (te_beg) .gt. te_err) then + print *, "fast_sat_adj te: ", sum (te_beg) / sum (gsize ** 2.0), & + sum (te_end) / sum (gsize ** 2.0), & + (sum (te_end) - sum (te_beg)) / sum (te_beg) + endif + if (abs (sum (tw_end) - sum (tw_beg)) / sum (tw_beg) .gt. te_err) then + print *, "fast_sat_adj tw: ", sum (tw_beg) / sum (gsize ** 2.0), & + sum (tw_end) / sum (gsize ** 2.0), & + (sum (tw_end) - sum (tw_beg)) / sum (tw_beg) + endif + endif -end subroutine fv_sat_adj +end subroutine fast_sat_adj ! ======================================================================= ! compute the saturated specific humidity for table ii @@ -795,7 +848,7 @@ real function wqs1 (ta, den) integer :: it - tmin = tice - 160. + tmin = t_ice - 160. ap1 = 10. * dim (ta, tmin) + 1. ap1 = min (2621., ap1) it = ap1 @@ -821,7 +874,7 @@ real function iqs1 (ta, den) integer :: it - tmin = tice - 160. + tmin = t_ice - 160. ap1 = 10. * dim (ta, tmin) + 1. ap1 = min (2621., ap1) it = ap1 @@ -849,7 +902,7 @@ real function wqs2 (ta, den, dqdt) integer :: it - tmin = tice - 160. + tmin = t_ice - 160. ap1 = 10. * dim (ta, tmin) + 1. ap1 = min (2621., ap1) it = ap1 @@ -883,7 +936,7 @@ subroutine wqs2_vect (is, ie, ta, den, wqsat, dqdt) integer :: i, it - tmin = tice - 160. + tmin = t_ice - 160. do i = is, ie ap1 = 10. * dim (ta (i), tmin) + 1. @@ -893,7 +946,8 @@ subroutine wqs2_vect (is, ie, ta, den, wqsat, dqdt) wqsat (i) = es / (rvgas * ta (i) * den (i)) it = ap1 - 0.5 ! finite diff, del_t = 0.1: - dqdt (i) = 10. * (desw (it) + (ap1 - it) * (desw (it + 1) - desw (it))) / (rvgas * ta (i) * den (i)) + dqdt (i) = 10. * (desw (it) + (ap1 - it) * (desw (it + 1) - desw (it))) / & + (rvgas * ta (i) * den (i)) enddo end subroutine wqs2_vect @@ -917,7 +971,7 @@ real function iqs2 (ta, den, dqdt) integer :: it - tmin = tice - 160. + tmin = t_ice - 160. ap1 = 10. * dim (ta, tmin) + 1. ap1 = min (2621., ap1) it = ap1 @@ -934,20 +988,16 @@ end function iqs2 ! prepare saturation water vapor pressure tables ! ======================================================================= -subroutine qs_init (kmp) +subroutine qsmith_init implicit none - integer, intent (in) :: kmp - integer, parameter :: length = 2621 integer :: i if (mp_initialized) return - !if (is_master ()) write (*, *) 'top layer for gfdl_mp = ', kmp - ! generate es table (dt = 0.1 deg c) allocate (table (length)) @@ -969,7 +1019,7 @@ subroutine qs_init (kmp) mp_initialized = .true. -end subroutine qs_init +end subroutine qsmith_init ! ======================================================================= ! saturation water vapor pressure table i @@ -989,7 +1039,7 @@ subroutine qs_table (n) integer :: i - tmin = tice - 160. + tmin = t_ice - 160. ! ----------------------------------------------------------------------- ! compute es over ice between - 160 deg c and 0 deg c. @@ -997,9 +1047,9 @@ subroutine qs_table (n) do i = 1, 1600 tem = tmin + delt * real (i - 1) - fac0 = (tem - tice) / (tem * tice) + fac0 = (tem - t_ice) / (tem * t_ice) fac1 = fac0 * li2 - fac2 = (d2ice * log (tem / tice) + fac1) / rvgas + fac2 = (d2ice * log (tem / t_ice) + fac1) / rvgas table (i) = e00 * exp (fac2) enddo @@ -1009,9 +1059,9 @@ subroutine qs_table (n) do i = 1, 1221 tem = 253.16 + delt * real (i - 1) - fac0 = (tem - tice) / (tem * tice) + fac0 = (tem - t_ice) / (tem * t_ice) fac1 = fac0 * lv0 - fac2 = (dc_vap * log (tem / tice) + fac1) / rvgas + fac2 = (dc_vap * log (tem / t_ice) + fac1) / rvgas esh20 = e00 * exp (fac2) if (i <= 200) then esupc (i) = esh20 @@ -1026,7 +1076,7 @@ subroutine qs_table (n) do i = 1, 200 tem = 253.16 + delt * real (i - 1) - wice = 0.05 * (tice - tem) + wice = 0.05 * (t_ice - tem) wh2o = 0.05 * (tem - 253.16) table (i + 1400) = wice * table (i + 1400) + wh2o * esupc (i) enddo @@ -1049,7 +1099,7 @@ subroutine qs_tablew (n) integer :: i - tmin = tice - 160. + tmin = t_ice - 160. ! ----------------------------------------------------------------------- ! compute es over water @@ -1057,9 +1107,9 @@ subroutine qs_tablew (n) do i = 1, n tem = tmin + delt * real (i - 1) - fac0 = (tem - tice) / (tem * tice) + fac0 = (tem - t_ice) / (tem * t_ice) fac1 = fac0 * lv0 - fac2 = (dc_vap * log (tem / tice) + fac1) / rvgas + fac2 = (dc_vap * log (tem / t_ice) + fac1) / rvgas tablew (i) = e00 * exp (fac2) enddo @@ -1081,23 +1131,23 @@ subroutine qs_table2 (n) integer :: i, i0, i1 - tmin = tice - 160. + tmin = t_ice - 160. do i = 1, n tem0 = tmin + delt * real (i - 1) - fac0 = (tem0 - tice) / (tem0 * tice) + fac0 = (tem0 - t_ice) / (tem0 * t_ice) if (i <= 1600) then ! ----------------------------------------------------------------------- ! compute es over ice between - 160 deg c and 0 deg c. ! ----------------------------------------------------------------------- fac1 = fac0 * li2 - fac2 = (d2ice * log (tem0 / tice) + fac1) / rvgas + fac2 = (d2ice * log (tem0 / t_ice) + fac1) / rvgas else ! ----------------------------------------------------------------------- ! compute es over water between 0 deg c and 102 deg c. ! ----------------------------------------------------------------------- fac1 = fac0 * lv0 - fac2 = (dc_vap * log (tem0 / tice) + fac1) / rvgas + fac2 = (dc_vap * log (tem0 / t_ice) + fac1) / rvgas endif table2 (i) = e00 * exp (fac2) enddo @@ -1115,4 +1165,4 @@ subroutine qs_table2 (n) end subroutine qs_table2 -end module fv_cmp_mod +end module fast_sat_adj_mod diff --git a/model/fv_arrays.F90 b/model/fv_arrays.F90 index 39bd8b15f..8b1cb3b40 100644 --- a/model/fv_arrays.F90 +++ b/model/fv_arrays.F90 @@ -10,7 +10,7 @@ !* (at your option) any later version. !* !* The FV3 dynamical core is distributed in the hope that it will be -!* useful, but WITHOUT ANYWARRANTY; without even the implied warranty +!* useful, but WITHOUT ANY WARRANTY; without even the implied warranty !* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. !* See the GNU General Public License for more details. !* @@ -29,9 +29,12 @@ module fv_arrays_mod use horiz_interp_type_mod, only: horiz_interp_type use mpp_mod, only: mpp_broadcast use platform_mod, only: r8_kind + use constants_mod, only: cnst_radius => radius, cnst_omega => omega public integer, public, parameter :: R_GRID = r8_kind + real(kind=r8_kind), public :: radius = cnst_radius + real(kind=r8_kind), public :: omega = cnst_omega !Several 'auxiliary' structures are introduced here. These are for ! the internal use by certain modules, and although fv_atmos_type @@ -55,8 +58,6 @@ module fv_arrays_mod integer :: id_u_dt_sg, id_v_dt_sg, id_t_dt_sg, id_qv_dt_sg integer :: id_ws, id_te, id_amdt, id_mdt, id_divg, id_aam logical :: initialized = .false. - real sphum, liq_wat, ice_wat ! GFDL physics - real rainwat, snowwat, graupel real :: efx(max_step), efx_sum, efx_nest(max_step), efx_sum_nest, mtq(max_step), mtq_sum integer :: steps @@ -164,8 +165,11 @@ module fv_arrays_mod integer :: npx_g, npy_g, ntiles_g ! global domain real(kind=R_GRID) :: global_area - logical :: g_sum_initialized = .false. !< Not currently used but can be useful - logical:: sw_corner = .false., se_corner = .false., ne_corner = .false., nw_corner = .false. + logical :: g_sum_initialized = .false. !Not currently used but can be useful + logical:: sw_corner = .false. + logical:: se_corner = .false. + logical:: ne_corner = .false. + logical:: nw_corner = .false. real(kind=R_GRID) :: da_min, da_max, da_min_c, da_max_c @@ -187,7 +191,7 @@ module fv_arrays_mod !< cubed-sphere will be used. If 4, a doubly-periodic !< f-plane cartesian grid will be used. If 5, a user-defined !< orthogonal grid will be used. If -1, the grid is read - !< from INPUT/grid_spec.nc. Values 2, 3, 5, 6, and 7 are not + !< from INPUT/grid_spec.nc. Values 2, 3, 6, and 7 are not !< supported and will likely not run. The default value is 0. logical, pointer :: nested !< Whether this is a nested grid. .false. by default. @@ -224,6 +228,7 @@ module fv_arrays_mod ! !< 5: a user-defined orthogonal grid for stand alone regional model ! -> moved to grid_tools + !> Momentum (or KE) options: integer :: hord_mt = 10 !< Horizontal advection scheme for momentum fluxes. A !< complete list of kord options is given in the @@ -381,6 +386,9 @@ module fv_arrays_mod !< horizontal advection schemes are enabled, but is unnecessary and !< not recommended when using monotonic advection. The default is .false. logical :: use_old_omega = .true. + logical :: remap_te = .false. !< A developmental option, remap total energy based on abs(kord_tm) + !< if kord_tm=0 use GMAO Cubic, otherwise as + !< Tv remapping !> PG off centering: real :: beta = 0.0 !< Parameter specifying fraction of time-off-centering for backwards !< evaluation of the pressure gradient force. The default is 0.0, which @@ -394,7 +402,7 @@ module fv_arrays_mod !< the values of 'a_imp' and 'beta' should add to 1, so that the time-centering is !< consistent between the PGF and the nonhydrostatic solver. !< The proper range is 0 to 0.45. -#ifdef SW_DYNAMIC +#ifdef SW_DYNAMICS integer :: n_sponge = 0 !< Controls the number of layers at the upper boundary on !< which the 2Dx filter is applied. This does not control the sponge layer. !< The default value is 0. @@ -503,6 +511,7 @@ module fv_arrays_mod !----------------------------------------------------------------------------------------------- logical :: reset_eta = .false. + logical :: ignore_rst_cksum = .false. !< enfore (.false.) or override (.true.) data integrity restart checksums real :: p_fac = 0.05 !< Safety factor for minimum nonhydrostatic pressures, which !< will be limited so the full pressure is no less than p_fac !< times the hydrostatic pressure. This is only of concern in mid-top @@ -764,6 +773,7 @@ module fv_arrays_mod !< wave drag parameterization and for the land surface roughness than !< either computes internally. This has no effect on the representation of !< the terrain in the dynamics. + logical :: do_am4_remap = .false. !< Use AM4 vertical remapping operators !-------------------------------------------------------------------------------------- ! The following options are useful for NWP experiments using datasets on the lat-lon grid !-------------------------------------------------------------------------------------- @@ -781,6 +791,9 @@ module fv_arrays_mod !< horizontally-interpolated output from chgres. The default is .false. !< Additional options are available through external_ic_nml. logical :: hrrrv3_ic = .false. +! following are namelist parameters for Stochastic Energy Baskscatter +! dissipation estimate + logical :: do_diss_est = .false. !< compute and save dissipation estimate logical :: ecmwf_ic = .false. !< If external_ic = .true., reads initial conditions from ECMWF analyses. !< The default is .false. logical :: gfs_phil = .false. !< if .T., compute geopotential inside of GFS physics (not used?) @@ -875,23 +888,22 @@ module fv_arrays_mod real(kind=R_GRID) :: deglon_start = -30., deglon_stop = 30., & !< boundaries of latlon patch deglat_start = -30., deglat_stop = 30. - logical :: regional = .false. !< Default setting for the regional domain. - - integer :: bc_update_interval = 3 !< Default setting for interval (hours) between external regional BC data files. - - integer :: nrows_blend = 0 !< # of blending rows in the outer integration domain. - logical :: write_restart_with_bcs = .false. !< Default setting for using DA-updated BC files - logical :: regional_bcs_from_gsi = .false. !< Default setting for writing restart files with boundary rows - - !>Convenience pointers integer, pointer :: grid_number !f1p logical :: adj_mass_vmr = .false. !TER: This is to reproduce answers for verona patch. This default can be changed ! to .true. in the next city release if desired - !integer, pointer :: test_case - !real, pointer :: alpha + + logical :: w_limiter = .true. ! Fix excessive w - momentum conserving --- sjl + + ! options related to regional mode + logical :: regional = .false. !< Default setting for the regional domain. + integer :: bc_update_interval = 3 !< Default setting for interval (hours) between external regional BC data files. + integer :: nrows_blend = 0 !< # of blending rows in the outer integration domain. + logical :: write_restart_with_bcs = .false. !< Default setting for using DA-updated BC files + logical :: regional_bcs_from_gsi = .false. !< Default setting for writing restart files with boundary rows. + logical :: pass_full_omega_to_physics_in_non_hydrostatic_mode = .false. !< Default to passing local omega to physics in non-hydrostatic mode end type fv_flags_type @@ -1019,6 +1031,10 @@ module fv_arrays_mod real, _ALLOCATABLE :: prei(:,:) _NULL real, _ALLOCATABLE :: pres(:,:) _NULL real, _ALLOCATABLE :: preg(:,:) _NULL + real, _ALLOCATABLE :: cond(:,:) _NULL + real, _ALLOCATABLE :: dep(:,:) _NULL + real, _ALLOCATABLE :: reevap(:,:) _NULL + real, _ALLOCATABLE :: sub(:,:) _NULL real, _ALLOCATABLE :: qv_dt(:,:,:) real, _ALLOCATABLE :: ql_dt(:,:,:) @@ -1059,6 +1075,15 @@ module fv_arrays_mod end type nudge_diag_type + type sg_diag_type + + real, _ALLOCATABLE :: t_dt(:,:,:) + real, _ALLOCATABLE :: u_dt(:,:,:) + real, _ALLOCATABLE :: v_dt(:,:,:) + real, _ALLOCATABLE :: qv_dt(:,:,:) + + end type sg_diag_type + type coarse_restart_type real, _ALLOCATABLE :: u(:,:,:) @@ -1113,18 +1138,11 @@ module fv_arrays_mod end type fv_coarse_graining_type -!>@brief 'allocate_fv_nest_BC_type' is an interface to subroutines -!! that allocate the 'fv_nest_BC_type' structure that holds the nested-grid BCs. -!>@details The subroutines can pass the array bounds explicitly or not. -!! The bounds in Atm%bd are used for the non-explicit case. interface allocate_fv_nest_BC_type module procedure allocate_fv_nest_BC_type_3D module procedure allocate_fv_nest_BC_type_3D_Atm end interface -!>@brief 'deallocate_fv_nest_BC_type' is an interface to a subroutine -!! that deallocates the 'fv_nest_BC_type' structure that holds the nested-grid -!BCs. interface deallocate_fv_nest_BC_type module procedure deallocate_fv_nest_BC_type_3D end interface @@ -1216,11 +1234,12 @@ module fv_arrays_mod real, _ALLOCATABLE :: pkz (:,:,:) _NULL !< finite-volume mean pk ! For phys coupling: - real, _ALLOCATABLE :: u_srf(:,:) _NULL !< Surface u-wind - real, _ALLOCATABLE :: v_srf(:,:) _NULL !< Surface v-wind - real, _ALLOCATABLE :: sgh(:,:) _NULL !< Terrain standard deviation - real, _ALLOCATABLE :: oro(:,:) _NULL !< land fraction (1: all land; 0: all water) - real, _ALLOCATABLE :: ts(:,:) _NULL !< skin temperature (sst) from NCEP/GFS (K) -- tile + real, _ALLOCATABLE :: u_srf(:,:) _NULL ! Surface u-wind + real, _ALLOCATABLE :: v_srf(:,:) _NULL ! Surface v-wind + real, _ALLOCATABLE :: sgh(:,:) _NULL ! Terrain standard deviation + real, _ALLOCATABLE :: oro(:,:) _NULL ! land fraction (1: all land; 0: all water) + real, _ALLOCATABLE :: ts(:,:) _NULL ! skin temperature (sst) from NCEP/GFS (K) -- tile + real, _ALLOCATABLE :: ci(:,:) _NULL ! sea-ice fraction from external file ! For stochastic kinetic energy backscatter (SKEB) real, _ALLOCATABLE :: diss_est(:,:,:) _NULL !< dissipation estimate taken from 'heat_source' @@ -1228,9 +1247,10 @@ module fv_arrays_mod !----------------------------------------------------------------------- ! Others: !----------------------------------------------------------------------- - real, _ALLOCATABLE :: phis(:,:) _NULL !< Surface geopotential (g*Z_surf) - real, _ALLOCATABLE :: omga(:,:,:) _NULL !< Vertical pressure velocity (pa/s) - real, _ALLOCATABLE :: ua(:,:,:) _NULL !< (ua, va) are mostly used as the A grid winds + real, _ALLOCATABLE :: phis(:,:) _NULL ! Surface geopotential (g*Z_surf) + real, _ALLOCATABLE :: omga(:,:,:) _NULL ! Vertical pressure velocity (pa/s) + real, _ALLOCATABLE :: local_omga(:,:,:) _NULL ! Vertical pressure velocity (pa/s) + real, _ALLOCATABLE :: ua(:,:,:) _NULL ! (ua, va) are mostly used as the A grid winds real, _ALLOCATABLE :: va(:,:,:) _NULL real, _ALLOCATABLE :: uc(:,:,:) _NULL ! (uc, vc) are mostly used as the C grid winds real, _ALLOCATABLE :: vc(:,:,:) _NULL @@ -1261,6 +1281,7 @@ module fv_arrays_mod #if defined(SPMD) type(domain2D) :: domain_for_coupler !< domain used in coupled model with halo = 1. + type(domain2D) :: domain_for_read !< domain used for reads to increase performance when io_layout=(1,1) !global tile and tile_of_mosaic only have a meaning for the CURRENT pe integer :: num_contact, npes_per_tile, global_tile, tile_of_mosaic, npes_this_grid @@ -1286,7 +1307,7 @@ module fv_arrays_mod real :: ptop - type(fv_grid_type) :: gridstruct + type(fv_grid_type) :: gridstruct !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! @@ -1313,20 +1334,18 @@ module fv_arrays_mod !Hold on to coarse-grid global grid, so we don't have to waste processor time getting it again when starting to do grid nesting real(kind=R_GRID), allocatable, dimension(:,:,:,:) :: grid_global - integer :: atmos_axes(4) + integer :: atmos_axes(4) type(inline_mp_type) :: inline_mp type(phys_diag_type) :: phys_diag type(nudge_diag_type) :: nudge_diag + type(sg_diag_type) :: sg_diag + type(coarse_restart_type) :: coarse_restart type(fv_coarse_graining_type) :: coarse_graining - end type fv_atmos_type contains -!>@brief The subroutine 'allocate_fv_atmos_type' allocates the fv_atmos_type -!>@details It includes an option to define dummy grids that have scalar and -!! small arrays defined as null 3D arrays. subroutine allocate_fv_atmos_type(Atm, isd_in, ied_in, jsd_in, jed_in, is_in, ie_in, js_in, je_in, & npx_in, npy_in, npz_in, ndims_in, ntiles_in, ncnst_in, nq_in, dummy, alloc_2d, ngrids_in) @@ -1450,9 +1469,13 @@ subroutine allocate_fv_atmos_type(Atm, isd_in, ied_in, jsd_in, jed_in, is_in, ie endif ! Allocate others + allocate ( Atm%diss_est(isd:ied ,jsd:jed ,npz) ) allocate ( Atm%ts(is:ie,js:je) ) allocate ( Atm%phis(isd:ied ,jsd:jed ) ) allocate ( Atm%omga(isd:ied ,jsd:jed ,npz) ); Atm%omga=0. + if (.not. Atm%flagstruct%hydrostatic .and. .not. Atm%flagstruct%pass_full_omega_to_physics_in_non_hydrostatic_mode) then + allocate (Atm%local_omga(isd:ied,jsd:jed,npz)); Atm%local_omga = 0. + endif allocate ( Atm%ua(isd:ied ,jsd:jed ,npz) ) allocate ( Atm%va(isd:ied ,jsd:jed ,npz) ) allocate ( Atm%uc(isd:ied+1,jsd:jed ,npz) ) @@ -1470,6 +1493,10 @@ subroutine allocate_fv_atmos_type(Atm, isd_in, ied_in, jsd_in, jed_in, is_in, ie allocate ( Atm%inline_mp%prei(is:ie,js:je) ) allocate ( Atm%inline_mp%pres(is:ie,js:je) ) allocate ( Atm%inline_mp%preg(is:ie,js:je) ) + allocate ( Atm%inline_mp%cond(is:ie,js:je) ) + allocate ( Atm%inline_mp%dep(is:ie,js:je) ) + allocate ( Atm%inline_mp%reevap(is:ie,js:je) ) + allocate ( Atm%inline_mp%sub(is:ie,js:je) ) !-------------------------- ! Non-hydrostatic dynamics: @@ -1554,8 +1581,13 @@ subroutine allocate_fv_atmos_type(Atm, isd_in, ied_in, jsd_in, jed_in, is_in, ie Atm%inline_mp%prei(i,j) = real_big Atm%inline_mp%pres(i,j) = real_big Atm%inline_mp%preg(i,j) = real_big + Atm%inline_mp%cond(i,j) = real_big + Atm%inline_mp%dep(i,j) = real_big + Atm%inline_mp%reevap(i,j) = real_big + Atm%inline_mp%sub(i,j) = real_big Atm%ts(i,j) = 300. + Atm%phis(i,j) = real_big enddo enddo @@ -1788,6 +1820,7 @@ subroutine deallocate_fv_atmos_type(Atm) deallocate ( Atm%pk ) deallocate ( Atm%peln ) deallocate ( Atm%pkz ) + deallocate ( Atm%ts ) deallocate ( Atm%phis ) deallocate ( Atm%omga ) deallocate ( Atm%ua ) @@ -1800,11 +1833,16 @@ subroutine deallocate_fv_atmos_type(Atm) deallocate ( Atm%cy ) deallocate ( Atm%ak ) deallocate ( Atm%bk ) + deallocate ( Atm%diss_est ) deallocate ( Atm%inline_mp%prer ) deallocate ( Atm%inline_mp%prei ) deallocate ( Atm%inline_mp%pres ) deallocate ( Atm%inline_mp%preg ) + deallocate ( Atm%inline_mp%cond ) + deallocate ( Atm%inline_mp%dep ) + deallocate ( Atm%inline_mp%reevap ) + deallocate ( Atm%inline_mp%sub ) deallocate ( Atm%u_srf ) deallocate ( Atm%v_srf ) @@ -2118,3 +2156,4 @@ end subroutine deallocate_fv_nest_BC_type_3d end module fv_arrays_mod + diff --git a/model/fv_control.F90 b/model/fv_control.F90 index 9fed20fcc..2f2563226 100644 --- a/model/fv_control.F90 +++ b/model/fv_control.F90 @@ -10,7 +10,7 @@ !* (at your option) any later version. !* !* The FV3 dynamical core is distributed in the hope that it will be -!* useful, but WITHOUT ANYWARRANTY; without even the implied warranty +!* useful, but WITHOUT ANY WARRANTY; without even the implied warranty !* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. !* See the GNU General Public License for more details. !* @@ -18,7 +18,7 @@ !* License along with the FV3 dynamical core. !* If not, see . !*********************************************************************** -! $Id$ + ! !---------------- ! FV contro panel @@ -26,7 +26,8 @@ module fv_control_mod - use constants_mod, only: pi=>pi_8, kappa, radius, grav, rdgas + use constants_mod, only: pi=>pi_8, kappa, grav, rdgas + use fv_arrays_mod, only: radius ! scaled for small earth use field_manager_mod, only: MODEL_ATMOS use fms_mod, only: write_version_number, check_nml_error use fms2_io_mod, only: file_exists @@ -170,12 +171,14 @@ subroutine fv_control_init(Atm, dt_atmos, this_grid, grids_on_this_pe, p_split) logical , pointer :: convert_ke logical , pointer :: do_vort_damp logical , pointer :: use_old_omega + logical , pointer :: remap_te ! PG off centering: real , pointer :: beta integer , pointer :: n_sponge real , pointer :: d_ext integer , pointer :: nwat logical , pointer :: warm_start + logical , pointer :: inline_q real , pointer :: shift_fac logical , pointer :: do_schmidt, do_cube_transform @@ -184,6 +187,7 @@ subroutine fv_control_init(Atm, dt_atmos, this_grid, grids_on_this_pe, p_split) real(kind=R_GRID) , pointer :: target_lon logical , pointer :: reset_eta + logical , pointer :: ignore_rst_cksum real , pointer :: p_fac real , pointer :: a_imp integer , pointer :: n_split @@ -239,8 +243,6 @@ subroutine fv_control_init(Atm, dt_atmos, this_grid, grids_on_this_pe, p_split) logical , pointer :: adiabatic logical , pointer :: moist_phys logical , pointer :: do_Held_Suarez - logical , pointer :: do_reed_physics - logical , pointer :: reed_cond_only logical , pointer :: reproduce_sum logical , pointer :: adjust_dry_mass logical , pointer :: fv_debug @@ -248,14 +250,16 @@ subroutine fv_control_init(Atm, dt_atmos, this_grid, grids_on_this_pe, p_split) logical , pointer :: mountain logical , pointer :: remap_t logical , pointer :: z_tracer + logical , pointer :: w_limiter logical , pointer :: old_divg_damp logical , pointer :: fv_land + logical , pointer :: do_am4_remap logical , pointer :: nudge logical , pointer :: nudge_ic logical , pointer :: ncep_ic logical , pointer :: nggps_ic - logical , pointer :: hrrrv3_ic + logical , pointer :: hrrrv3_ic logical , pointer :: ecmwf_ic logical , pointer :: gfs_phil logical , pointer :: agrid_vel_rst @@ -288,8 +292,8 @@ subroutine fv_control_init(Atm, dt_atmos, this_grid, grids_on_this_pe, p_split) real(kind=R_GRID), pointer :: deglat logical, pointer :: nested, twowaynest - logical, pointer :: regional - integer, pointer :: bc_update_interval + logical, pointer :: regional, write_restart_with_bcs, regional_bcs_from_gsi + integer, pointer :: bc_update_interval, nrows_blend integer, pointer :: parent_tile, refinement, nestbctype, nestupdate, nsponge, ioffset, joffset real, pointer :: s_weight, update_blend @@ -300,6 +304,7 @@ subroutine fv_control_init(Atm, dt_atmos, this_grid, grids_on_this_pe, p_split) logical, pointer :: write_only_coarse_intermediate_restarts logical, pointer :: write_coarse_agrid_vel_rst logical, pointer :: write_coarse_dgrid_vel_rst + logical, pointer :: pass_full_omega_to_physics_in_non_hydrostatic_mode !!!!!!!!!! END POINTERS !!!!!!!!!!!!!!!!!!!!!!!!!!!! this_grid = -1 ! default @@ -383,7 +388,7 @@ subroutine fv_control_init(Atm, dt_atmos, this_grid, grids_on_this_pe, p_split) Atm(n)%nml_filename = 'input.nml' endif if (.not. file_exists(Atm(n)%nml_filename)) then - call mpp_error(FATAL, "Could not find nested grid namelist "//Atm(n)%nml_filename) + call mpp_error(FATAL, "Could not find namelist "//Atm(n)%nml_filename) endif enddo @@ -439,21 +444,10 @@ subroutine fv_control_init(Atm, dt_atmos, this_grid, grids_on_this_pe, p_split) call set_namelist_pointers(Atm(this_grid)) call fv_diag_init_gn(Atm(this_grid)) -#ifdef INTERNAL_FILE_NML - if (this_grid .gt. 1) then - write(Atm(this_grid)%nml_filename,'(A4, I2.2)') 'nest', this_grid - if (.not. file_exists('input_'//trim(Atm(this_grid)%nml_filename)//'.nml')) then - call mpp_error(FATAL, "Could not find nested grid namelist "//'input_'//trim(Atm(this_grid)%nml_filename)//'.nml') - endif - else - Atm(this_grid)%nml_filename = '' - endif - call read_input_nml(Atm(this_grid)%nml_filename) !re-reads into internal namelist -#endif + call read_input_nml(alt_input_nml_path=Atm(this_grid)%nml_filename) !re-reads into internal namelist call read_namelist_fv_grid_nml call read_namelist_fv_core_nml(Atm(this_grid)) ! do options processing here too? - call read_namelist_test_case_nml(Atm(this_grid)%nml_filename) - !TODO test_case_nml moved to test_cases + call read_namelist_test_case_nml call mpp_get_current_pelist(Atm(this_grid)%pelist, commID=commID) ! for commID call mp_start(commID,halo_update_type) @@ -473,6 +467,13 @@ subroutine fv_control_init(Atm, dt_atmos, this_grid, grids_on_this_pe, p_split) endif + + if (Atm(this_grid)%flagstruct%regional) then + if ( consv_te > 0.) then + call mpp_error(FATAL, 'The global energy fixer cannot be used on a regional grid. consv_te must be set to 0.') + end if + end if + !Now only one call to mpp_define_nest_domains for ALL nests ! set up nest_level, tile_fine, tile_coarse ! need number of tiles, npx, and npy on each grid @@ -537,7 +538,8 @@ subroutine fv_control_init(Atm, dt_atmos, this_grid, grids_on_this_pe, p_split) Atm(this_grid)%flagstruct%grid_type,Atm(this_grid)%neststruct%nested, & Atm(this_grid)%layout,Atm(this_grid)%io_layout,Atm(this_grid)%bd,Atm(this_grid)%tile_of_mosaic, & Atm(this_grid)%gridstruct%square_domain,Atm(this_grid)%npes_per_tile,Atm(this_grid)%domain, & - Atm(this_grid)%domain_for_coupler,Atm(this_grid)%num_contact,Atm(this_grid)%pelist) + Atm(this_grid)%domain_for_coupler,Atm(this_grid)%domain_for_read,Atm(this_grid)%num_contact, & + Atm(this_grid)%pelist) call broadcast_domains(Atm,Atm(this_grid)%pelist,size(Atm(this_grid)%pelist)) do n=1,ngrids tile_id = mpp_get_tile_id(Atm(n)%domain) @@ -647,7 +649,6 @@ subroutine fv_control_init(Atm, dt_atmos, this_grid, grids_on_this_pe, p_split) !Initialize restart call fv_restart_init() - contains subroutine set_namelist_pointers(Atm) @@ -665,6 +666,7 @@ subroutine set_namelist_pointers(Atm) hord_tm => Atm%flagstruct%hord_tm hord_dp => Atm%flagstruct%hord_dp kord_tm => Atm%flagstruct%kord_tm + remap_te => Atm%flagstruct%remap_te hord_tr => Atm%flagstruct%hord_tr kord_tr => Atm%flagstruct%kord_tr scale_z => Atm%flagstruct%scale_z @@ -711,7 +713,11 @@ subroutine set_namelist_pointers(Atm) target_lon => Atm%flagstruct%target_lon regional => Atm%flagstruct%regional bc_update_interval => Atm%flagstruct%bc_update_interval + nrows_blend => Atm%flagstruct%nrows_blend + write_restart_with_bcs => Atm%flagstruct%write_restart_with_bcs + regional_bcs_from_gsi => Atm%flagstruct%regional_bcs_from_gsi reset_eta => Atm%flagstruct%reset_eta + ignore_rst_cksum => Atm%flagstruct%ignore_rst_cksum p_fac => Atm%flagstruct%p_fac a_imp => Atm%flagstruct%a_imp n_split => Atm%flagstruct%n_split @@ -761,17 +767,17 @@ subroutine set_namelist_pointers(Atm) adiabatic => Atm%flagstruct%adiabatic moist_phys => Atm%flagstruct%moist_phys do_Held_Suarez => Atm%flagstruct%do_Held_Suarez - do_reed_physics => Atm%flagstruct%do_reed_physics - reed_cond_only => Atm%flagstruct%reed_cond_only reproduce_sum => Atm%flagstruct%reproduce_sum adjust_dry_mass => Atm%flagstruct%adjust_dry_mass fv_debug => Atm%flagstruct%fv_debug + w_limiter => Atm%flagstruct%w_limiter srf_init => Atm%flagstruct%srf_init mountain => Atm%flagstruct%mountain remap_t => Atm%flagstruct%remap_t z_tracer => Atm%flagstruct%z_tracer old_divg_damp => Atm%flagstruct%old_divg_damp fv_land => Atm%flagstruct%fv_land + do_am4_remap => Atm%flagstruct%do_am4_remap nudge => Atm%flagstruct%nudge nudge_ic => Atm%flagstruct%nudge_ic ncep_ic => Atm%flagstruct%ncep_ic @@ -830,6 +836,7 @@ subroutine set_namelist_pointers(Atm) write_only_coarse_intermediate_restarts => Atm%coarse_graining%write_only_coarse_intermediate_restarts write_coarse_agrid_vel_rst => Atm%coarse_graining%write_coarse_agrid_vel_rst write_coarse_dgrid_vel_rst => Atm%coarse_graining%write_coarse_dgrid_vel_rst + pass_full_omega_to_physics_in_non_hydrostatic_mode => Atm%flagstruct%pass_full_omega_to_physics_in_non_hydrostatic_mode end subroutine set_namelist_pointers @@ -900,12 +907,13 @@ subroutine read_namelist_fv_core_nml(Atm) use_logp, p_fac, a_imp, k_split, n_split, m_split, q_split, print_freq, write_3d_diags, & do_schmidt, do_cube_transform, & hord_mt, hord_vt, hord_tm, hord_dp, hord_tr, shift_fac, stretch_fac, target_lat, target_lon, & - kord_mt, kord_wz, kord_tm, kord_tr, fv_debug, fv_land, nudge, do_sat_adj, do_inline_mp, do_f3d, & + kord_mt, kord_wz, kord_tm, kord_tr, remap_te, fv_debug, fv_land, & + do_am4_remap, nudge, do_sat_adj, do_inline_mp, do_f3d, & external_ic, read_increment, ncep_ic, nggps_ic, hrrrv3_ic, ecmwf_ic, use_new_ncep, use_ncep_phy, fv_diag_ic, & external_eta, res_latlon_dynamics, res_latlon_tracers, scale_z, w_max, z_min, lim_fac, & dddmp, d2_bg, d4_bg, vtdm4, trdm2, d_ext, delt_max, beta, non_ortho, n_sponge, & warm_start, adjust_dry_mass, mountain, d_con, ke_bg, nord, nord_tr, convert_ke, use_old_omega, & - dry_mass, grid_type, do_Held_Suarez, do_reed_physics, reed_cond_only, & + dry_mass, grid_type, do_Held_Suarez, & consv_te, fill, filter_phys, fill_dp, fill_wz, fill_gfs, consv_am, RF_fast, & range_warn, dwind_2d, inline_q, z_tracer, reproduce_sum, adiabatic, do_vort_damp, no_dycore, & tau, tau_h2o, rf_cutoff, nf_omega, hydrostatic, fv_sg_adj, sg_cutoff, breed_vortex_inline, & @@ -916,12 +924,13 @@ subroutine read_namelist_fv_core_nml(Atm) phys_hydrostatic, use_hydro_pressure, make_hybrid_z, old_divg_damp, add_noise, & nested, twowaynest, nudge_qv, & nestbctype, nestupdate, nsponge, s_weight, & - check_negative, nudge_ic, halo_update_type, gfs_phil, agrid_vel_rst, & + check_negative, nudge_ic, halo_update_type, gfs_phil, agrid_vel_rst, & do_uni_zfull, adj_mass_vmr, update_blend, regional,& - bc_update_interval, write_coarse_restart_files,& - write_coarse_diagnostics,& + bc_update_interval, nrows_blend, write_restart_with_bcs, regional_bcs_from_gsi, & + w_limiter, write_coarse_restart_files, write_coarse_diagnostics,& write_only_coarse_intermediate_restarts, & - write_coarse_agrid_vel_rst, write_coarse_dgrid_vel_rst + write_coarse_agrid_vel_rst, write_coarse_dgrid_vel_rst, & + pass_full_omega_to_physics_in_non_hydrostatic_mode, ignore_rst_cksum ! Read FVCORE namelist @@ -1028,7 +1037,6 @@ subroutine read_namelist_fv_core_nml(Atm) 198 format(A,i2.2,A,i4.4,'x',i4.4,'x',i1.1,'-',f9.3) 199 format(A,i3.3) - !if (.not. (nested .or. regional)) alpha = alpha*pi !TODO for test_case_nml !allocate(Atm%neststruct%child_grids(size(Atm))) !TODO want to remove !Atm(N)%neststruct%child_grids = .false. diff --git a/model/fv_dynamics.F90 b/model/fv_dynamics.F90 index 8a36a96d7..597448129 100644 --- a/model/fv_dynamics.F90 +++ b/model/fv_dynamics.F90 @@ -10,7 +10,7 @@ !* (at your option) any later version. !* !* The FV3 dynamical core is distributed in the hope that it will be -!* useful, but WITHOUT ANYWARRANTY; without even the implied warranty +!* useful, but WITHOUT ANY WARRANTY; without even the implied warranty !* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. !* See the GNU General Public License for more details. !* @@ -18,8 +18,10 @@ !* License along with the FV3 dynamical core. !* If not, see . !*********************************************************************** + module fv_dynamics_mod - use constants_mod, only: grav, pi=>pi_8, radius, hlv, rdgas, omega, rvgas, cp_vapor + use constants_mod, only: grav, pi=>pi_8, hlv, rdgas, rvgas, cp_vapor + use fv_arrays_mod, only: radius, omega ! scaled for small earth use dyn_core_mod, only: dyn_core, del2_cubed, init_ijk_mem use fv_mapz_mod, only: compute_total_energy, Lagrangian_to_Eulerian, moist_cv, moist_cp use fv_tracer2d_mod, only: tracer_2d, tracer_2d_1L, tracer_2d_nested @@ -30,7 +32,7 @@ module fv_dynamics_mod use fv_mp_mod, only: start_group_halo_update, complete_group_halo_update use fv_timing_mod, only: timing_on, timing_off use diag_manager_mod, only: send_data - use fv_diagnostics_mod, only: fv_time, prt_mxm, range_check, prt_minmax + use fv_diagnostics_mod, only: fv_time, prt_mxm, range_check, prt_minmax, is_ideal_case use mpp_domains_mod, only: DGRID_NE, CGRID_NE, mpp_update_domains, domain2D use mpp_mod, only: mpp_pe use field_manager_mod, only: MODEL_ATMOS @@ -57,9 +59,8 @@ module fv_dynamics_mod real :: agrav -#ifdef HIWPP real, allocatable:: u00(:,:,:), v00(:,:,:) -#endif + private public :: fv_dynamics @@ -75,7 +76,7 @@ subroutine fv_dynamics(npx, npy, npz, nq_tot, ng, bdt, consv_te, fill, ps, pe, pk, peln, pkz, phis, q_con, omga, ua, va, uc, vc, & ak, bk, mfx, mfy, cx, cy, ze0, hybrid_z, & gridstruct, flagstruct, neststruct, idiag, bd, & - parent_grid, domain, inline_mp, time_total) + parent_grid, domain, inline_mp, diss_est, time_total) real, intent(IN) :: bdt ! Large time-step real, intent(IN) :: consv_te @@ -106,6 +107,7 @@ subroutine fv_dynamics(npx, npy, npz, nq_tot, ng, bdt, consv_te, fill, real, intent(inout) :: q( bd%isd:bd%ied ,bd%jsd:bd%jed ,npz, ncnst) ! specific humidity and constituents real, intent(inout) :: delz(bd%is:,bd%js:,1:) ! delta-height (m); non-hydrostatic only real, intent(inout) :: ze0(bd%is:, bd%js: ,1:) ! height at edges (m); non-hydrostatic + real, intent(inout) :: diss_est(bd%isd:bd%ied ,bd%jsd:bd%jed, npz) ! diffusion estimate for SKEB ! ze0 no longer used !----------------------------------------------------------------------- @@ -163,7 +165,7 @@ subroutine fv_dynamics(npx, npy, npz, nq_tot, ng, bdt, consv_te, fill, integer :: sphum, liq_wat = -999, ice_wat = -999 ! GFDL physics integer :: rainwat = -999, snowwat = -999, graupel = -999, cld_amt = -999 integer :: theta_d = -999 - logical used, last_step, do_omega + logical used, last_step integer, parameter :: max_packs=13 type(group_halo_update_type), save :: i_pack(max_packs) integer :: is, ie, js, je @@ -296,7 +298,7 @@ subroutine fv_dynamics(npx, npy, npz, nq_tot, ng, bdt, consv_te, fill, !$OMP private(cvm) do k=1,npz if ( flagstruct%moist_phys ) then - do j=js,je + do j=js,je #ifdef MOIST_CAPPA call moist_cv(is,ie,isd,ied,jsd,jed, npz, j, k, nwat, sphum, liq_wat, rainwat, & ice_wat, snowwat, graupel, q, q_con(is:ie,j,k), cvm) @@ -315,15 +317,26 @@ subroutine fv_dynamics(npx, npy, npz, nq_tot, ng, bdt, consv_te, fill, ! (1.-q(i,j,k,sphum))/delz(i,j,k)) ) #endif enddo - enddo + enddo else do j=js,je +#ifdef MOIST_CAPPA + call moist_cv(is,ie,isd,ied,jsd,jed, npz, j, k, nwat, sphum, liq_wat, rainwat, & + ice_wat, snowwat, graupel, q, q_con(is:ie,j,k), cvm) +#endif do i=is,ie + dp1(i,j,k) = zvir*q(i,j,k,sphum) +#ifdef MOIST_CAPPA + cappa(i,j,k) = rdgas/(rdgas + cvm(i)/(1.+dp1(i,j,k))) + pkz(i,j,k) = exp(cappa(i,j,k)*log(rdg*delp(i,j,k)*pt(i,j,k)* & + (1.+dp1(i,j,k))*(1.-q_con(i,j,k))/delz(i,j,k)) ) +#else dp1(i,j,k) = 0. pkz(i,j,k) = exp(kappa*log(rdg*delp(i,j,k)*pt(i,j,k)/delz(i,j,k))) +#endif enddo enddo - endif + endif enddo endif @@ -362,14 +375,14 @@ subroutine fv_dynamics(npx, npy, npz, nq_tot, ng, bdt, consv_te, fill, endif if( .not.flagstruct%RF_fast .and. flagstruct%tau > 0. ) then - if ( gridstruct%grid_type<4 .or. gridstruct%bounded_domain ) then + if ( gridstruct%grid_type<4 .or. gridstruct%bounded_domain .or. is_ideal_case ) then ! if ( flagstruct%RF_fast ) then ! call Ray_fast(abs(dt), npx, npy, npz, pfull, flagstruct%tau, u, v, w, & ! dp_ref, ptop, hydrostatic, flagstruct%rf_cutoff, bd) ! else call Rayleigh_Super(abs(bdt), npx, npy, npz, ks, pfull, phis, flagstruct%tau, u, v, w, pt, & ua, va, delz, gridstruct%agrid, cp_air, rdgas, ptop, hydrostatic, & - .not. gridstruct%bounded_domain, flagstruct%rf_cutoff, gridstruct, domain, bd) + .not. (gridstruct%bounded_domain .or. is_ideal_case), flagstruct%rf_cutoff, gridstruct, domain, bd) ! endif else call Rayleigh_Friction(abs(bdt), npx, npy, npz, ks, pfull, flagstruct%tau, u, v, w, pt, & @@ -377,30 +390,7 @@ subroutine fv_dynamics(npx, npy, npz, nq_tot, ng, bdt, consv_te, fill, endif endif -#endif - -#ifndef SW_DYNAMICS ! Convert pt to virtual potential temperature on the first timestep - if ( flagstruct%adiabatic .and. flagstruct%kord_tm>0 ) then - if ( .not.pt_initialized )then -!$OMP parallel do default(none) shared(theta_d,is,ie,js,je,npz,pt,pkz,q) - do k=1,npz - do j=js,je - do i=is,ie - pt(i,j,k) = pt(i,j,k)/pkz(i,j,k) - enddo - enddo - if ( theta_d>0 ) then - do j=js,je - do i=is,ie - q(i,j,k,theta_d) = pt(i,j,k) - enddo - enddo - endif - enddo - pt_initialized = .true. - endif - else !$OMP parallel do default(none) shared(is,ie,js,je,npz,pt,dp1,pkz,q_con) do k=1,npz do j=js,je @@ -413,8 +403,7 @@ subroutine fv_dynamics(npx, npy, npz, nq_tot, ng, bdt, consv_te, fill, enddo enddo enddo - endif -#endif +#endif !end ifdef SW_DYNAMICS last_step = .false. mdt = bdt / real(k_split) @@ -437,6 +426,21 @@ subroutine fv_dynamics(npx, npy, npz, nq_tot, ng, bdt, consv_te, fill, inline_mp%prei = 0.0 inline_mp%pres = 0.0 inline_mp%preg = 0.0 + inline_mp%cond = 0.0 + inline_mp%dep = 0.0 + inline_mp%reevap = 0.0 + inline_mp%sub = 0.0 + if (allocated(inline_mp%qv_dt)) inline_mp%qv_dt = 0.0 + if (allocated(inline_mp%ql_dt)) inline_mp%ql_dt = 0.0 + if (allocated(inline_mp%qi_dt)) inline_mp%qi_dt = 0.0 + if (allocated(inline_mp%liq_wat_dt)) inline_mp%liq_wat_dt = 0.0 + if (allocated(inline_mp%qr_dt)) inline_mp%qr_dt = 0.0 + if (allocated(inline_mp%ice_wat_dt)) inline_mp%ice_wat_dt = 0.0 + if (allocated(inline_mp%qg_dt)) inline_mp%qg_dt = 0.0 + if (allocated(inline_mp%qs_dt)) inline_mp%qs_dt = 0.0 + if (allocated(inline_mp%t_dt)) inline_mp%t_dt = 0.0 + if (allocated(inline_mp%u_dt)) inline_mp%u_dt = 0.0 + if (allocated(inline_mp%v_dt)) inline_mp%v_dt = 0.0 endif call timing_on('FV_DYN_LOOP') @@ -483,7 +487,7 @@ subroutine fv_dynamics(npx, npy, npz, nq_tot, ng, bdt, consv_te, fill, u, v, w, delz, pt, q, delp, pe, pk, phis, ws, omga, ptop, pfull, ua, va, & uc, vc, mfx, mfy, cx, cy, pkz, peln, q_con, ak, bk, ks, & gridstruct, flagstruct, neststruct, idiag, bd, & - domain, n_map==1, i_pack, last_step, time_total) + domain, n_map==1, i_pack, last_step, diss_est, time_total) call timing_off('DYN_CORE') @@ -555,20 +559,20 @@ subroutine fv_dynamics(npx, npy, npz, nq_tot, ng, bdt, consv_te, fill, if ( iq==cld_amt ) kord_tracer(iq) = 9 ! monotonic enddo - do_omega = hydrostatic .and. last_step call timing_on('Remapping') -#ifdef AVEC_TIMERS - call avec_timer_start(6) -#endif - if ( flagstruct%fv_debug ) then if (is_master()) write(*,'(A, I3, A1, I3)') 'before remap k_split ', n_map, '/', k_split call prt_mxm('T_ldyn', pt, is, ie, js, je, ng, npz, 1., gridstruct%area_64, domain) call prt_mxm('SPHUM_ldyn', q(isd,jsd,1,sphum ), is, ie, js, je, ng, npz, 1.,gridstruct%area_64, domain) + if ( liq_wat > 0 ) & call prt_mxm('liq_wat_ldyn', q(isd,jsd,1,liq_wat), is, ie, js, je, ng, npz, 1.,gridstruct%area_64, domain) + if ( rainwat > 0 ) & call prt_mxm('rainwat_ldyn', q(isd,jsd,1,rainwat), is, ie, js, je, ng, npz, 1.,gridstruct%area_64, domain) + if ( ice_wat > 0 ) & call prt_mxm('ice_wat_ldyn', q(isd,jsd,1,ice_wat), is, ie, js, je, ng, npz, 1.,gridstruct%area_64, domain) + if ( snowwat > 0 ) & call prt_mxm('snowwat_ldyn', q(isd,jsd,1,snowwat), is, ie, js, je, ng, npz, 1.,gridstruct%area_64, domain) + if ( graupel > 0 ) & call prt_mxm('graupel_ldyn', q(isd,jsd,1,graupel), is, ie, js, je, ng, npz, 1.,gridstruct%area_64, domain) #ifdef TEST_LMH @@ -587,33 +591,35 @@ subroutine fv_dynamics(npx, npy, npz, nq_tot, ng, bdt, consv_te, fill, #endif endif - call Lagrangian_to_Eulerian(last_step, consv_te, ps, pe, delp, & pkz, pk, mdt, bdt, npx, npy, npz, is,ie,js,je, isd,ied,jsd,jed, & nr, nwat, sphum, q_con, u, v, w, delz, pt, q, phis, & zvir, cp_air, akap, cappa, flagstruct%kord_mt, flagstruct%kord_wz, & - kord_tracer, flagstruct%kord_tm, peln, te_2d, & + kord_tracer, flagstruct%kord_tm, flagstruct%remap_te, peln, te_2d, & ng, ua, va, omga, dp1, ws, fill, reproduce_sum, & idiag%id_mdt>0, dtdt_m, ptop, ak, bk, pfull, gridstruct, domain, & - flagstruct%do_sat_adj, hydrostatic, flagstruct%phys_hydrostatic, & - hybrid_z, do_omega, & + flagstruct%do_sat_adj, hydrostatic, & + hybrid_z, & flagstruct%adiabatic, do_adiabatic_init, flagstruct%do_inline_mp, & inline_mp, flagstruct%c2l_ord, bd, flagstruct%fv_debug, & - flagstruct%moist_phys) + flagstruct%moist_phys, flagstruct%w_limiter, flagstruct%do_am4_remap) if ( flagstruct%fv_debug ) then if (is_master()) write(*,'(A, I3, A1, I3)') 'finished k_split ', n_map, '/', k_split call prt_mxm('T_dyn_a4', pt, is, ie, js, je, ng, npz, 1., gridstruct%area_64, domain) - if (sphum > 0) call prt_mxm('SPHUM_dyn', q(isd,jsd,1,sphum ), is, ie, js, je, ng, npz, 1.,gridstruct%area_64, domain) - if (liq_wat > 0) call prt_mxm('liq_wat_dyn', q(isd,jsd,1,liq_wat), is, ie, js, je, ng, npz, 1.,gridstruct%area_64, domain) - if (rainwat > 0) call prt_mxm('rainwat_dyn', q(isd,jsd,1,rainwat), is, ie, js, je, ng, npz, 1.,gridstruct%area_64, domain) - if (ice_wat > 0)call prt_mxm('ice_wat_dyn', q(isd,jsd,1,ice_wat), is, ie, js, je, ng, npz, 1.,gridstruct%area_64, domain) - if (snowwat > 0)call prt_mxm('snowwat_dyn', q(isd,jsd,1,snowwat), is, ie, js, je, ng, npz, 1.,gridstruct%area_64, domain) - if (graupel > 0) call prt_mxm('graupel_dyn', q(isd,jsd,1,graupel), is, ie, js, je, ng, npz, 1.,gridstruct%area_64, domain) + call prt_mxm('pkz', pkz, is, ie, js, je, 0, npz, 1., gridstruct%area_64, domain) + call prt_mxm('SPHUM_dyn', q(isd,jsd,1,sphum ), is, ie, js, je, ng, npz, 1.,gridstruct%area_64, domain) + if ( liq_wat > 0 ) & + call prt_mxm('liq_wat_dyn', q(isd,jsd,1,liq_wat), is, ie, js, je, ng, npz, 1.,gridstruct%area_64, domain) + if ( rainwat > 0 ) & + call prt_mxm('rainwat_dyn', q(isd,jsd,1,rainwat), is, ie, js, je, ng, npz, 1.,gridstruct%area_64, domain) + if ( ice_wat > 0 ) & + call prt_mxm('ice_wat_dyn', q(isd,jsd,1,ice_wat), is, ie, js, je, ng, npz, 1.,gridstruct%area_64, domain) + if ( snowwat > 0 ) & + call prt_mxm('snowwat_dyn', q(isd,jsd,1,snowwat), is, ie, js, je, ng, npz, 1.,gridstruct%area_64, domain) + if ( graupel > 0 ) & + call prt_mxm('graupel_dyn', q(isd,jsd,1,graupel), is, ie, js, je, ng, npz, 1.,gridstruct%area_64, domain) endif -#ifdef AVEC_TIMERS - call avec_timer_stop(6) -#endif call timing_off('Remapping') #ifdef MOIST_CAPPA if ( neststruct%nested .and. .not. last_step) then @@ -627,29 +633,19 @@ subroutine fv_dynamics(npx, npy, npz, nq_tot, ng, bdt, consv_te, fill, isd, ied, jsd, jed, npz, & is, ie, js, je, & isd, ied, jsd, jed, & - reg_bc_update_time ) + reg_bc_update_time,1 ) endif #endif - - if( last_step ) then - if( .not. hydrostatic ) then -!$OMP parallel do default(none) shared(is,ie,js,je,npz,omga,delp,delz,w) - do k=1,npz - do j=js,je - do i=is,ie - omga(i,j,k) = delp(i,j,k)/delz(i,j,k)*w(i,j,k) - enddo - enddo - enddo - endif !-------------------------- ! Filter omega for physics: !-------------------------- - if(flagstruct%nf_omega>0) & + if (last_step) then + if(flagstruct%nf_omega>0) then call del2_cubed(omga, 0.18*gridstruct%da_min, gridstruct, domain, npx, npy, npz, flagstruct%nf_omega, bd) + endif endif end if -#endif +#endif !endif SW_DYNAMICS enddo ! n_map loop ! Initialize rain, ice, snow and graupel precipitaiton @@ -658,6 +654,21 @@ subroutine fv_dynamics(npx, npy, npz, nq_tot, ng, bdt, consv_te, fill, inline_mp%prei = inline_mp%prei / k_split inline_mp%pres = inline_mp%pres / k_split inline_mp%preg = inline_mp%preg / k_split + inline_mp%cond = inline_mp%cond / k_split + inline_mp%dep = inline_mp%dep / k_split + inline_mp%reevap = inline_mp%reevap / k_split + inline_mp%sub = inline_mp%sub / k_split + if (allocated(inline_mp%qv_dt)) inline_mp%qv_dt = inline_mp%qv_dt / bdt + if (allocated(inline_mp%ql_dt)) inline_mp%ql_dt = inline_mp%ql_dt / bdt + if (allocated(inline_mp%qi_dt)) inline_mp%qi_dt = inline_mp%qi_dt / bdt + if (allocated(inline_mp%liq_wat_dt)) inline_mp%liq_wat_dt = inline_mp%liq_wat_dt / bdt + if (allocated(inline_mp%qr_dt)) inline_mp%qr_dt = inline_mp%qr_dt / bdt + if (allocated(inline_mp%ice_wat_dt)) inline_mp%ice_wat_dt = inline_mp%ice_wat_dt / bdt + if (allocated(inline_mp%qg_dt)) inline_mp%qg_dt = inline_mp%qg_dt / bdt + if (allocated(inline_mp%qs_dt)) inline_mp%qs_dt = inline_mp%qs_dt / bdt + if (allocated(inline_mp%t_dt)) inline_mp%t_dt = inline_mp%t_dt / bdt + if (allocated(inline_mp%u_dt)) inline_mp%u_dt = inline_mp%u_dt / bdt + if (allocated(inline_mp%v_dt)) inline_mp%v_dt = inline_mp%v_dt / bdt endif call timing_off('FV_DYN_LOOP') @@ -950,7 +961,7 @@ subroutine Rayleigh_Super(dt, npx, npy, npz, ks, pm, phis, tau, u, v, w, pt, & rcv = 1. / (cp - rg) if ( .not. RF_initialized ) then -#ifdef HIWPP + if ( is_ideal_case )then allocate ( u00(is:ie, js:je+1,npz) ) allocate ( v00(is:ie+1,js:je ,npz) ) !$OMP parallel do default(none) shared(is,ie,js,je,npz,u00,u,v00,v) @@ -966,30 +977,30 @@ subroutine Rayleigh_Super(dt, npx, npy, npz, ks, pm, phis, tau, u, v, w, pt, & enddo enddo enddo -#endif + endif #ifdef SMALL_EARTH_TEST ! changed!!! - tau0 = tau + tau0 = tau #else - tau0 = tau * sday + tau0 = tau * sday #endif - allocate( rf(npz) ) - rf(:) = 0. + allocate( rf(npz) ) + rf(:) = 0. - do k=1, ks+1 - if( is_master() ) write(6,*) k, 0.01*pm(k) - enddo - if( is_master() ) write(6,*) 'Rayleigh friction E-folding time (days):' - do k=1, npz - if ( pm(k) < rf_cutoff ) then - rf(k) = dt/tau0*sin(0.5*pi*log(rf_cutoff/pm(k))/log(rf_cutoff/ptop))**2 - if( is_master() ) write(6,*) k, 0.01*pm(k), dt/(rf(k)*sday) - kmax = k - else - exit - endif - enddo - RF_initialized = .true. - endif + do k=1, ks+1 + if( is_master() ) write(6,*) k, 0.01*pm(k) + enddo + if( is_master() ) write(6,*) 'Rayleigh friction E-folding time (days):' + do k=1, npz + if ( pm(k) < rf_cutoff ) then + rf(k) = dt/tau0*sin(0.5*pi*log(rf_cutoff/pm(k))/log(rf_cutoff/ptop))**2 + if( is_master() ) write(6,*) k, 0.01*pm(k), dt/(rf(k)*sday) + kmax = k + else + exit + endif + enddo + RF_initialized = .true. + endif call c2l_ord2(u, v, ua, va, gridstruct, npz, gridstruct%grid_type, bd, gridstruct%bounded_domain) @@ -1009,66 +1020,64 @@ subroutine Rayleigh_Super(dt, npx, npy, npz, ks, pm, phis, tau, u, v, w, pt, & call timing_off('COMM_TOTAL') !$OMP parallel do default(none) shared(is,ie,js,je,kmax,pm,rf_cutoff,w,rf,u,v, & -#ifdef HIWPP -!$OMP u00,v00, & -#endif +!$OMP u00,v00,is_ideal_case, & !$OMP conserve,hydrostatic,pt,ua,va,u2f,cp,rg,ptop,rcv) do k=1,kmax if ( pm(k) < rf_cutoff ) then -#ifdef HIWPP - if (.not. hydrostatic) then + if (is_ideal_case) then + if (.not. hydrostatic) then + do j=js,je + do i=is,ie + w(i,j,k) = w(i,j,k)/(1.+rf(k)) + enddo + enddo + endif + do j=js,je+1 + do i=is,ie + u(i,j,k) = (u(i,j,k)+rf(k)*u00(i,j,k))/(1.+rf(k)) + enddo + enddo do j=js,je + do i=is,ie+1 + v(i,j,k) = (v(i,j,k)+rf(k)*v00(i,j,k))/(1.+rf(k)) + enddo + enddo + else + ! Add heat so as to conserve TE + if ( conserve ) then + if ( hydrostatic ) then + do j=js,je + do i=is,ie + pt(i,j,k) = pt(i,j,k) + 0.5*(ua(i,j,k)**2+va(i,j,k)**2)*(1.-u2f(i,j,k)**2)/(cp-rg*ptop/pm(k)) + enddo + enddo + else + do j=js,je + do i=is,ie + pt(i,j,k) = pt(i,j,k) + 0.5*(ua(i,j,k)**2+va(i,j,k)**2+w(i,j,k)**2)*(1.-u2f(i,j,k)**2)*rcv + enddo + enddo + endif + endif + + do j=js,je+1 do i=is,ie - w(i,j,k) = w(i,j,k)/(1.+rf(k)) + u(i,j,k) = 0.5*(u2f(i,j-1,k)+u2f(i,j,k))*u(i,j,k) + enddo + enddo + do j=js,je + do i=is,ie+1 + v(i,j,k) = 0.5*(u2f(i-1,j,k)+u2f(i,j,k))*v(i,j,k) enddo enddo + if ( .not. hydrostatic ) then + do j=js,je + do i=is,ie + w(i,j,k) = u2f(i,j,k)*w(i,j,k) + enddo + enddo + endif endif - do j=js,je+1 - do i=is,ie - u(i,j,k) = (u(i,j,k)+rf(k)*u00(i,j,k))/(1.+rf(k)) - enddo - enddo - do j=js,je - do i=is,ie+1 - v(i,j,k) = (v(i,j,k)+rf(k)*v00(i,j,k))/(1.+rf(k)) - enddo - enddo -#else -! Add heat so as to conserve TE - if ( conserve ) then - if ( hydrostatic ) then - do j=js,je - do i=is,ie - pt(i,j,k) = pt(i,j,k) + 0.5*(ua(i,j,k)**2+va(i,j,k)**2)*(1.-u2f(i,j,k)**2)/(cp-rg*ptop/pm(k)) - enddo - enddo - else - do j=js,je - do i=is,ie - pt(i,j,k) = pt(i,j,k) + 0.5*(ua(i,j,k)**2+va(i,j,k)**2+w(i,j,k)**2)*(1.-u2f(i,j,k)**2)*rcv - enddo - enddo - endif - endif - - do j=js,je+1 - do i=is,ie - u(i,j,k) = 0.5*(u2f(i,j-1,k)+u2f(i,j,k))*u(i,j,k) - enddo - enddo - do j=js,je - do i=is,ie+1 - v(i,j,k) = 0.5*(u2f(i-1,j,k)+u2f(i,j,k))*v(i,j,k) - enddo - enddo - if ( .not. hydrostatic ) then - do j=js,je - do i=is,ie - w(i,j,k) = u2f(i,j,k)*w(i,j,k) - enddo - enddo - endif -#endif endif enddo @@ -1237,7 +1246,7 @@ subroutine compute_aam(npz, is, ie, js, je, isd, ied, jsd, jed, gridstruct, bd, call c2l_ord2(u, v, ua, va, gridstruct, npz, gridstruct%grid_type, bd, gridstruct%bounded_domain) -!$OMP parallel do default(none) shared(is,ie,js,je,npz,gridstruct,aam,m_fac,ps,ptop,delp,agrav,ua) & +!$OMP parallel do default(none) shared(is,ie,js,je,npz,gridstruct,aam,m_fac,ps,ptop,delp,agrav,ua,radius,omega) & !$OMP private(r1, r2, dm) do j=js,je do i=is,ie @@ -1261,3 +1270,4 @@ subroutine compute_aam(npz, is, ie, js, je, isd, ied, jsd, jed, gridstruct, bd, end subroutine compute_aam end module fv_dynamics_mod + diff --git a/model/fv_fill.F90 b/model/fv_fill.F90 index 5742e2961..edcdff6d3 100644 --- a/model/fv_fill.F90 +++ b/model/fv_fill.F90 @@ -10,7 +10,7 @@ !* (at your option) any later version. !* !* The FV3 dynamical core is distributed in the hope that it will be -!* useful, but WITHOUT ANYWARRANTY; without even the implied warranty +!* useful, but WITHOUT ANY WARRANTY; without even the implied warranty !* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. !* See the GNU General Public License for more details. !* @@ -18,6 +18,7 @@ !* License along with the FV3 dynamical core. !* If not, see . !*********************************************************************** + module fv_fill_mod use mpp_domains_mod, only: mpp_update_domains, domain2D diff --git a/model/fv_grid_utils.F90 b/model/fv_grid_utils.F90 index 6dabc26bb..602c30e07 100644 --- a/model/fv_grid_utils.F90 +++ b/model/fv_grid_utils.F90 @@ -10,7 +10,7 @@ !* (at your option) any later version. !* !* The FV3 dynamical core is distributed in the hope that it will be -!* useful, but WITHOUT ANYWARRANTY; without even the implied warranty +!* useful, but WITHOUT ANY WARRANTY; without even the implied warranty !* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. !* See the GNU General Public License for more details. !* @@ -18,10 +18,12 @@ !* License along with the FV3 dynamical core. !* If not, see . !*********************************************************************** + module fv_grid_utils_mod #include - use constants_mod, only: omega, pi=>pi_8, cnst_radius=>radius + use constants_mod, only: pi=>pi_8 + use fv_arrays_mod, only: radius, omega ! scaled for small earth use mpp_mod, only: FATAL, mpp_error, WARNING use external_sst_mod, only: i_sst, j_sst, sst_ncep, sst_anom use mpp_domains_mod, only: mpp_update_domains, DGRID_NE, mpp_global_sum @@ -50,8 +52,6 @@ module fv_grid_utils_mod real, parameter:: big_number=1.d8 real, parameter:: tiny_number=1.d-8 - real(kind=R_GRID) :: radius=cnst_radius - real, parameter:: ptop_min=1.d-8 public f_p @@ -485,14 +485,8 @@ subroutine grid_utils_init(Atm, npx, npy, npz, non_ortho, grid_type, c2l_order) call normalize_vect( ee2(1:3,i,j) ) ! symmetrical grid -#ifdef TEST_FP - tmp1 = inner_prod(ee1(1:3,i,j), ee2(1:3,i,j)) - cosa(i,j) = sign(min(1., abs(tmp1)), tmp1) - sina(i,j) = sqrt(max(0.,1. -cosa(i,j)**2)) -#else cosa(i,j) = 0.5*(cos_sg(i-1,j-1,8)+cos_sg(i,j,6)) sina(i,j) = 0.5*(sin_sg(i-1,j-1,8)+sin_sg(i,j,6)) -#endif enddo enddo @@ -582,56 +576,35 @@ subroutine grid_utils_init(Atm, npx, npy, npz, non_ortho, grid_type, c2l_order) sin_sg(i,0,4) = sin_sg(1,i,1) cos_sg(0,i,3) = cos_sg(i,1,2) cos_sg(i,0,4) = cos_sg(1,i,1) -!!! cos_sg(0,i,7) = cos_sg(i,1,6) -!!! cos_sg(0,i,8) = cos_sg(i,1,7) -!!! cos_sg(i,0,8) = cos_sg(1,i,9) -!!! cos_sg(i,0,9) = cos_sg(1,i,6) enddo -!!! cos_sg(0,0,8) = 0.5*(cos_sg(0,1,7)+cos_sg(1,0,9)) - endif if ( nw_corner ) then do i=npy,npy+2 sin_sg(0,i,3) = sin_sg(npy-i,npy-1,4) cos_sg(0,i,3) = cos_sg(npy-i,npy-1,4) -!!! cos_sg(0,i,7) = cos_sg(npy-i,npy-1,8) -!!! cos_sg(0,i,8) = cos_sg(npy-i,npy-1,9) enddo do i=0,-2,-1 sin_sg(i,npy,2) = sin_sg(1,npy-i,1) cos_sg(i,npy,2) = cos_sg(1,npy-i,1) -!!! cos_sg(i,npy,6) = cos_sg(1,npy-i,9) -!!! cos_sg(i,npy,7) = cos_sg(1,npy-i,6) enddo -!!! cos_sg(0,npy,7) = 0.5*(cos_sg(1,npy,6)+cos_sg(0,npy-1,8)) endif if ( se_corner ) then do j=0,-2,-1 sin_sg(npx,j,1) = sin_sg(npx-j,1,2) cos_sg(npx,j,1) = cos_sg(npx-j,1,2) -!!! cos_sg(npx,j,6) = cos_sg(npx-j,1,7) -!!! cos_sg(npx,j,9) = cos_sg(npx-j,1,6) enddo do i=npx,npx+2 sin_sg(i,0,4) = sin_sg(npx-1,npx-i,3) cos_sg(i,0,4) = cos_sg(npx-1,npx-i,3) -!!! cos_sg(i,0,9) = cos_sg(npx-1,npx-i,8) -!!! cos_sg(i,0,8) = cos_sg(npx-1,npx-i,7) enddo -!!! cos_sg(npx,0,9) = 0.5*(cos_sg(npx,1,6)+cos_sg(npx-1,0,8)) endif if ( ne_corner ) then do i=0,2 sin_sg(npx,npy+i,1) = sin_sg(npx+i,npy-1,4) sin_sg(npx+i,npy,2) = sin_sg(npx-1,npy+i,3) cos_sg(npx,npy+i,1) = cos_sg(npx+i,npy-1,4) -!!! cos_sg(npx,npy+i,6) = cos_sg(npx+i,npy-1,9) -!!! cos_sg(npx,npy+i,9) = cos_sg(npx+i,npy-1,8) cos_sg(npx+i,npy,2) = cos_sg(npx-1,npy+i,3) -!!! cos_sg(npx+i,npy,6) = cos_sg(npx-1,npy+i,7) -!!! cos_sg(npx+i,npy,7) = cos_sg(npx-1,npy+i,8) end do -!!! cos_sg(npx,npy,6) = 0.5*(cos_sg(npx-1,npy,7)+cos_sg(npx,npy-1,9)) endif else @@ -650,42 +623,6 @@ subroutine grid_utils_init(Atm, npx, npy, npz, non_ortho, grid_type, c2l_order) if ( grid_type < 3 ) then -#ifdef USE_NORM_VECT -!------------------------------------------------------------- -! Make normal vect at face edges after consines are computed: -!------------------------------------------------------------- -! for old d2a2c_vect routines - if (.not. Atm%gridstruct%bounded_domain) then - do j=js-1,je+1 - if ( is==1 ) then - i=1 - call vect_cross(ew(1,i,j,1), grid3(1,i,j+1), grid3(1,i,j)) - call normalize_vect( ew(1,i,j,1) ) - endif - if ( (ie+1)==npx ) then - i=npx - call vect_cross(ew(1,i,j,1), grid3(1,i,j+1), grid3(1,i,j)) - call normalize_vect( ew(1,i,j,1) ) - endif - enddo - - if ( js==1 ) then - j=1 - do i=is-1,ie+1 - call vect_cross(es(1,i,j,2), grid3(1,i,j),grid3(1,i+1,j)) - call normalize_vect( es(1,i,j,2) ) - enddo - endif - if ( (je+1)==npy ) then - j=npy - do i=is-1,ie+1 - call vect_cross(es(1,i,j,2), grid3(1,i,j),grid3(1,i+1,j)) - call normalize_vect( es(1,i,j,2) ) - enddo - endif - endif -#endif - ! For omega computation: ! Unit vectors: do j=js,je+1 @@ -741,7 +678,7 @@ subroutine grid_utils_init(Atm, npx, npy, npz, non_ortho, grid_type, c2l_order) call global_mx_c(area_c(is:ie,js:je), is, ie, js, je, Atm%gridstruct%da_min_c, Atm%gridstruct%da_max_c) - if( is_master() ) write(*,*) 'da_max_c/da_min_c=', Atm%gridstruct%da_max_c/Atm%gridstruct%da_min_c + if( is_master() ) write(*,*) 'da_max_c, da_min_c, da_max_c/da_min_c=', Atm%gridstruct%da_max_c, Atm%gridstruct%da_min_c, Atm%gridstruct%da_max_c/Atm%gridstruct%da_min_c !------------------------------------------------ ! Initialization for interpolation at face edges @@ -1815,14 +1752,6 @@ subroutine get_center_vect( npx, npy, pp, u1, u2, bd ) u1(1:3,i,j) = 0.d0 u2(1:3,i,j) = 0.d0 else -#ifdef OLD_VECT - do k=1,3 - u1(k,i,j) = pp(k,i+1,j)+pp(k,i+1,j+1) - pp(k,i,j)-pp(k,i,j+1) - u2(k,i,j) = pp(k,i,j+1)+pp(k,i+1,j+1) - pp(k,i,j)-pp(k,i+1,j) - enddo - call normalize_vect( u1(1,i,j) ) - call normalize_vect( u2(1,i,j) ) -#else call cell_center3(pp(1,i,j), pp(1,i+1,j), pp(1,i,j+1), pp(1,i+1,j+1), pc) ! e1: call mid_pt3_cart(pp(1,i,j), pp(1,i,j+1), p1) @@ -1836,7 +1765,6 @@ subroutine get_center_vect( npx, npy, pp, u1, u2, bd ) call vect_cross(p3, p2, p1) call vect_cross(u2(1,i,j), pc, p3) call normalize_vect( u2(1,i,j) ) -#endif endif enddo enddo @@ -3205,11 +3133,6 @@ subroutine make_eta_level(km, pe, area, kks, ak, bk, ptop, domain, bd) if ( is_master() ) then write(*,*) 'Make_eta_level ...., ptop=', ptop -#ifdef PRINT_GRID - do k=1,km+1 - write(*,*) ph(k), ak(k), bk(k) - enddo -#endif endif deallocate ( pem ) diff --git a/model/fv_mapz.F90 b/model/fv_mapz.F90 index e89b48d4d..38d6e1b91 100644 --- a/model/fv_mapz.F90 +++ b/model/fv_mapz.F90 @@ -33,7 +33,7 @@ module fv_mapz_mod use fv_arrays_mod, only: fv_grid_type, fv_grid_bounds_type, R_GRID, inline_mp_type use fv_timing_mod, only: timing_on, timing_off use fv_mp_mod, only: is_master, mp_reduce_min, mp_reduce_max - use fv_cmp_mod, only: qs_init, fv_sat_adj + use fast_sat_adj_mod, only: fast_sat_adj, qsmith_init implicit none real, parameter:: consv_min = 0.001 ! below which no correction applies @@ -63,14 +63,16 @@ module fv_mapz_mod subroutine Lagrangian_to_Eulerian(last_step, consv, ps, pe, delp, pkz, pk, & mdt, pdt, npx, npy, km, is,ie,js,je, isd,ied,jsd,jed, & nq, nwat, sphum, q_con, u, v, w, delz, pt, q, hs, r_vir, cp, & - akap, cappa, kord_mt, kord_wz, kord_tr, kord_tm, peln, te0_2d, & + akap, cappa, kord_mt, kord_wz, kord_tr, kord_tm, remap_te, peln, te0_2d, & ng, ua, va, omga, te, ws, fill, reproduce_sum, out_dt, dtdt, & ptop, ak, bk, pfull, gridstruct, domain, do_sat_adj, & - hydrostatic, phys_hydrostatic, hybrid_z, do_omega, adiabatic, do_adiabatic_init, & + hydrostatic, hybrid_z, adiabatic, do_adiabatic_init, & do_inline_mp, inline_mp, c2l_ord, bd, fv_debug, & - moist_phys) + moist_phys, dum_w_limiter, do_am4_remap) logical, intent(in):: last_step logical, intent(in):: fv_debug + logical, intent(in):: dum_w_limiter + logical, intent(in):: do_am4_remap real, intent(in):: mdt ! remap time step real, intent(in):: pdt ! phys time step integer, intent(in):: npx, npy @@ -99,7 +101,8 @@ subroutine Lagrangian_to_Eulerian(last_step, consv, ps, pe, delp, pkz, pk, & logical, intent(in):: do_inline_mp logical, intent(in):: fill ! fill negative tracers logical, intent(in):: reproduce_sum - logical, intent(in):: do_omega, adiabatic, do_adiabatic_init + logical, intent(in):: adiabatic, do_adiabatic_init + logical, intent(in):: remap_te real, intent(in) :: ptop real, intent(in) :: ak(km+1) real, intent(in) :: bk(km+1) @@ -123,10 +126,10 @@ subroutine Lagrangian_to_Eulerian(last_step, consv, ps, pe, delp, pkz, pk, & ! as input; output: temperature real, intent(inout), dimension(isd:,jsd:,1:)::q_con, cappa real, intent(inout), dimension(is:,js:,1:)::delz - logical, intent(in):: hydrostatic, phys_hydrostatic + logical, intent(in):: hydrostatic logical, intent(in):: hybrid_z logical, intent(in):: out_dt - logical, intent(in):: moist_phys + logical, intent(in):: moist_phys !not used --- lmh 13 may 21 real, intent(inout):: ua(isd:ied,jsd:jed,km) ! u-wind (m/s) on physics grid real, intent(inout):: va(isd:ied,jsd:jed,km) ! v-wind (m/s) on physics grid @@ -144,6 +147,7 @@ subroutine Lagrangian_to_Eulerian(last_step, consv, ps, pe, delp, pkz, pk, & ! SJL 03.11.04: Initial version for partial remapping ! !----------------------------------------------------------------------- + real, allocatable, dimension(:,:) :: dz real, allocatable, dimension(:,:,:) :: dp0, u0, v0 real, allocatable, dimension(:,:,:) :: u_dt, v_dt real, dimension(is:ie,js:je):: te_2d, zsum0, zsum1, dpln @@ -152,6 +156,7 @@ subroutine Lagrangian_to_Eulerian(last_step, consv, ps, pe, delp, pkz, pk, & real, dimension(isd:ied,jsd:jed,km):: pe4 real, dimension(is:ie+1,km+1):: pe0, pe3 real, dimension(is:ie):: gsize, gz, cvm, qv + real, dimension(isd:ied,jsd:jed,km):: qnl, qni real rcp, rg, rrg, bkh, dtmp, k1k logical:: fast_mp_consv @@ -178,7 +183,7 @@ subroutine Lagrangian_to_Eulerian(last_step, consv, ps, pe, delp, pkz, pk, & kmp = k if ( pfull(k) > 10.E2 ) exit enddo - call qs_init(kmp) + call qsmith_init endif !$OMP parallel do default(none) shared(is,ie,js,je,km,pe,ptop,kord_tm,hydrostatic, & @@ -186,7 +191,7 @@ subroutine Lagrangian_to_Eulerian(last_step, consv, ps, pe, delp, pkz, pk, & !$OMP graupel,q_con,sphum,cappa,r_vir,rcp,k1k,delp, & !$OMP delz,akap,pkz,te,u,v,ps, gridstruct, last_step, & !$OMP ak,bk,nq,isd,ied,jsd,jed,kord_tr,fill, adiabatic, & -!$OMP hs,w,ws,kord_wz,do_omega,omga,rrg,kord_mt,pe4) & +!$OMP hs,w,ws,kord_wz,omga,rrg,kord_mt,pe4) & !$OMP private(qv,gz,cvm,kp,k_next,bkh,dp2, & !$OMP pe0,pe1,pe2,pe3,pk1,pk2,pn2,phis,q2,w2) do 1000 j=js,je+1 @@ -366,8 +371,8 @@ subroutine Lagrangian_to_Eulerian(last_step, consv, ps, pe, delp, pkz, pk, & enddo !---------------- - if ( do_omega ) then -! Start do_omega + if ( last_step ) then +! Start last_step ! Copy omega field to pe3 do i=is,ie pe3(i,1) = 0. @@ -430,7 +435,7 @@ subroutine Lagrangian_to_Eulerian(last_step, consv, ps, pe, delp, pkz, pk, & endif ! Interpolate omega/pe3 (defined at pe0) to remapped cell center (dp2) - if ( do_omega ) then + if ( last_step ) then do k=1,km do i=is,ie dp2(i,k) = 0.5*(peln(i,k,j) + peln(i,k+1,j)) @@ -450,7 +455,7 @@ subroutine Lagrangian_to_Eulerian(last_step, consv, ps, pe, delp, pkz, pk, & enddo enddo enddo - endif ! end do_omega + endif ! end last_step endif !(j < je+1) @@ -517,7 +522,7 @@ subroutine Lagrangian_to_Eulerian(last_step, consv, ps, pe, delp, pkz, pk, & !$OMP fast_mp_consv,kord_tm,pe4, & !$OMP npx,npy,ccn_cm3,u_dt,v_dt, & !$OMP c2l_ord,bd,dp0,ps) & -!$OMP private(q2,pe0,pe1,pe2,pe3,qv,cvm,gz,gsize,phis,dpln,dp2,t0) +!$OMP private(q2,pe0,pe1,pe2,pe3,qv,cvm,gz,gsize,phis,dpln,dp2,t0,qnl,qni,dz) !$OMP do do k=2,km @@ -660,12 +665,24 @@ subroutine Lagrangian_to_Eulerian(last_step, consv, ps, pe, delp, pkz, pk, & dpln(i,j) = peln(i,k+1,j) - peln(i,k,j) enddo enddo - call fv_sat_adj(abs(mdt), r_vir, is, ie, js, je, ng, hydrostatic, fast_mp_consv, & + call fast_sat_adj(abs(mdt), is, ie, js, je, ng, hydrostatic, fast_mp_consv, & te(isd,jsd,k), q(isd,jsd,k,sphum), q(isd,jsd,k,liq_wat), & q(isd,jsd,k,ice_wat), q(isd,jsd,k,rainwat), & - q(isd,jsd,k,snowwat), q(isd,jsd,k,graupel), & - hs, dpln, delz(is:ie,js:je,k), pt(isd,jsd,k), delp(isd,jsd,k), q_con(isd:,jsd:,k), & - cappa(isd:,jsd:,k), gridstruct%area_64, dtdt(is,js,k), out_dt, last_step, cld_amt>0, q(isd,jsd,k,cld_amt)) + q(isd,jsd,k,snowwat), q(isd,jsd,k,graupel), q(isd,jsd,k,cld_amt), & + qnl(isd,jsd,k), qni(isd,jsd,k), hs ,dpln, dz(is:ie,js:je), & + pt(isd,jsd,k), delp(isd,jsd,k), & +#ifdef USE_COND + q_con(isd:,jsd:,k), & +#else + q_con(isd:,jsd:,1), & +#endif +#ifdef MOIST_CAPPA + cappa(isd:,jsd:,k), & +#else + cappa(isd:,jsd:,1), & +#endif + sqrt(gridstruct%area_64(is:ie,js:je)), & + dtdt(is,js,k), out_dt, last_step) if ( .not. hydrostatic ) then do j=js,je do i=is,ie @@ -3009,11 +3026,12 @@ end subroutine rst_remap - subroutine mappm(km, pe1, q1, kn, pe2, q2, i1, i2, iv, kord, ptop) + subroutine mappm(km, pe1, q1, kn, pe2, q2, i1, i2, iv, kord) ! IV = 0: constituents ! IV = 1: potential temp ! IV =-1: winds +! IV =-2: vertical velocity ! Mass flux preserving mapping: q1(im,km) -> q2(im,kn) @@ -3024,9 +3042,8 @@ subroutine mappm(km, pe1, q1, kn, pe2, q2, i1, i2, iv, kord, ptop) integer, intent(in):: i1, i2, km, kn, kord, iv real, intent(in ):: pe1(i1:i2,km+1), pe2(i1:i2,kn+1) - real, intent(in ):: q1(i1:i2,km) - real, intent(out):: q2(i1:i2,kn) - real, intent(IN) :: ptop + real, intent(in ):: q1(i1:i2,km) ! input field + real, intent(out):: q2(i1:i2,kn) ! output field ! local real qs(i1:i2) real dp1(i1:i2,km) @@ -3048,17 +3065,6 @@ subroutine mappm(km, pe1, q1, kn, pe2, q2, i1, i2, iv, kord, ptop) call ppm_profile( a4, dp1, km, i1, i2, iv, kord ) endif -!------------------------------------ -! Lowest layer: constant distribution -!------------------------------------ -#ifdef NGGPS_SUBMITTED - do i=i1,i2 - a4(2,i,km) = q1(i,km) - a4(3,i,km) = q1(i,km) - a4(4,i,km) = 0. - enddo -#endif - do 5555 i=i1,i2 k0 = 1 do 555 k=1,kn @@ -3068,11 +3074,7 @@ subroutine mappm(km, pe1, q1, kn, pe2, q2, i1, i2, iv, kord, ptop) q2(i,k) = q1(i,1) elseif(pe2(i,k) .ge. pe1(i,km+1)) then ! Entire grid below old ps -#ifdef NGGPS_SUBMITTED - q2(i,k) = a4(3,i,km) ! this is not good. -#else q2(i,k) = q1(i,km) -#endif else do 45 L=k0,km @@ -3123,11 +3125,7 @@ subroutine mappm(km, pe1, q1, kn, pe2, q2, i1, i2, iv, kord, ptop) delp = pe2(i,k+1) - pe1(i,km+1) if(delp > 0.) then ! Extended below old ps -#ifdef NGGPS_SUBMITTED - qsum = qsum + delp * a4(3,i,km) ! not good. -#else qsum = qsum + delp * q1(i,km) -#endif dpsum = dpsum + delp endif 123 q2(i,k) = qsum / dpsum diff --git a/model/fv_nesting.F90 b/model/fv_nesting.F90 index 495c39394..309a1cd48 100644 --- a/model/fv_nesting.F90 +++ b/model/fv_nesting.F90 @@ -10,7 +10,7 @@ !* (at your option) any later version. !* !* The FV3 dynamical core is distributed in the hope that it will be -!* useful, but WITHOUT ANYWARRANTY; without even the implied warranty +!* useful, but WITHOUT ANY WARRANTY; without even the implied warranty !* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. !* See the GNU General Public License for more details. !* @@ -18,6 +18,7 @@ !* License along with the FV3 dynamical core. !* If not, see . !*********************************************************************** + module fv_nesting_mod use mpp_domains_mod, only: mpp_update_domains @@ -36,14 +37,16 @@ module fv_nesting_mod use fv_arrays_mod, only: allocate_fv_nest_BC_type, fv_atmos_type, fv_grid_bounds_type, deallocate_fv_nest_BC_type use fv_grid_utils_mod, only: ptop_min, g_sum, cubed_to_latlon, f_p use init_hydro_mod, only: p_var - use constants_mod, only: grav, pi=>pi_8, radius, hlv, rdgas, cp_air, rvgas, cp_vapor, kappa - use fv_mapz_mod, only: mappm, remap_2d + use constants_mod, only: grav, pi=>pi_8, hlv, rdgas, cp_air, rvgas, cp_vapor, kappa + use fv_arrays_mod, only: radius ! scaled for small earth + use fv_mapz_mod, only: mappm use fv_timing_mod, only: timing_on, timing_off use fv_mp_mod, only: is_master use fv_mp_mod, only: mp_reduce_sum, global_nest_domain use fv_diagnostics_mod, only: sphum_ll_fix, range_check use sw_core_mod, only: divergence_corner, divergence_corner_nest use time_manager_mod, only: time_type + use gfdl_mp_mod, only: c_liq, c_ice implicit none logical :: RF_initialized = .false. @@ -1184,7 +1187,7 @@ subroutine remap_BC_k(pe_lagBC, pe_eulBC, var_lagBC, var_eulBC, isd_BC, ied_BC, call mappm(npz_coarse, peln_lag, var_lagBC(istart:iend,j:j,:), & npz, peln_eul, var_eulBC(istart:iend,j:j,:), & - istart, iend, iv, kord, pe_eulBC(istart,j,1)) + istart, iend, iv, kord) enddo @@ -1195,7 +1198,7 @@ subroutine remap_BC_k(pe_lagBC, pe_eulBC, var_lagBC, var_eulBC, isd_BC, ied_BC, call mappm(npz_coarse, pe_lagBC(istart:iend,j:j,:), var_lagBC(istart:iend,j:j,:), & npz, pe_eulBC(istart:iend,j:j,:), var_eulBC(istart:iend,j:j,:), & - istart, iend, iv, kord, pe_eulBC(istart,j,1)) + istart, iend, iv, kord) !!! NEED A FILLQ/FILLZ CALL HERE?? enddo @@ -1329,10 +1332,6 @@ subroutine setup_pt_NH_BC(pt_BC, delp_BC, delz_BC, sphum_BC, q_BC, nq, & integer, intent(IN) :: npx, npy, npz real, intent(IN) :: zvir - !real, parameter:: c_liq = 4185.5 ! heat capacity of water at 0C - !real, parameter:: c_ice = 1972. ! heat capacity of ice at 0C: c=c_ice+7.3*(T-Tice) - real, parameter:: c_liq = 4218.0 ! heat capacity of water at 0C - real, parameter:: c_ice = 2106. ! heat capacity of ice at 0C: c=c_ice+7.3*(T-Tice) real, parameter:: cv_vap = cp_vapor - rvgas ! 1384.5 real, dimension(:,:,:), pointer :: liq_watBC_west, ice_watBC_west, rainwatBC_west, snowwatBC_west, graupelBC_west @@ -1579,10 +1578,6 @@ subroutine setup_pt_NH_BC_k(ptBC,sphumBC,delpBC,delzBC, & integer :: i,j,k real :: dp1, q_con, q_sol, q_liq, cvm, pkz, rdg, cv_air - !real, parameter:: c_liq = 4185.5 ! heat capacity of water at 0C - real, parameter:: c_liq = 4218.0 ! heat capacity of water at 0C - !real, parameter:: c_ice = 1972. ! heat capacity of ice at 0C: c=c_ice+7.3*(T-Tice) - real, parameter:: c_ice = 2106. ! heat capacity of ice at 0C: c=c_ice+7.3*(T-Tice) real, parameter:: cv_vap = cp_vapor - rvgas ! 1384.5 real, parameter:: tice = 273.16 ! For GFS Partitioning real, parameter:: t_i0 = 15. @@ -2692,7 +2687,7 @@ subroutine remap_up_k(ps_src, ps_dst, ak_src, bk_src, ak_dst, bk_dst, var_src, v !remap_2d seems to have some bugs when doing logp remapping call mappm(npz_src, peln_src, var_src(istart:iend,j:j,:), & npz_dst, peln_dst, var_dst_unblend, & - istart, iend, iv, kord, peln_dst(istart,1)) + istart, iend, iv, kord) do k=1,npz_dst bw1 = blend_wt(k) @@ -2711,7 +2706,7 @@ subroutine remap_up_k(ps_src, ps_dst, ak_src, bk_src, ak_dst, bk_dst, var_src, v call mappm(npz_src, pe_src, var_src(istart:iend,j:j,:), & npz_dst, pe_dst, var_dst_unblend, & - istart, iend, iv, kord, pe_dst(istart,1)) + istart, iend, iv, kord) do k=1,npz_dst bw1 = blend_wt(k) @@ -2879,7 +2874,7 @@ subroutine update_remap_tqw( npz, ak_dst, bk_dst, ps_dst, t_dst, q_dst, w_dst, qp(i,k) = q_dst(i,j,k,iq) enddo enddo - call mappm(kmd, pe0, qp, npz, pe1, qn1, is,ie, 0, kord_tr, ptop) !not sure about indices + call mappm(kmd, pe0, qp, npz, pe1, qn1, is,ie, 0, kord_tr) !not sure about indices do k=1,npz do i=istart,iend q_dst(i,j,k,iq) = qn1(i,k) @@ -2894,7 +2889,7 @@ subroutine update_remap_tqw( npz, ak_dst, bk_dst, ps_dst, t_dst, q_dst, w_dst, enddo enddo !Remap T using logp - call mappm(kmd, pn0(istart:iend,:), tp(istart:iend,:), npz, pn1(istart:iend,:), qn1(istart:iend,:), istart,iend, 1, abs(kord_tm), ptop) + call mappm(kmd, pn0(istart:iend,:), tp(istart:iend,:), npz, pn1(istart:iend,:), qn1(istart:iend,:), istart,iend, 1, abs(kord_tm)) do k=1,npz wt1 = blend_wt(k) @@ -2912,7 +2907,7 @@ subroutine update_remap_tqw( npz, ak_dst, bk_dst, ps_dst, t_dst, q_dst, w_dst, enddo !Remap w using p !Using iv == -1 instead of -2 - call mappm(kmd, pe0(istart:iend,:), tp(istart:iend,:), npz, pe1(istart:iend,:), qn1(istart:iend,:), istart,iend, -1, kord_wz, ptop) + call mappm(kmd, pe0(istart:iend,:), tp(istart:iend,:), npz, pe1(istart:iend,:), qn1(istart:iend,:), istart,iend, -1, kord_wz) do k=1,npz wt1 = blend_wt(k) @@ -3002,7 +2997,7 @@ subroutine update_remap_uv(npz, ak_dst, bk_dst, ps_dst, u_dst, v_dst, & enddo enddo qn1 = 0. - call mappm(kmd, pe0(istart:iend,:), qt(istart:iend,:), npz, pe1(istart:iend,:), qn1(istart:iend,:), istart,iend, -1, kord_mt, ptop) + call mappm(kmd, pe0(istart:iend,:), qt(istart:iend,:), npz, pe1(istart:iend,:), qn1(istart:iend,:), istart,iend, -1, kord_mt) do k=1,npz wt1 = blend_wt(k) wt2 = 1. - wt1 @@ -3023,7 +3018,7 @@ subroutine update_remap_uv(npz, ak_dst, bk_dst, ps_dst, u_dst, v_dst, & !------ ! map v !------ -!$OMP parallel do default(none) shared(js,je,kmd,is,ie,ak_dst,bk_dst,ps_dst,u_dst,v_dst,ak_src,bk_src,ps_src,npz,u_src,v_src,ptop,istart,iend_v,jstart,jend,blend_wt) & +!$OMP parallel do default(none) shared(js,je,kmd,is,ie,ak_dst,bk_dst,ps_dst,u_dst,v_dst,ak_src,bk_src,ps_src,npz,u_src,v_src,ptop,istart,iend_v,jstart,jend,blend_wt,kord_mt) & !$OMP private(pe0,pe1,qt,qn1,wt1,wt2) do j=jstart,jend !------ @@ -3052,7 +3047,7 @@ subroutine update_remap_uv(npz, ak_dst, bk_dst, ps_dst, u_dst, v_dst, & enddo enddo qn1 = 0. - call mappm(kmd, pe0(istart:iend_v+1,:), qt(istart:iend_v+1,:), npz, pe1(istart:iend_v+1,:), qn1(istart:iend_v+1,:), istart,iend_v+1, -1, 8, ptop) + call mappm(kmd, pe0(istart:iend_v+1,:), qt(istart:iend_v+1,:), npz, pe1(istart:iend_v+1,:), qn1(istart:iend_v+1,:), istart,iend_v+1, -1, kord_mt) do k=1,npz wt1 = blend_wt(k) wt2 = 1. - wt1 diff --git a/model/fv_regional_bc.F90 b/model/fv_regional_bc.F90 index 92fa94ce7..6467498b8 100644 --- a/model/fv_regional_bc.F90 +++ b/model/fv_regional_bc.F90 @@ -10,7 +10,7 @@ !* (at your option) any later version. !* !* The FV3 dynamical core is distributed in the hope that it will be -!* useful, but WITHOUT ANYWARRANTY; without even the implied warranty +!* useful, but WITHOUT ANY WARRANTY; without even the implied warranty !* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. !* See the GNU General Public License for more details. !* @@ -66,8 +66,7 @@ module fv_regional_mod use fv_eta_mod, only: get_eta_level use fms_mod, only: check_nml_error use boundary_mod, only: fv_nest_BC_type_3D - use fv_cmp_mod, only: c_liq, c_ice - use sim_nc_mod, only: open_ncfile, close_ncfile, get_ncdim1 + use gfdl_mp_mod, only: c_liq, c_ice implicit none @@ -415,6 +414,17 @@ subroutine setup_regional_BC(Atm & else nrows_blend=nrows_blend_in_data !<-- # of blending rows in the BC files. endif + + IF ( north_bc .or. south_bc ) THEN + IF ( nrows_blend_user > jed - nhalo_model - (jsd + nhalo_model) + 1 ) THEN + call mpp_error(FATAL,'Number of blending rows is greater than the north-south tile size!') + ENDIF + ENDIF + IF ( west_bc .or. east_bc ) THEN + IF ( nrows_blend_user > ied - nhalo_model - (isd + nhalo_model) + 1 ) THEN + call mpp_error(FATAL,'Number of blending rows is greater than the east-west tile size!') + ENDIF + ENDIF ! call check(nf90_close(ncid)) !<-- Close the BC file for now. ! @@ -1971,6 +1981,7 @@ subroutine regional_bc_data(Atm,bc_hour & endif endif ! +#ifndef SW_DYNAMICS if(call_remap)then call remap_scalar_nggps_regional_bc(Atm & ,side & @@ -2148,6 +2159,7 @@ subroutine regional_bc_data(Atm,bc_hour & endif endif +#endif ! !----------------------------------------------------------------------- enddo sides_scalars @@ -2491,9 +2503,11 @@ subroutine fill_BC_for_DA do j=js_input,je_input do i=is_input,ie_input BC_t1%north%delp_BC(i,j,k)=delp_input(i,j,k) +#ifndef SW_DYNAMICS BC_t1%north%pt_BC(i,j,k)=t_input(i,j,k) BC_t1%north%w_BC(i,j,k)=w_input(i,j,k) BC_t1%north%delz_BC(i,j,k)=delz_input(i,j,k) +#endif enddo enddo enddo @@ -2552,9 +2566,11 @@ subroutine fill_BC_for_DA do j=js_input,je_input do i=is_input,ie_input BC_t1%south%delp_BC(i,j,k)=delp_input(i,j,k) +#ifndef SW_DYNAMICS BC_t1%south%pt_BC(i,j,k)=t_input(i,j,k) BC_t1%south%w_BC(i,j,k)=w_input(i,j,k) BC_t1%south%delz_BC(i,j,k)=delz_input(i,j,k) +#endif enddo enddo enddo @@ -2613,9 +2629,11 @@ subroutine fill_BC_for_DA do j=js_input,je_input do i=is_input,ie_input BC_t1%east%delp_BC(i,j,k)=delp_input(i,j,k) +#ifndef SW_DYNAMICS BC_t1%east%pt_BC(i,j,k)=t_input(i,j,k) BC_t1%east%w_BC(i,j,k)=w_input(i,j,k) BC_t1%east%delz_BC(i,j,k)=delz_input(i,j,k) +#endif enddo enddo enddo @@ -2674,9 +2692,11 @@ subroutine fill_BC_for_DA do j=js_input,je_input do i=is_input,ie_input BC_t1%west%delp_BC(i,j,k)=delp_input(i,j,k) +#ifndef SW_DYNAMICS BC_t1%west%pt_BC(i,j,k)=t_input(i,j,k) BC_t1%west%w_BC(i,j,k)=w_input(i,j,k) BC_t1%west%delz_BC(i,j,k)=delz_input(i,j,k) +#endif enddo enddo enddo @@ -3446,6 +3466,7 @@ end subroutine allocate_regional_BC_arrays !+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ !--------------------------------------------------------------------- +#ifndef SW_DYNAMICS subroutine remap_scalar_nggps_regional_bc(Atm & ,side & ,isd,ied,jsd,jed & @@ -3655,7 +3676,7 @@ subroutine remap_scalar_nggps_regional_bc(Atm & enddo enddo - call mappm(km, pe0, qp, npz, pe1, qn1, is,ie, 0, 8, Atm%ptop) + call mappm(km, pe0, qp, npz, pe1, qn1, is,ie, 0, 8) if ( iq==sphum ) then call fillq(ie-is+1, npz, 1, qn1, dp2) @@ -3739,6 +3760,7 @@ subroutine remap_scalar_nggps_regional_bc(Atm & ! Compute true temperature using hydrostatic balance if not read from input. +#ifndef SW_DYNAMICS if ( .not. data_source_fv3gfs ) then do k=1,npz BC_side%pt_BC(i,j,k) = (gz_fv(k)-gz_fv(k+1))/( rdgas*(pn1(i,k+1)-pn1(i,k))*(1.+zvir*BC_side%q_BC(i,j,k,sphum)) ) @@ -3752,6 +3774,7 @@ subroutine remap_scalar_nggps_regional_bc(Atm & enddo endif +#endif enddo i_loop !----------------------------------------------------------------------- @@ -3764,6 +3787,7 @@ subroutine remap_scalar_nggps_regional_bc(Atm & ! If the source is from old GFS or operational GSM then the tracers will be fixed in the boundaries ! and may not provide a very good result ! +#ifndef SW_DYNAMICS if ( .not. data_source_fv3gfs ) then if ( Atm%flagstruct%nwat .eq. 6 ) then do k=1,npz @@ -3809,6 +3833,7 @@ subroutine remap_scalar_nggps_regional_bc(Atm & enddo endif endif ! data source /= FV3GFS GAUSSIAN NEMSIO/NETCDF and GRIB2 FILE +#endif ! ! For GFS spectral input, omega in pa/sec is stored as w in the input data so actual w(m/s) is calculated ! For GFS nemsio input, omega is 0, so best not to use for input since boundary data will not exist for w @@ -3823,7 +3848,7 @@ subroutine remap_scalar_nggps_regional_bc(Atm & enddo enddo - call mappm(km, pe0, qp, npz, pe1, qn1, is,ie, -1, 4, Atm%ptop) + call mappm(km, pe0, qp, npz, pe1, qn1, is,ie, -1, 4) if ( data_source_fv3gfs ) then do k=1,npz @@ -3840,7 +3865,7 @@ subroutine remap_scalar_nggps_regional_bc(Atm & enddo enddo - call mappm(km, pe0, qp, npz, pe1, qn1, is,ie, 2, 4, Atm%ptop) + call mappm(km, pe0, qp, npz, pe1, qn1, is,ie, 2, 4) do k=1,npz do i=is,ie @@ -3882,6 +3907,7 @@ subroutine remap_scalar_nggps_regional_bc(Atm & end subroutine remap_scalar_nggps_regional_bc +#endif !--------------------------------------------------------------------- !+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ !--------------------------------------------------------------------- @@ -3939,9 +3965,9 @@ subroutine remap_dwinds_regional_bc(Atm & enddo enddo call mappm(km, pe0(is_u:ie_u,1:km+1), ud(is_u:ie_u,j,1:km), npz, pe1(is_u:ie_u,1:npz+1), & - qn1_d(is_u:ie_u,1:npz), is_u,ie_u, -1, 8, Atm%ptop ) + qn1_d(is_u:ie_u,1:npz), is_u,ie_u, -1, 8 ) call mappm(km, pe0(is_u:ie_u,1:km+1), vc(is_u:ie_u,j,1:km), npz, pe1(is_u:ie_u,1:npz+1), & - qn1_c(is_u:ie_u,1:npz), is_u,ie_u, -1, 8, Atm%ptop ) + qn1_c(is_u:ie_u,1:npz), is_u,ie_u, -1, 8 ) do k=1,npz do i=is_u,ie_u BC_side%u_BC(i,j,k) = qn1_d(i,k) @@ -3980,9 +4006,9 @@ subroutine remap_dwinds_regional_bc(Atm & enddo enddo call mappm(km, pe0(is_v:ie_v,1:km+1), vd(is_v:ie_v,j,1:km), npz, pe1(is_v:ie_v,1:npz+1), & - qn1_d(is_v:ie_v,1:npz), is_v,ie_v, -1, 8, Atm%ptop) + qn1_d(is_v:ie_v,1:npz), is_v,ie_v, -1, 8) call mappm(km, pe0(is_v:ie_v,1:km+1), uc(is_v:ie_v,j,1:km), npz, pe1(is_v:ie_v,1:npz+1), & - qn1_c(is_v:ie_v,1:npz), is_v,ie_v, -1, 8, Atm%ptop) + qn1_c(is_v:ie_v,1:npz), is_v,ie_v, -1, 8) do k=1,npz do i=is_v,ie_v BC_side%v_BC(i,j,k) = qn1_d(i,k) @@ -4231,6 +4257,7 @@ subroutine bc_values_into_arrays(side_t0,side_t1 & delp(i,j,k)=side_t0%delp_BC(i,j,k) & +(side_t1%delp_BC(i,j,k)-side_t0%delp_BC(i,j,k)) & *fraction_interval +#ifndef SW_DYNAMICS pt(i,j,k)=side_t0%pt_BC(i,j,k) & +(side_t1%pt_BC(i,j,k)-side_t0%pt_BC(i,j,k)) & *fraction_interval @@ -4253,6 +4280,7 @@ subroutine bc_values_into_arrays(side_t0,side_t1 & w(i,j,k)=side_t0%w_BC(i,j,k) & +(side_t1%w_BC(i,j,k)-side_t0%w_BC(i,j,k)) & *fraction_interval +#endif enddo enddo ! @@ -4279,9 +4307,9 @@ subroutine bc_values_into_arrays(side_t0,side_t1 & enddo enddo ! - ie=min(ubound(side_t0%w_BC,1),ubound(w,1)) - je=min(ubound(side_t0%w_BC,2),ubound(w,2)) - nz=ubound(w,3) + ie=min(ubound(side_t0%delp_BC,1),ubound(delp,1)) + je=min(ubound(side_t0%delp_BC,2),ubound(delp,2)) + nz=ubound(delp,3) ! do nt=1,ntracers do k=1,nz @@ -4314,7 +4342,7 @@ subroutine regional_boundary_update(array & ,is,ie,js,je & ,isd,ied,jsd,jed & ,fcst_time & - ,index4 ) + ,it,index4 ) ! !--------------------------------------------------------------------- !*** Select the given variable's boundary data at the two @@ -4332,7 +4360,8 @@ subroutine regional_boundary_update(array & integer,intent(in) :: lbnd_x,ubnd_x,lbnd_y,ubnd_y,ubnd_z !<-- Dimensions of full prognostic array to be updated. ! integer,intent(in) :: is,ie,js,je & !<-- Compute limits - ,isd,ied,jsd,jed !<-- Memory limits + ,isd,ied,jsd,jed & !<-- Memory limits + ,it !<-- Acoustic step ! integer,intent(in),optional :: index4 !<-- Index for the 4-D tracer array. ! @@ -4360,7 +4389,7 @@ subroutine regional_boundary_update(array & ! real,dimension(:,:,:),pointer :: bc_t0,bc_t1 !<-- Boundary data at the two bracketing times. ! - logical :: blend,call_interp + logical :: blend,call_interp,blendtmp ! !--------------------------------------------------------------------- !********************************************************************* @@ -4404,13 +4433,21 @@ subroutine regional_boundary_update(array & i2=ied+1 endif ! - j1=jsd - j2=js-1 + j1=jsd ! -2 -- outermost boundary ghost zone + j2=js-1 ! 0 -- first boundary ghost zone ! + IF ( east_bc ) THEN i1_blend=is + ELSE + i1_blend=isd !is-nhalo_model + ENDIF + IF ( west_bc ) THEN i2_blend=ie + ELSE + i2_blend=ied ! ie+nhalo_model + ENDIF if(trim(bc_vbl_name)=='uc'.or.trim(bc_vbl_name)=='v'.or.trim(bc_vbl_name)=='divgd')then - i2_blend=ie+1 + i2_blend=i2_blend+1 ! ie+1 endif j1_blend=js j2_blend=js+nrows_blend_user-1 @@ -4445,8 +4482,19 @@ subroutine regional_boundary_update(array & ! i1_blend=is i2_blend=ie - if(trim(bc_vbl_name)=='uc'.or.trim(bc_vbl_name)=='v'.or.trim(bc_vbl_name)=='divgd')then - i2_blend=ie+1 + IF ( east_bc ) THEN + i1_blend=is + ELSE + i1_blend=isd !is-nhalo_model + ENDIF + IF ( west_bc ) THEN + i2_blend=ie + ELSE + i2_blend=ied ! ie+nhalo_model + ENDIF + if(trim(bc_vbl_name)=='uc'.or.trim(bc_vbl_name)=='v'.or.trim(bc_vbl_name)=='divgd')then +! i2_blend=ie+1 + i2_blend=i2_blend+1 endif j2_blend=je if(trim(bc_vbl_name)=='u'.or.trim(bc_vbl_name)=='vc'.or.trim(bc_vbl_name)=='divgd')then @@ -4491,16 +4539,21 @@ subroutine regional_boundary_update(array & endif endif ! - i1_blend=is - i2_blend=is+nrows_blend_user-1 +! Note: Original code checked for corner region and avoided overlap, but changed this to blend corners from both boundaries + i1_blend=is + i2_blend=is+nrows_blend_user-1 + + IF ( north_bc ) THEN j1_blend=js + ELSE + j1_blend=jsd !js-nhalo_model + ENDIF + IF ( south_bc ) THEN j2_blend=je - if(north_bc)then - j1_blend=js+nrows_blend_user !<-- North BC already handles nrows_blend_user blending rows - endif - if(south_bc)then - j2_blend=je-nrows_blend_user !<-- South BC already handles nrows_blend_user blending rows - endif + ELSE + j2_blend=jed ! ie+nhalo_model + ENDIF + if(trim(bc_vbl_name)=='u'.or.trim(bc_vbl_name)=='vc'.or.trim(bc_vbl_name)=='divgd')then j2_blend=j2_blend+1 endif @@ -4546,16 +4599,20 @@ subroutine regional_boundary_update(array & endif endif ! +! Note: Original code checked for corner region and avoided overlap, but changed this to blend corners from both boundaries i1_blend=i1-nrows_blend_user i2_blend=i1-1 + + IF ( north_bc ) THEN j1_blend=js + ELSE + j1_blend=jsd !is-nhalo_model + ENDIF + IF ( south_bc ) THEN j2_blend=je - if(north_bc)then - j1_blend=js+nrows_blend_user !<-- North BC already handled nrows_blend_user blending rows. - endif - if(south_bc)then - j2_blend=je-nrows_blend_user !<-- South BC already handled nrows_blend_user blending rows. - endif + ELSE + j2_blend=jed ! ie+nhalo_model + ENDIF if(trim(bc_vbl_name)=='u'.or.trim(bc_vbl_name)=='vc'.or.trim(bc_vbl_name)=='divgd')then j2_blend=j2_blend+1 endif @@ -4571,6 +4628,8 @@ subroutine regional_boundary_update(array & !*** then update the boundary points. !--------------------------------------------------------------------- ! + + if(call_interp)then ! call retrieve_bc_variable_data(bc_vbl_name & @@ -4588,7 +4647,7 @@ subroutine regional_boundary_update(array & ,fcst_time & ,bc_update_interval & ,i1_blend,i2_blend,j1_blend,j2_blend & - ,i_bc,j_bc,nside,bc_vbl_name,blend ) + ,i_bc,j_bc,nside,bc_vbl_name,blend,it ) endif ! !--------------------------------------------------------------------- @@ -4644,6 +4703,7 @@ subroutine retrieve_bc_variable_data(bc_vbl_name & case ('delp') bc_t0=>bc_side_t0%delp_BC bc_t1=>bc_side_t1%delp_BC +#ifndef SW_DYNAMICS case ('delz') bc_t0=>bc_side_t0%delz_BC bc_t1=>bc_side_t1%delz_BC @@ -4653,6 +4713,7 @@ subroutine retrieve_bc_variable_data(bc_vbl_name & case ('w') bc_t0=>bc_side_t0%w_BC bc_t1=>bc_side_t1%w_BC +#endif case ('divgd') bc_t0=>bc_side_t0%divgd_BC bc_t1=>bc_side_t1%divgd_BC @@ -4718,7 +4779,7 @@ subroutine bc_time_interpolation(array & ,fcst_time & ,bc_update_interval & ,i1_blend,i2_blend,j1_blend,j2_blend & - ,i_bc,j_bc,nside,bc_vbl_name,blend ) + ,i_bc,j_bc,nside,bc_vbl_name,blend,it ) !--------------------------------------------------------------------- !*** Update the boundary region of the input array at the given @@ -4743,7 +4804,7 @@ subroutine bc_time_interpolation(array & ! integer,intent(in) :: is,ie,js,je !<-- Min/Max index limits on task's computational subdomain ! - integer,intent(in) :: bc_update_interval !<-- Time (hours) between BC data states + integer,intent(in) :: bc_update_interval,it !<-- Time (hours) between BC data states, acoustic step ! real,intent(in) :: fcst_time !<-- Current forecast time (sec) ! @@ -4780,9 +4841,22 @@ subroutine bc_time_interpolation(array & ! fraction_interval=mod(fcst_time,(bc_update_interval*3600.)) & /(bc_update_interval*3600.) -! + +!--------------------------------------------------------------------- +!*** Special check for final acoustic step prior to new boundary information +!*** being ingested. !--------------------------------------------------------------------- + + if (fraction_interval .eq. 0.0 .and. it .gt. 1) then + fraction_interval=1.0 + if (is_master()) then + write(0,*) 'reset of fraction_interval ', trim(bc_vbl_name),it, fcst_time + endif + endif + ! +!--------------------------------------------------------------------- +! Set values in the boundary points only do k=1,ubnd_z do j=j1,j2 do i=i1,i2 @@ -4813,7 +4887,7 @@ subroutine bc_time_interpolation(array & !----------- ! if(nside==1.and.north_bc)then - rdenom=1./real(j2_blend-j_bc-1) + rdenom=1./real(Max(1,j2_blend-j_bc-1)) do k=1,ubnd_z do j=j1_blend,j2_blend factor_dist=exp(-(blend_exp1+blend_exp2*(j-j_bc-1)*rdenom)) !<-- Exponential falloff of blending weights. @@ -4832,7 +4906,7 @@ subroutine bc_time_interpolation(array & !----------- ! if(nside==2.and.south_bc)then - rdenom=1./real(j_bc-j1_blend-1) + rdenom=1./real(Max(1,j_bc-j1_blend-1)) do k=1,ubnd_z do j=j1_blend,j2_blend factor_dist=exp(-(blend_exp1+blend_exp2*(j_bc-j-1)*rdenom)) !<-- Exponential falloff of blending weights. @@ -4850,7 +4924,7 @@ subroutine bc_time_interpolation(array & !---------- ! if(nside==3.and.east_bc)then - rdenom=1./real(i2_blend-i_bc-1) + rdenom=1./real(Max(1,i2_blend-i_bc-1)) do k=1,ubnd_z do j=j1_blend,j2_blend do i=i1_blend,i2_blend @@ -4871,7 +4945,7 @@ subroutine bc_time_interpolation(array & !---------- ! if(nside==4.and.west_bc)then - rdenom=1./real(i_bc-i1_blend-1) + rdenom=1./real(Max(1, i_bc-i1_blend-1)) do k=1,ubnd_z do j=j1_blend,j2_blend do i=i1_blend,i2_blend @@ -5153,6 +5227,7 @@ subroutine convert_to_virt_pot_temp(isd,ied,jsd,jed,npz) j1=regional_bounds%js_north j2=regional_bounds%je_north q =>BC_t1%north%q_BC +#ifndef SW_DYNAMICS #ifdef USE_COND q_con=>BC_t1%north%q_con_BC #endif @@ -5163,6 +5238,7 @@ subroutine convert_to_virt_pot_temp(isd,ied,jsd,jed,npz) #endif pt =>BC_t1%north%pt_BC call compute_vpt !<-- Compute the virtual potential temperature. +#endif endif ! if(south_bc)then @@ -5171,6 +5247,7 @@ subroutine convert_to_virt_pot_temp(isd,ied,jsd,jed,npz) j1=regional_bounds%js_south j2=regional_bounds%je_south q =>BC_t1%south%q_BC +#ifndef SW_DYNAMICS #ifdef USE_COND q_con=>BC_t1%south%q_con_BC #endif @@ -5181,6 +5258,7 @@ subroutine convert_to_virt_pot_temp(isd,ied,jsd,jed,npz) #endif pt =>BC_t1%south%pt_BC call compute_vpt !<-- Compute the virtual potential temperature. +#endif endif ! if(east_bc)then @@ -5189,6 +5267,7 @@ subroutine convert_to_virt_pot_temp(isd,ied,jsd,jed,npz) j1=regional_bounds%js_east j2=regional_bounds%je_east q =>BC_t1%east%q_BC +#ifndef SW_DYNAMICS #ifdef USE_COND q_con=>BC_t1%east%q_con_BC #endif @@ -5199,6 +5278,7 @@ subroutine convert_to_virt_pot_temp(isd,ied,jsd,jed,npz) #endif pt =>BC_t1%east%pt_BC call compute_vpt !<-- Compute the virtual potential temperature. +#endif endif ! if(west_bc)then @@ -5207,6 +5287,7 @@ subroutine convert_to_virt_pot_temp(isd,ied,jsd,jed,npz) j1=regional_bounds%js_west j2=regional_bounds%je_west q =>BC_t1%west%q_BC +#ifndef SW_DYNAMICS #ifdef USE_COND q_con=>BC_t1%west%q_con_BC #endif @@ -5217,6 +5298,7 @@ subroutine convert_to_virt_pot_temp(isd,ied,jsd,jed,npz) #endif pt =>BC_t1%west%pt_BC call compute_vpt !<-- Compute the virtual potential temperature. +#endif endif ! !----------------------------------------------------------------------- @@ -6733,7 +6815,7 @@ end subroutine exch_uv !+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ !--------------------------------------------------------------------- - subroutine get_data_source(data_source_fv3gfs,regional) + subroutine get_data_source(data_source_fv3gfs,regional,directory) ! ! This routine extracts the data source information if it is present in the datafile. ! @@ -6742,8 +6824,13 @@ subroutine get_data_source(data_source_fv3gfs,regional) character (len=80) :: source logical :: lstatus + character(len=*), intent(in), optional :: directory + character(len=128) :: dir type(FmsNetcdfFile_t) :: Gfs_data integer, allocatable, dimension(:) :: pes !< Array of the pes in the current pelist + + dir = 'INPUT/' + if(present(directory)) dir = directory ! ! Use the fms call here so we can actually get the return code value. ! The term 'source' is specified by 'chgres_cube' @@ -6752,8 +6839,8 @@ subroutine get_data_source(data_source_fv3gfs,regional) allocate(pes(mpp_npes())) call mpp_get_current_pelist(pes) - if (open_file(Gfs_data , 'INPUT/gfs_data.nc', "read", pelist=pes) .or. & - open_file(Gfs_data , 'INPUT/gfs_data.tile1.nc', "read", pelist=pes)) then + if (open_file(Gfs_data , trim(dir)//'/gfs_data.nc', "read", pelist=pes) .or. & + open_file(Gfs_data , trim(dir)//'/gfs_data.tile1.nc', "read", pelist=pes)) then lstatus = global_att_exists(Gfs_data, "source") if(lstatus) call get_global_attribute(Gfs_data, "source", source) call close_file(Gfs_data) @@ -6761,7 +6848,8 @@ subroutine get_data_source(data_source_fv3gfs,regional) deallocate(pes) if (.not. lstatus) then - if (mpp_pe() == 0) write(0,*) 'INPUT source not found ',lstatus,' set source=No Source Attribute' + if (mpp_pe() == 0) write(0,*) 'INPUT source not found in ', trim(dir), & + ' status=', lstatus,' set source=No Source Attribute' source='No Source Attribute' endif if (mpp_pe()==0) write(*,*) 'INPUT gfs_data source string=',source diff --git a/model/fv_sg.F90 b/model/fv_sg.F90 index b6bf503f8..31f3eba3e 100644 --- a/model/fv_sg.F90 +++ b/model/fv_sg.F90 @@ -10,7 +10,7 @@ !* (at your option) any later version. !* !* The FV3 dynamical core is distributed in the hope that it will be -!* useful, but WITHOUT ANYWARRANTY; without even the implied warranty +!* useful, but WITHOUT ANY WARRANTY; without even the implied warranty !* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. !* See the GNU General Public License for more details. !* @@ -18,6 +18,7 @@ !* License along with the FV3 dynamical core. !* If not, see . !*********************************************************************** + module fv_sg_mod !----------------------------------------------------------------------- @@ -26,7 +27,7 @@ module fv_sg_mod use constants_mod, only: rdgas, rvgas, cp_air, cp_vapor, hlv, hlf, kappa, grav use tracer_manager_mod, only: get_tracer_index use field_manager_mod, only: MODEL_ATMOS - use gfdl_cloud_microphys_mod, only: wqs1, wqs2, wqsat2_moist + use gfdl_mp_mod, only: wqs1, wqs2, wqsat2_moist, c_liq, c_ice use fv_mp_mod, only: mp_reduce_min, is_master use mpp_mod, only: mpp_pe @@ -37,10 +38,6 @@ module fv_sg_mod real, parameter:: esl = 0.621971831 real, parameter:: tice = 273.16 - real, parameter:: c_ice = 2106. ! Emanuel table, page 566 -! real, parameter:: c_ice = 1972. ! -15 C -! real, parameter:: c_liq = 4.1855e+3 ! GFS - real, parameter:: c_liq = 4218. ! ECMWF-IFS real, parameter:: cv_vap = cp_vapor - rvgas ! 1384.5 real, parameter:: c_con = c_ice @@ -978,7 +975,7 @@ subroutine qsmith_init allocate ( table(length) ) allocate ( des (length) ) - call qs_table(length, table) + call qs_table_m(length, table) do i=1,length-1 des(i) = table(i+1) - table(i) diff --git a/model/fv_tracer2d.F90 b/model/fv_tracer2d.F90 index fd298279e..ea102da32 100644 --- a/model/fv_tracer2d.F90 +++ b/model/fv_tracer2d.F90 @@ -10,7 +10,7 @@ !* (at your option) any later version. !* !* The FV3 dynamical core is distributed in the hope that it will be -!* useful, but WITHOUT ANYWARRANTY; without even the implied warranty +!* useful, but WITHOUT ANY WARRANTY; without even the implied warranty !* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. !* See the GNU General Public License for more details. !* @@ -18,6 +18,7 @@ !* License along with the FV3 dynamical core. !* If not, see . !*********************************************************************** + module fv_tracer2d_mod use tp_core_mod, only: fv_tp_2d, copy_corners use fv_mp_mod, only: mp_reduce_max @@ -722,7 +723,7 @@ subroutine tracer_2d_nested(q, dp1, mfx, mfy, cx, cy, gridstruct, bd, domain, np is, ie, js, je, & isd, ied, jsd, jed, & reg_bc_update_time, & - iq ) + it, iq ) enddo endif diff --git a/model/fv_update_phys.F90 b/model/fv_update_phys.F90 index d3672defb..83d2955fd 100644 --- a/model/fv_update_phys.F90 +++ b/model/fv_update_phys.F90 @@ -10,7 +10,7 @@ !* (at your option) any later version. !* !* The FV3 dynamical core is distributed in the hope that it will be -!* useful, but WITHOUT ANYWARRANTY; without even the implied warranty +!* useful, but WITHOUT ANY WARRANTY; without even the implied warranty !* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. !* See the GNU General Public License for more details. !* @@ -18,9 +18,10 @@ !* License along with the FV3 dynamical core. !* If not, see . !*********************************************************************** + module fv_update_phys_mod - use constants_mod, only: kappa, rdgas, rvgas, grav, cp_air, cp_vapor, pi=>pi_8, radius, TFREEZE + use constants_mod, only: kappa, rdgas, rvgas, grav, cp_air, cp_vapor, pi=>pi_8, TFREEZE use field_manager_mod, only: MODEL_ATMOS use mpp_domains_mod, only: mpp_update_domains, domain2d use mpp_parameter_mod, only: AGRID_PARAM=>AGRID @@ -546,7 +547,7 @@ subroutine fv_update_phys ( dt, is, ie, js, je, isd, ied, jsd, jed, ng, nq, call fv_climate_nudge ( Time, dt, is, ie, js, je, npz, pfull, & lona(is:ie,js:je), lata(is:ie,js:je), phis(is:ie,js:je), & - ptop, ak, bk, & + ak, bk, & ps(is:ie,js:je), ua(is:ie,js:je,:), va(is:ie,js:je,:), & pt(is:ie,js:je,:), q(is:ie,js:je,:,sphum:sphum), & ps_dt(is:ie,js:je), u_dt(is:ie,js:je,:), & @@ -594,7 +595,7 @@ subroutine fv_update_phys ( dt, is, ie, js, je, isd, ied, jsd, jed, ng, nq, enddo enddo call fv_ada_nudge ( Time, dt, npx, npy, npz, ps_dt, u_dt, v_dt, t_dt, q_dt_nudge, & - zvir, ptop, ak, bk, ts, ps, delp, ua, va, pt, & + zvir, ak, bk, ts, ps, delp, ua, va, pt, & nwat, q, phis, gridstruct, bd, domain ) if (allocated(nudge_diag%nudge_t_dt)) nudge_diag%nudge_t_dt = (pt(is:ie,js:je,:) - nudge_diag%nudge_t_dt) / dt @@ -624,7 +625,7 @@ subroutine fv_update_phys ( dt, is, ie, js, je, isd, ied, jsd, jed, ng, nq, enddo enddo call fv_nwp_nudge ( Time, dt, npx, npy, npz, ps_dt, u_dt, v_dt, t_dt, q_dt_nudge, & - zvir, ptop, ak, bk, ts, ps, delp, ua, va, pt, & + zvir, ak, bk, ts, ps, delp, ua, va, pt, & nwat, q, phis, gridstruct, bd, domain ) if (allocated(nudge_diag%nudge_t_dt)) nudge_diag%nudge_t_dt = (pt(is:ie,js:je,:) - nudge_diag%nudge_t_dt) / dt diff --git a/driver/SHiELD/gfdl_cloud_microphys.F90 b/model/gfdl_cld_mp.F90 similarity index 56% rename from driver/SHiELD/gfdl_cloud_microphys.F90 rename to model/gfdl_cld_mp.F90 index 3dd6c40cd..5316f4bc3 100644 --- a/driver/SHiELD/gfdl_cloud_microphys.F90 +++ b/model/gfdl_cld_mp.F90 @@ -10,7 +10,7 @@ !* (at your option) any later version. !* !* The FV3 dynamical core is distributed in the hope that it will be -!* useful, but WITHOUT ANYWARRANTY; without even the implied warranty +!* useful, but WITHOUT ANY WARRANTY; without even the implied warranty !* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. !* See the GNU General Public License for more details. !* @@ -27,180 +27,186 @@ ! developer: shian - jiann lin, linjiong zhou ! ======================================================================= -module gfdl_cloud_microphys_mod +module gfdl_cld_mp_mod - ! use mpp_mod, only: stdlog, mpp_pe, mpp_root_pe, mpp_clock_id, & - ! mpp_clock_begin, mpp_clock_end, clock_routine, & - ! input_nml_file - ! use time_manager_mod, only: time_type, get_time - ! use constants_mod, only: grav, rdgas, rvgas, cp_air, hlv, hlf, pi => pi_8 - ! use fms_mod, only: write_version_number, open_namelist_file, & - ! check_nml_error, file_exist, close_file +#ifdef GFS_PHYS + use machine, only: r_grid => kind_phys +#endif implicit none private - public gfdl_cloud_microphys_driver, gfdl_cloud_microphys_init, gfdl_cloud_microphys_end - public wqs1, wqs2, qs_blend, wqsat_moist, wqsat2_moist - public qsmith_init, qsmith, es2_table1d, es3_table1d, esw_table1d - public setup_con, wet_bulb - - real :: missing_value = - 1.e10 + public gfdl_cld_mp_driver, gfdl_cld_mp_init, gfdl_cld_mp_end + public wqs1, wqs2, iqs1, iqs2, mpdrv, sedi_heat, warm_rain, revap_racc, & + linear_prof, icloud, subgrid_z_proc, terminal_fall, check_column, implicit_fall, & + lagrangian_fall_ppm, cs_profile, cs_limiters, fall_speed, setupm, setup_con, & + qsmith_init, qs_tablew, qs_table2, qs_table3, qs_table, neg_adj, acr3d, smlt, gmlt, & + wet_bulb, qsmith, qs_blend, es3_table1d, es2_table1d, esw_table1d, es2_table, & + esw_table, d_sat, qs1d_m, wqsat_moist, wqsat2_moist, qs1d_moist, revap_rac1, & + wqs2_vect, rhow, rhor, rhos, rhog, rhoh, rnzr, rnzs, rnzg, rnzh, rvgas, rdgas, & + grav, hlv, hlf, cp_air, cp_vap, cv_air, cv_vap, c_ice, c_liq, dc_vap, dc_ice, & + t_ice, t_wfr, e00, pi, zvir, rgrav + +#ifndef GFS_PHYS + integer, parameter :: r_grid = 8 +#endif logical :: module_is_initialized = .false. logical :: qsmith_tables_initialized = .false. - character (len = 17) :: mod_name = 'gfdl_cloud_microphys' - real, parameter :: grav = 9.80665 ! gfs: acceleration due to gravity real, parameter :: rdgas = 287.05 ! gfs: gas constant for dry air real, parameter :: rvgas = 461.50 ! gfs: gas constant for water vapor - real, parameter :: cp_air = 1004.6 ! gfs: heat capacity of dry air at constant pressure + real, parameter :: cp_air = 1.0046e3 ! gfs: heat capacity of dry air at constant pressure real, parameter :: hlv = 2.5e6 ! gfs: latent heat of evaporation real, parameter :: hlf = 3.3358e5 ! gfs: latent heat of fusion real, parameter :: pi = 3.1415926535897931 ! gfs: ratio of circle circumference to diameter - ! real, parameter :: rdgas = 287.04 ! gfdl: gas constant for dry air - ! real, parameter :: cp_air = rdgas * 7. / 2. ! 1004.675, heat capacity of dry air at constant pressure real, parameter :: cp_vap = 4.0 * rvgas ! 1846.0, heat capacity of water vapore at constnat pressure - ! real, parameter :: cv_air = 717.56 ! satoh value + ! real, parameter :: cv_air = 717.56 ! satoh value, heat capacity of dry air at constant volume real, parameter :: cv_air = cp_air - rdgas ! 717.55, heat capacity of dry air at constant volume - ! real, parameter :: cv_vap = 1410.0 ! emanuel value + ! real, parameter :: cv_vap = 1410.0 ! emanuel value, heat capacity of water vapor at constant volume real, parameter :: cv_vap = 3.0 * rvgas ! 1384.5, heat capacity of water vapor at constant volume - ! the following two are from emanuel's book "atmospheric convection" - real, parameter :: c_ice = 2106.0 ! heat capacity of ice at 0 deg c: c = c_ice + 7.3 * (t - tice) - ! real, parameter :: c_liq = 4190.0 ! heat capacity of water at 0 deg c + ! http: // www.engineeringtoolbox.com / ice - thermal - properties - d_576.html + ! c_ice = 2050.0 at 0 deg c + ! c_ice = 2000.0 at - 10 deg c + ! c_ice = 1943.0 at - 20 deg c + ! c_ice = 1882.0 at - 30 deg c + ! c_ice = 1818.0 at - 40 deg c - ! real, parameter :: c_ice = 1972.0 ! gfdl: heat capacity of ice at - 15 deg c - ! real, parameter :: c_liq = 4185.5 ! gfdl: heat capacity of water at 15 deg c - real, parameter :: c_liq = 4218.0 ! ifs: heat capacity of liquid at 0 deg c + ! https: // www.engineeringtoolbox.com / specific - heat - capacity - water - d_660.html + ! c_liq = 4219.9 at 0.01 deg c + ! c_liq = 4195.5 at 10 deg c + ! c_liq = 4184.4 at 20 deg c + ! c_liq = 4180.1 at 30 deg c + ! c_liq = 4179.6 at 40 deg c + + ! the following two are from emanuel's book "atmospheric convection" + ! real, parameter :: c_ice = 2.106e3 ! heat capacity of ice at 0 deg c: c = c_ice + 7.3 * (t - tice) + ! real, parameter :: c_liq = 4.190e3 ! heat capacity of water at 0 deg c + ! real, parameter :: c_ice = 1.972e3 ! gfdl: heat capacity of ice at - 15 deg c + ! real, parameter :: c_liq = 4.1855e3 ! gfdl: heat capacity of water at 15 deg c + ! real, parameter :: c_ice = 2.106e3 ! gfs: heat capacity of ice at 0 deg c + ! real, parameter :: c_liq = 4.1855e3 ! gfs: heat capacity of liquid at 15 deg c + real, parameter :: c_ice = 2.106e3 ! ifs: heat capacity of ice at 0 deg c + real, parameter :: c_liq = 4.218e3 ! ifs: heat capacity of water at 0 deg c real, parameter :: eps = rdgas / rvgas ! 0.6219934995 real, parameter :: zvir = rvgas / rdgas - 1. ! 0.6077338443 + real, parameter :: dc_vap = cp_vap - c_liq ! - 2.372e3, isobaric heating / cooling + real, parameter :: dc_ice = c_liq - c_ice ! 2.112e3, isobaric heating / colling + real, parameter :: t_ice = 273.16 ! freezing temperature real, parameter :: table_ice = 273.16 ! freezing point for qs table + real :: t_wfr ! complete freezing temperature - ! real, parameter :: e00 = 610.71 ! gfdl: saturation vapor pressure at 0 deg c - real, parameter :: e00 = 611.21 ! ifs: saturation vapor pressure at 0 deg c - - real, parameter :: dc_vap = cp_vap - c_liq ! - 2339.5, isobaric heating / cooling - real, parameter :: dc_ice = c_liq - c_ice ! 2213.5, isobaric heating / colling + real (kind = r_grid), parameter :: e00 = 611.21 ! ifs: saturation vapor pressure at 0 deg c + ! real (kind = r_grid), parameter :: e00 = 610.71 ! gfdl: saturation vapor pressure at 0 deg c real, parameter :: hlv0 = hlv ! gfs: evaporation latent heat coefficient at 0 deg c - ! real, parameter :: hlv0 = 2.501e6 ! emanuel appendix - 2 + ! real, parameter :: hlv0 = 2.501e6 ! emanuel value real, parameter :: hlf0 = hlf ! gfs: fussion latent heat coefficient at 0 deg c - ! real, parameter :: hlf0 = 3.337e5 ! emanuel + ! real, parameter :: hlf0 = 3.337e5 ! emanuel value - real, parameter :: lv0 = hlv0 - dc_vap * t_ice! 3.13905782e6, evaporation latent heat coefficient at 0 deg k - real, parameter :: li00 = hlf0 - dc_ice * t_ice! - 2.7105966e5, fussion latend heat coefficient at 0 deg k + real, parameter :: lv0 = hlv0 - dc_vap * t_ice ! 3.14893552e6, evaporation latent heat coefficient at 0 deg k + real, parameter :: li0 = hlf0 - dc_ice * t_ice ! - 2.2691392e5, fussion latend heat coefficient at 0 deg k - real, parameter :: d2ice = dc_vap + dc_ice ! - 126, isobaric heating / cooling - real, parameter :: li2 = lv0 + li00 ! 2.86799816e6, sublimation latent heat coefficient at 0 deg k + real (kind = r_grid), parameter :: d2ice = cp_vap - c_ice ! - 260.0, isobaric heating / cooling + real (kind = r_grid), parameter :: li2 = lv0 + li0 ! 2.9220216e6, sublimation latent heat coefficient at 0 deg k - real, parameter :: qrmin = 1.e-8 ! min value for ??? + real, parameter :: qrmin = 1.e-8 ! min value for cloud condensates real, parameter :: qvmin = 1.e-20 ! min value for water vapor (treated as zero) real, parameter :: qcmin = 1.e-12 ! min value for cloud condensates real, parameter :: vr_min = 1.e-3 ! min fall speed for rain real, parameter :: vf_min = 1.e-5 ! min fall speed for cloud ice, snow, graupel - real, parameter :: dz_min = 1.e-2 ! use for correcting flipped height + real, parameter :: dz_min = 1.e-2 ! used for correcting flipped height real, parameter :: sfcrho = 1.2 ! surface air density - ! intercept parameters - - real, parameter :: rnzr = 8.0e6 ! lin83 - real, parameter :: rnzs = 3.0e6 ! lin83 - real, parameter :: rnzg = 4.0e6 ! rh84 - real, parameter :: rnzh = 4.0e4 ! lin83 --- lmh 29 sep 17 - - ! density parameters + real, parameter :: rnzr = 8.0e6 ! lin et al. 1983 + real, parameter :: rnzs = 3.0e6 ! lin et al. 1983 + real, parameter :: rnzg = 4.0e6 ! rutledge and hobbs 1984 + ! lmh, 20170929 + real, parameter :: rnzh = 4.0e4 ! lin et al. 1983 - real, parameter :: rhor = 1.e3 ! density of rain water, lin83 - real, parameter :: rhos = 0.1e3 ! lin83 (snow density; 1 / 10 of water) - real, parameter :: rhog = 0.4e3 ! rh84 (graupel density) - real, parameter :: rhoh = 0.917e3 ! lin83 --- lmh 29 sep 17 + real, parameter :: rhow = 1.0e3 ! density of cloud water + real, parameter :: rhor = 1.0e3 ! lin et al. 1983 + real, parameter :: rhos = 0.1e3 ! lin et al. 1983 + real, parameter :: rhog = 0.4e3 ! rutledge and hobbs 1984 + ! lmh, 20170929 + real, parameter :: rhoh = 0.917e3 ! lin et al. 1983 - public rhor, rhos, rhog, rhoh, rnzr, rnzs, rnzg, rnzh + real, parameter :: rgrav = 1. / grav real :: cracs, csacr, cgacr, cgacs, csacw, craci, csaci, cgacw, cgaci, cracw ! constants for accretions real :: acco (3, 4) ! constants for accretions + ! constants for sublimation / deposition, freezing / melting, condensation / evaporation real :: cssub (5), cgsub (5), crevp (5), cgfr (2), csmlt (5), cgmlt (5) real :: es0, ces0 - real :: pie, rgrav, fac_rc + real :: pie, fac_rc real :: c_air, c_vap - real :: lati, latv, lats, lat2, lcp, icp, tcp ! used in bigg mechanism and wet bulk + real :: lat2, lcp, icp, tcp ! used in bigg mechanism and wet bulk real :: d0_vap ! the same as dc_vap, except that cp_vap can be cp_vap or cv_vap - real :: lv00 ! the same as lv0, except that cp_vap can be cp_vap or cv_vap - - ! cloud microphysics switchers - - integer :: icloud_f = 0 ! cloud scheme - integer :: irain_f = 0 ! cloud water to rain auto conversion scheme - - logical :: de_ice = .false. ! to prevent excessive build - up of cloud ice from external sources - logical :: sedi_transport = .true. ! transport of momentum in sedimentation - logical :: do_sedi_w = .false. ! transport of vertical motion in sedimentation - logical :: do_sedi_heat = .false. ! transport of heat in sedimentation ! default changed to false 19oct17 lmh - logical :: prog_ccn = .false. ! do prognostic ccn (yi ming's method) - logical :: do_qa = .true. ! do inline cloud fraction - logical :: rad_snow = .true. ! consider snow in cloud fraciton calculation - logical :: rad_graupel = .true. ! consider graupel in cloud fraction calculation - logical :: rad_rain = .true. ! consider rain in cloud fraction calculation - logical :: fix_negative = .false. ! fix negative water species - logical :: do_setup = .true. ! setup constants and parameters - logical :: p_nonhydro = .false. ! perform hydrosatic adjustment on air density + real (kind = r_grid) :: lv00, li00, li20 + real (kind = r_grid) :: d1_vap, d1_ice, c1_vap, c1_liq, c1_ice + real (kind = r_grid), parameter :: one_r8 = 1. real, allocatable :: table (:), table2 (:), table3 (:), tablew (:) real, allocatable :: des (:), des2 (:), des3 (:), desw (:) logical :: tables_are_initialized = .false. - ! logical :: master - ! integer :: id_rh, id_vtr, id_vts, id_vtg, id_vti, id_rain, id_snow, id_graupel, & - ! id_ice, id_prec, id_cond, id_var, id_droplets - ! integer :: gfdl_mp_clock ! clock for timing of driver routine - real, parameter :: dt_fr = 8. ! homogeneous freezing of all cloud water at t_wfr - dt_fr ! minimum temperature water can exist (moore & molinero nov. 2011, nature) ! dt_fr can be considered as the error bar - real :: p_min = 100. ! minimum pressure (pascal) for mp to operate - - ! slj, the following parameters are for cloud - resolving resolution: 1 - 5 km - - ! qi0_crt = 0.8e-4 - ! qs0_crt = 0.6e-3 - ! c_psaci = 0.1 - ! c_pgacs = 0.1 + real, parameter :: p0_min = 100. ! minimum pressure (pascal) for mp to operate + real :: p_min ! ----------------------------------------------------------------------- ! namelist parameters ! ----------------------------------------------------------------------- + integer :: ntimes = 1 ! cloud microphysics sub cycles + + integer :: icloud_f = 0 ! cloud scheme + integer :: irain_f = 0 ! cloud water to rain auto conversion scheme + + logical :: sedi_transport = .true. ! transport of momentum in sedimentation + logical :: do_sedi_w = .true. ! transport of vertical momentum during sedimentation + logical :: do_sedi_heat = .true. ! transport of heat in sedimentation + logical :: prog_ccn = .false. ! do prognostic ccn (yi ming's method) + logical :: do_qa = .true. ! do inline cloud fraction + logical :: rad_snow = .true. ! consider snow in cloud fraciton calculation + logical :: rad_graupel = .true. ! consider graupel in cloud fraction calculation + logical :: rad_rain = .true. ! consider rain in cloud fraction calculation + logical :: fix_negative = .false. ! fix negative water species + logical :: do_setup = .true. ! setup constants and parameters + logical :: disp_heat = .false. ! dissipative heating due to sedimentation + logical :: do_cond_timescale = .false. ! whether to apply a timescale to condensation + + real :: cld_fac = 1.0 ! multiplication factor for cloud fraction real :: cld_min = 0.05 ! minimum cloud fraction real :: tice = 273.16 ! set tice = 165. to trun off ice - phase phys (kessler emulator) + real :: tice_mlt = 273.16 ! set ice melting temperature to 268.0 based on observation (kay et al., 2016, jc) real :: t_min = 178. ! min temp to freeze - dry all water vapor real :: t_sub = 184. ! min temp for sublimation of cloud ice real :: mp_time = 150. ! maximum micro - physics time step (sec) - ! relative humidity increment - real :: rh_inc = 0.25 ! rh increment for complete evaporation of cloud water and cloud ice real :: rh_inr = 0.25 ! rh increment for minimum evaporation of rain real :: rh_ins = 0.25 ! rh increment for sublimation of snow - ! conversion time scale - real :: tau_r2g = 900. ! rain freezing during fast_sat real :: tau_smlt = 900. ! snow melting real :: tau_g2r = 600. ! graupel melting to rain @@ -211,18 +217,15 @@ module gfdl_cloud_microphys_mod real :: tau_l2v = 300. ! cloud water to water vapor (evaporation) real :: tau_g2v = 900. ! grapuel sublimation real :: tau_v2g = 21600. ! grapuel deposition -- make it a slow process - - ! horizontal subgrid variability + real :: tau_revp = 0. ! rain evaporation real :: dw_land = 0.20 ! base value for subgrid deviation / variability over land real :: dw_ocean = 0.10 ! base value for ocean - ! prescribed ccn - real :: ccn_o = 90. ! ccn over ocean (cm^ - 3) real :: ccn_l = 270. ! ccn over land (cm^ - 3) - real :: rthresh = 10.0e-6 ! critical cloud drop radius (micro m) + real :: rthresh = 10.0e-6 ! critical cloud drop radius (micron) ! ----------------------------------------------------------------------- ! wrf / wsm6 scheme: qi_gen = 4.92e-11 * (1.e3 * exp (0.1 * tmp)) ** 1.33 @@ -241,7 +244,7 @@ module gfdl_cloud_microphys_mod real :: ql_mlt = 2.0e-3 ! max value of cloud water allowed from melted cloud ice real :: qs_mlt = 1.0e-6 ! max cloud water due to snow melt - real :: ql_gen = 1.0e-3 ! max cloud water generation during remapping step if fast_sat_adj = .t. + real :: ql_gen = 1.0e-3 ! max cloud water generation during remapping step if do_sat_adj = .t. real :: qi_gen = 1.82e-6 ! max cloud ice generation during remapping step ! cloud condensate upper bounds: "safety valves" for ql & qi @@ -250,87 +253,113 @@ module gfdl_cloud_microphys_mod real :: qi0_max = 1.0e-4 ! max cloud ice value (by other sources) real :: qi0_crt = 1.0e-4 ! cloud ice to snow autoconversion threshold (was 1.e-4) - ! qi0_crt is highly dependent on horizontal resolution + ! qi0_crt if negative, its magnitude is used as the mixing ration threshold; otherwise, used as density real :: qr0_crt = 1.0e-4 ! rain to snow or graupel / hail threshold - ! lfo used * mixing ratio * = 1.e-4 (hail in lfo) + ! lin et al. (1983) used * mixing ratio * = 1.e-4 (hail) real :: qs0_crt = 1.0e-3 ! snow to graupel density threshold (0.6e-3 in purdue lin scheme) real :: c_paut = 0.55 ! autoconversion cloud water to rain (use 0.5 to reduce autoconversion) real :: c_psaci = 0.02 ! accretion: cloud ice to snow (was 0.1 in zetac) - real :: c_piacr = 5.0 ! accretion: rain to ice: + real :: c_piacr = 5.0 ! accretion: rain to ice: (not used) real :: c_cracw = 0.9 ! rain accretion efficiency real :: c_pgacs = 2.0e-3 ! snow to graupel "accretion" eff. (was 0.1 in zetac) ! decreasing clin to reduce csacw (so as to reduce cloud water --- > snow) - real :: alin = 842.0 ! "a" in lin1983 - real :: clin = 4.8 ! "c" in lin 1983, 4.8 -- > 6. (to ehance ql -- > qs) - - ! fall velocity tuning constants: + real :: alin = 842.0 ! "a" in lin et al. (1983) + real :: clin = 4.8 ! "c" in lin et al. (1983), 4.8 -- > 6. (to ehance ql -- > qs) logical :: const_vi = .false. ! if .t. the constants are specified by v * _fac logical :: const_vs = .false. ! if .t. the constants are specified by v * _fac logical :: const_vg = .false. ! if .t. the constants are specified by v * _fac logical :: const_vr = .false. ! if .t. the constants are specified by v * _fac - ! good values: - - real :: vi_fac = 1. ! if const_vi: 1 / 3 - real :: vs_fac = 1. ! if const_vs: 1. - real :: vg_fac = 1. ! if const_vg: 2. - real :: vr_fac = 1. ! if const_vr: 4. - - ! upper bounds of fall speed (with variable speed option) + real :: vi_fac = 1. ! ifs: if const_vi: 1 / 3 + real :: vs_fac = 1. ! ifs: if const_vs: 1. + real :: vg_fac = 1. ! ifs: if const_vg: 2. + real :: vr_fac = 1. ! ifs: if const_vr: 4. real :: vi_max = 0.5 ! max fall speed for ice real :: vs_max = 5.0 ! max fall speed for snow real :: vg_max = 8.0 ! max fall speed for graupel real :: vr_max = 12. ! max fall speed for rain - ! cloud microphysics switchers + real :: xr_a = 0.25 ! p value in xu and randall, 1996 + real :: xr_b = 100. ! alpha_0 value in xu and randall, 1996 + real :: xr_c = 0.49 ! gamma value in xu and randall, 1996 - logical :: fast_sat_adj = .false. ! has fast saturation adjustments + real :: te_err = 1.e-14 ! 64bit: 1.e-14, 32bit: 1.e-7 + + logical :: do_sat_adj = .false. ! has fast saturation adjustments logical :: z_slope_liq = .true. ! use linear mono slope for autocconversions logical :: z_slope_ice = .false. ! use linear mono slope for autocconversions logical :: use_ccn = .false. ! must be true when prog_ccn is false logical :: use_ppm = .false. ! use ppm fall scheme + logical :: use_ppm_ice = .false. ! use ppm fall scheme for cloud ice logical :: mono_prof = .true. ! perform terminal fall with mono ppm scheme - logical :: mp_print = .false. ! cloud microphysics debugging printout logical :: do_hail = .false. ! use hail parameters instead of graupel - - ! real :: global_area = - 1. - - real :: log_10, tice0, t_wfr + logical :: hd_icefall = .false. ! use heymsfield and donner, 1990's fall speed of cloud ice + logical :: use_xr_cloud = .false. ! use xu and randall, 1996's cloud diagnosis + logical :: use_park_cloud = .false. ! park et al. 2016 + logical :: use_gi_cloud = .false. ! gultepe and isaac (2007, grl) + logical :: use_rhc_cevap = .false. ! cap of rh for cloud water evaporation + logical :: use_rhc_revap = .false. ! cap of rh for rain evaporation + logical :: consv_checker = .false. ! turn on energy and water conservation checker + logical :: do_warm_rain_mp = .false. ! do warm rain cloud microphysics only + ! turn off to save time, turn on only in c48 64bit + + real :: g2, log_10 + + real :: rh_thres = 0.75 + real :: rhc_cevap = 0.85 ! cloud water + real :: rhc_revap = 0.85 ! cloud water + + real :: f_dq_p = 1.0 + real :: f_dq_m = 1.0 + logical :: do_cld_adj = .false. + + integer :: inflag = 1 ! ice nucleation scheme + ! 1: hong et al., 2004 + ! 2: meyers et al., 1992 + ! 3: meyers et al., 1992 + ! 4: cooper, 1986 + ! 5: flecther, 1962 ! ----------------------------------------------------------------------- ! namelist ! ----------------------------------------------------------------------- - namelist / gfdl_cloud_microphysics_nml / & - mp_time, t_min, t_sub, tau_r2g, tau_smlt, tau_g2r, dw_land, dw_ocean, & + namelist / gfdl_mp_nml / & + t_min, t_sub, tau_r2g, tau_smlt, tau_g2r, dw_land, dw_ocean, & vi_fac, vr_fac, vs_fac, vg_fac, ql_mlt, do_qa, fix_negative, vi_max, & vs_max, vg_max, vr_max, qs_mlt, qs0_crt, qi_gen, ql0_max, qi0_max, & - qi0_crt, fast_sat_adj, rh_inc, rh_ins, rh_inr, const_vi, & + qi0_crt, do_sat_adj, rh_inc, rh_ins, rh_inr, const_vi, & const_vs, const_vg, const_vr, use_ccn, rthresh, ccn_l, ccn_o, qc_crt, & tau_g2v, tau_v2g, sat_adj0, tau_imlt, tau_v2l, tau_l2v, & tau_i2s, tau_l2r, qi_lim, ql_gen, c_paut, c_psaci, c_pgacs, & z_slope_liq, z_slope_ice, prog_ccn, c_cracw, alin, clin, tice, & - rad_snow, rad_graupel, rad_rain, cld_min, use_ppm, mono_prof, & - do_sedi_heat, sedi_transport, do_sedi_w, de_ice, icloud_f, irain_f, & - mp_print, do_hail + rad_snow, rad_graupel, rad_rain, cld_fac, cld_min, use_ppm, use_ppm_ice, mono_prof, & + do_sedi_heat, sedi_transport, do_sedi_w, icloud_f, irain_f, & + ntimes, disp_heat, do_hail, use_xr_cloud, xr_a, xr_b, xr_c, tau_revp, tice_mlt, hd_icefall, & + do_cond_timescale, mp_time, consv_checker, te_err, use_park_cloud, & + use_gi_cloud, use_rhc_cevap, use_rhc_revap, inflag, do_warm_rain_mp, & + rh_thres, f_dq_p, f_dq_m, do_cld_adj public & - mp_time, t_min, t_sub, tau_r2g, tau_smlt, tau_g2r, dw_land, dw_ocean, & + t_min, t_sub, tau_r2g, tau_smlt, tau_g2r, dw_land, dw_ocean, & vi_fac, vr_fac, vs_fac, vg_fac, ql_mlt, do_qa, fix_negative, vi_max, & vs_max, vg_max, vr_max, qs_mlt, qs0_crt, qi_gen, ql0_max, qi0_max, & - qi0_crt, fast_sat_adj, rh_inc, rh_ins, rh_inr, const_vi, & + qi0_crt, do_sat_adj, rh_inc, rh_ins, rh_inr, const_vi, & const_vs, const_vg, const_vr, use_ccn, rthresh, ccn_l, ccn_o, qc_crt, & tau_g2v, tau_v2g, sat_adj0, tau_imlt, tau_v2l, tau_l2v, & tau_i2s, tau_l2r, qi_lim, ql_gen, c_paut, c_psaci, c_pgacs, & z_slope_liq, z_slope_ice, prog_ccn, c_cracw, alin, clin, tice, & - rad_snow, rad_graupel, rad_rain, cld_min, use_ppm, mono_prof, & - do_sedi_heat, sedi_transport, do_sedi_w, de_ice, icloud_f, irain_f, & - mp_print, do_hail + rad_snow, rad_graupel, rad_rain, cld_fac, cld_min, use_ppm, use_ppm_ice, mono_prof, & + do_sedi_heat, sedi_transport, do_sedi_w, icloud_f, irain_f, & + ntimes, disp_heat, do_hail, use_xr_cloud, xr_a, xr_b, xr_c, tau_revp, tice_mlt, hd_icefall, & + do_cond_timescale, mp_time, consv_checker, te_err, use_park_cloud, & + use_gi_cloud, use_rhc_cevap, use_rhc_revap, inflag, do_warm_rain_mp, & + rh_thres, f_dq_p, f_dq_m, do_cld_adj contains @@ -338,161 +367,98 @@ module gfdl_cloud_microphys_mod ! the driver of the gfdl cloud microphysics ! ----------------------------------------------------------------------- -subroutine gfdl_cloud_microphys_driver (qv, ql, qr, qi, qs, qg, qa, qn, & - qv_dt, ql_dt, qr_dt, qi_dt, qs_dt, qg_dt, qa_dt, pt_dt, pt, w, & - uin, vin, udt, vdt, dz, delp, area, dt_in, land, rain, snow, ice, & - graupel, hydrostatic, phys_hydrostatic, iis, iie, kks, & - kke, ktop, kbot, seconds) +subroutine gfdl_cld_mp_driver (qv, ql, qr, qi, qs, qg, qa, qnl, qni, & + pt, w, ua, va, dz, delp, gsize, dts, hs, rain, snow, ice, & + graupel, hydrostatic, is, ie, ks, ke, q_con, cappa, consv_te, & + te, condensation, deposition, evaporation, sublimation, last_step, do_inline_mp) implicit none - logical, intent (in) :: hydrostatic, phys_hydrostatic - integer, intent (in) :: iis, iie ! physics window - integer, intent (in) :: kks, kke ! vertical dimension - integer, intent (in) :: ktop, kbot ! vertical compute domain - integer, intent (in) :: seconds + logical, intent (in) :: hydrostatic + logical, intent (in) :: last_step + logical, intent (in) :: consv_te + logical, intent (in) :: do_inline_mp - real, intent (in) :: dt_in ! physics time step + integer, intent (in) :: is, ie ! physics window + integer, intent (in) :: ks, ke ! vertical dimension - real, intent (in), dimension (:) :: area ! cell area - real, intent (in), dimension (:) :: land ! land fraction + real, intent (in) :: dts ! physics time step - real, intent (in), dimension (:, :) :: delp, dz, uin, vin - real, intent (in), dimension (:, :) :: pt, qv, ql, qr, qg, qa, qn + real, intent (in), dimension (is:ie) :: hs, gsize - real, intent (inout), dimension (:, :) :: qi, qs - real, intent (inout), dimension (:, :) :: pt_dt, qa_dt, udt, vdt, w - real, intent (inout), dimension (:, :) :: qv_dt, ql_dt, qr_dt - real, intent (inout), dimension (:, :) :: qi_dt, qs_dt, qg_dt + real, intent (in), dimension (is:ie, ks:ke) :: dz + real, intent (in), dimension (is:ie, ks:ke) :: qnl, qni - real, intent (out), dimension (:) :: rain, snow, ice, graupel + real, intent (inout), dimension (is:ie, ks:ke) :: delp + real, intent (inout), dimension (is:ie, ks:ke) :: qv, ql, qr, qi, qs, qg, qa + real, intent (inout), dimension (is:ie, ks:ke) :: pt, ua, va, w + real, intent (inout), dimension (is:, ks:) :: q_con, cappa + real, intent (inout), dimension (is:ie) :: rain, snow, ice, graupel + real, intent (inout), dimension (is:ie) :: condensation, deposition + real, intent (inout), dimension (is:ie) :: evaporation, sublimation + real, intent (inout), dimension (is:ie, ks:ke) :: te ! logical :: used + real, dimension (is:ie) :: w_var + real, dimension (is:ie, ks:ke) :: vt_r, vt_s, vt_g, vt_i + real, dimension (is:ie, ks:ke) :: m2_rain, m2_sol - real :: mpdt, rdt, dts, convt, tot_prec - - integer :: i, k - integer :: is, ie ! physics window - integer :: ks, ke ! vertical dimension - integer :: days, ntimes - - real, dimension (iie - iis + 1) :: prec_mp, prec1, cond, w_var, rh0 - - real, dimension (iie - iis + 1, kke - kks + 1) :: vt_r, vt_s, vt_g, vt_i, qn2 - - real, dimension (iie - iis + 1, kke - kks + 1) :: m2_rain, m2_sol - - real :: allmax - - is = 1 - ks = 1 - ie = iie - iis + 1 - ke = kke - kks + 1 - - ! call mpp_clock_begin (gfdl_mp_clock) + if (last_step) then + p_min = p0_min ! final clean - up + else + p_min = 30.e2 ! time saving trick + endif ! ----------------------------------------------------------------------- ! define heat capacity of dry air and water vapor based on hydrostatical property ! ----------------------------------------------------------------------- - if (phys_hydrostatic .or. hydrostatic) then + if (hydrostatic) then c_air = cp_air c_vap = cp_vap - p_nonhydro = .false. + do_sedi_w = .false. else c_air = cv_air c_vap = cv_vap - p_nonhydro = .true. endif d0_vap = c_vap - c_liq - lv00 = hlv0 - d0_vap * t_ice - - if (hydrostatic) do_sedi_w = .false. - - ! ----------------------------------------------------------------------- - ! define latent heat coefficient used in wet bulb and bigg mechanism - ! ----------------------------------------------------------------------- - latv = hlv - lati = hlf - lats = latv + lati - lat2 = lats * lats + ! scaled constants (to reduce fp errors for 32 - bit) : + d1_vap = d0_vap / c_air + d1_ice = dc_ice / c_air - lcp = latv / cp_air - icp = lati / cp_air - tcp = (latv + lati) / cp_air + ! lv0 = hlv0 - (c_vap - c_liq) * t_ice! 3.13905782e6, evaporation latent heat coefficient at 0 deg k + lv00 = (hlv0 - d0_vap * t_ice) / c_air + li00 = (hlf0 - dc_ice * t_ice) / c_air + li20 = lv00 + li00 - ! tendency zero out for am moist processes should be done outside the driver + c1_vap = c_vap / c_air + c1_liq = c_liq / c_air + c1_ice = c_ice / c_air ! ----------------------------------------------------------------------- - ! define cloud microphysics sub time step + ! define latent heat coefficient used in wet bulb and bigg mechanism ! ----------------------------------------------------------------------- - mpdt = min (dt_in, mp_time) - rdt = 1. / dt_in - ntimes = nint (dt_in / mpdt) - - ! small time step: - dts = dt_in / real (ntimes) - - ! call get_time (time, seconds, days) + lat2 = (hlv + hlf) ** 2 - ! ----------------------------------------------------------------------- - ! initialize precipitation - ! ----------------------------------------------------------------------- + lcp = hlv / cp_air + icp = hlf / cp_air + tcp = (hlv + hlf) / cp_air - do i = is, ie - graupel (i) = 0. - rain (i) = 0. - snow (i) = 0. - ice (i) = 0. - cond (i) = 0. - enddo + ! tendency zero out for am moist processes should be done outside the driver ! ----------------------------------------------------------------------- ! major cloud microphysics ! ----------------------------------------------------------------------- - call mpdrv (hydrostatic, uin, vin, w, delp, pt, qv, ql, qr, qi, qs, qg, & - qa, qn, dz, is, ie, ks, ke, ktop, kbot, dt_in, ntimes, & - rain, snow, graupel, ice, m2_rain, & - m2_sol, cond, area, land, udt, vdt, pt_dt, & - qv_dt, ql_dt, qr_dt, qi_dt, qs_dt, qg_dt, qa_dt, w_var, vt_r, & - vt_s, vt_g, vt_i, qn2) - - ! ----------------------------------------------------------------------- - ! no clouds allowed above ktop - ! ----------------------------------------------------------------------- - - if (ks < ktop) then - do k = ks, ktop - if (do_qa) then - do i = is, ie - qa_dt (i, k) = 0. - enddo - else - do i = is, ie - ! qa_dt (i, k) = - qa (i, k) * rdt - qa_dt (i, k) = 0. ! gfs - enddo - endif - enddo - endif - - ! convert to mm / day - - convt = 86400. * rdt * rgrav - do i = is, ie - rain (i) = rain (i) * convt - snow (i) = snow (i) * convt - ice (i) = ice (i) * convt - graupel (i) = graupel (i) * convt - prec_mp (i) = rain (i) + snow (i) + ice (i) + graupel (i) - enddo - - ! call mpp_clock_end (gfdl_mp_clock) + call mpdrv (hydrostatic, ua, va, w, delp, pt, qv, ql, qr, qi, qs, qg, & + qa, qnl, qni, dz, is, ie, ks, ke, dts, & + rain, snow, graupel, ice, m2_rain, m2_sol, gsize, hs, & + w_var, vt_r, vt_s, vt_g, vt_i, q_con, cappa, consv_te, te, & + condensation, deposition, evaporation, sublimation, last_step, do_inline_mp) -end subroutine gfdl_cloud_microphys_driver +end subroutine gfdl_cld_mp_driver ! ----------------------------------------------------------------------- ! gfdl cloud microphysics, major program @@ -509,58 +475,75 @@ end subroutine gfdl_cloud_microphys_driver ! 6) qg: graupel (kg / kg) ! ----------------------------------------------------------------------- -subroutine mpdrv (hydrostatic, uin, vin, w, delp, pt, qv, ql, qr, qi, qs, & - qg, qa, qn, dz, is, ie, ks, ke, ktop, kbot, dt_in, ntimes, & - rain, snow, graupel, ice, m2_rain, m2_sol, cond, area1, land, & - u_dt, v_dt, pt_dt, qv_dt, ql_dt, qr_dt, qi_dt, qs_dt, qg_dt, qa_dt, & - w_var, vt_r, vt_s, vt_g, vt_i, qn2) +subroutine mpdrv (hydrostatic, ua, va, w, delp, pt, qv, ql, qr, qi, qs, & + qg, qa, qnl, qni, dz, is, ie, ks, ke, dt_in, & + rain, snow, graupel, ice, m2_rain, m2_sol, gsize, hs, & + w_var, vt_r, vt_s, vt_g, vt_i, q_con, cappa, consv_te, te, & + condensation, deposition, evaporation, sublimation, last_step, do_inline_mp) implicit none logical, intent (in) :: hydrostatic - + logical, intent (in) :: last_step + logical, intent (in) :: consv_te + logical, intent (in) :: do_inline_mp integer, intent (in) :: is, ie, ks, ke - integer, intent (in) :: ntimes, ktop, kbot - real, intent (in) :: dt_in - - real, intent (in), dimension (is:) :: area1, land - - real, intent (in), dimension (is:, ks:) :: uin, vin, delp, pt, dz - real, intent (in), dimension (is:, ks:) :: qv, ql, qr, qg, qa, qn - - real, intent (inout), dimension (is:, ks:) :: qi, qs - real, intent (inout), dimension (is:, ks:) :: u_dt, v_dt, w, pt_dt, qa_dt - real, intent (inout), dimension (is:, ks:) :: qv_dt, ql_dt, qr_dt, qi_dt, qs_dt, qg_dt - - real, intent (inout), dimension (is:) :: rain, snow, ice, graupel, cond - - real, intent (out), dimension (is:) :: w_var - - real, intent (out), dimension (is:, ks:) :: vt_r, vt_s, vt_g, vt_i, qn2 - - real, intent (out), dimension (is:, ks:) :: m2_rain, m2_sol - - real, dimension (ktop:kbot) :: qvz, qlz, qrz, qiz, qsz, qgz, qaz - real, dimension (ktop:kbot) :: vtiz, vtsz, vtgz, vtrz - real, dimension (ktop:kbot) :: dp0, dp1, dz0, dz1 - real, dimension (ktop:kbot) :: qv0, ql0, qr0, qi0, qs0, qg0, qa0 - real, dimension (ktop:kbot) :: t0, den, den0, tz, p1, denfac - real, dimension (ktop:kbot) :: ccn, c_praut, m1_rain, m1_sol, m1 - real, dimension (ktop:kbot) :: u0, v0, u1, v1, w1 + real, intent (in), dimension (is:ie) :: gsize + real, intent (in), dimension (is:ie) :: hs + real, intent (in), dimension (is:ie, ks:ke) :: dz + real, intent (in), dimension (is:ie, ks:ke) :: qnl, qni + + real, intent (inout), dimension (is:ie, ks:ke) :: delp + real, intent (inout), dimension (is:ie, ks:ke) :: qv, ql, qr, qi, qs, qg, qa + real, intent (inout), dimension (is:ie, ks:ke) :: pt, ua, va, w + real, intent (inout), dimension (is:, ks:) :: q_con, cappa + real, intent (inout), dimension (is:ie) :: rain, snow, ice, graupel + real, intent (inout), dimension (is:ie) :: condensation, deposition + real, intent (inout), dimension (is:ie) :: evaporation, sublimation + + real, intent (out), dimension (is:ie) :: w_var + real, intent (out), dimension (is:ie, ks:ke) :: vt_r, vt_s, vt_g, vt_i + real, intent (out), dimension (is:ie, ks:ke) :: m2_rain, m2_sol + real, intent (out), dimension (is:ie, ks:ke) :: te + ! local: + real, dimension (ks:ke) :: q_liq, q_sol + real, dimension (ks:ke) :: qvz, qlz, qrz, qiz, qsz, qgz, qaz + real, dimension (ks:ke) :: vtiz, vtsz, vtgz, vtrz + real, dimension (ks:ke) :: dp1, dz1 + real, dimension (ks:ke) :: den, p1, denfac + real, dimension (ks:ke) :: ccn, cin, c_praut, m1_rain, m1_sol, m1 + real, dimension (ks:ke) :: u0, v0, u1, v1, w1 + + real (kind = r_grid), dimension (is:ie, ks:ke) :: te_beg, te_end, tw_beg, tw_end + real (kind = r_grid), dimension (is:ie, ks:ke) :: te_beg_0, te_end_0, tw_beg_0, tw_end_0 + real (kind = r_grid), dimension (is:ie) :: te_b_beg, te_b_end, tw_b_beg, tw_b_end, dte, te_loss + real (kind = r_grid), dimension (is:ie) :: te_b_beg_0, te_b_end_0, tw_b_beg_0, tw_b_end_0 + real (kind = r_grid), dimension (ks:ke) :: te1, te2 real :: cpaut, rh_adj, rh_rain real :: r1, s1, i1, g1, rdt, ccn0 - real :: dt_rain, dts - real :: s_leng, t_land, t_ocean, h_var - real :: cvm, tmp, omq - real :: dqi, qio, qin + real :: dt_rain + real :: s_leng, t_land, t_ocean, h_var, tmp + real (kind = r_grid), dimension (ks:ke) :: dp0, tz, cvm + real (kind = r_grid) :: con_r8, c8 + real :: convt + real :: dts, q_cond + real :: cond, dep, reevap, sub integer :: i, k, n + ntimes = max (ntimes, int (dt_in / min (dt_in, mp_time))) dts = dt_in / real (ntimes) + dt_rain = dts * 0.5 - rdt = 1. / dt_in + rdt = one_r8 / dts + + dte = 0.0 + + ! convert to mm / day + convt = 86400. * rdt * rgrav + cond = 0.0 ! ----------------------------------------------------------------------- ! use local variables @@ -568,93 +551,132 @@ subroutine mpdrv (hydrostatic, uin, vin, w, delp, pt, qv, ql, qr, qi, qs, & do i = is, ie - do k = ktop, kbot - qiz (k) = qi (i, k) - qsz (k) = qs (i, k) + do k = ks, ke + if (do_inline_mp) then +#ifdef MOIST_CAPPA + tz (k) = pt (i, k) / ((1. + zvir * qv (i, k)) * (1. - (ql (i, k) + qr (i, k) + qi (i, k) + qs (i, k) + qg (i, k)))) +#else + tz (k) = pt (i, k) / (1. + zvir * qv (i, k)) +#endif + else + tz (k) = pt (i, k) + endif enddo ! ----------------------------------------------------------------------- - ! this is to prevent excessive build - up of cloud ice from external sources + ! total energy checker ! ----------------------------------------------------------------------- - if (de_ice) then - do k = ktop, kbot - qio = qiz (k) - dt_in * qi_dt (i, k) ! original qi before phys - qin = max (qio, qi0_max) ! adjusted value - if (qiz (k) > qin) then - qsz (k) = qsz (k) + qiz (k) - qin - qiz (k) = qin - dqi = (qin - qio) * rdt ! modified qi tendency - qs_dt (i, k) = qs_dt (i, k) + qi_dt (i, k) - dqi - qi_dt (i, k) = dqi - qi (i, k) = qiz (k) - qs (i, k) = qsz (k) + if (consv_checker) then + do k = ks, ke + q_liq (k) = ql (i, k) + qr (i, k) + q_sol (k) = qi (i, k) + qs (i, k) + qg (i, k) + cvm (k) = c_air * (1.0 - qv (i, k) - q_liq (k) - q_sol (k)) + & + qv (i, k) * c_vap + q_liq (k) * c_liq + q_sol (k) * c_ice + te_beg_0 (i, k) = cvm (k) * tz (k) + lv00 * c_air * qv (i, k) - li00 * c_air * q_sol (k) + if (hydrostatic) then + te_beg_0 (i, k) = te_beg_0 (i, k) + 0.5 * (ua (i, k) ** 2 + va (i, k) ** 2) + else + te_beg_0 (i, k) = te_beg_0 (i, k) + 0.5 * (ua (i, k) ** 2 + va (i, k) ** 2 + w (i, k) ** 2) endif + te_beg_0 (i, k) = rgrav * te_beg_0 (i, k) * delp (i, k) * gsize (i) ** 2.0 + tw_beg_0 (i, k) = rgrav * (qv (i, k) + q_liq (k) + q_sol (k)) * delp (i, k) * gsize (i) ** 2.0 enddo + te_b_beg_0 (i) = (dte (i) - li00 * c_air * (ice (i) + snow (i) + graupel (i)) * dt_in / 86400) * gsize (i) ** 2.0 + tw_b_beg_0 (i) = (rain (i) + ice (i) + snow (i) + graupel (i)) * dt_in / 86400 * gsize (i) ** 2.0 endif - do k = ktop, kbot - - t0 (k) = pt (i, k) - tz (k) = t0 (k) - dp1 (k) = delp (i, k) - dp0 (k) = dp1 (k) ! moist air mass * grav - + do k = ks, ke + dp0 (k) = delp (i, k) ! ----------------------------------------------------------------------- ! convert moist mixing ratios to dry mixing ratios ! ----------------------------------------------------------------------- - qvz (k) = qv (i, k) qlz (k) = ql (i, k) qrz (k) = qr (i, k) + qiz (k) = qi (i, k) + qsz (k) = qs (i, k) qgz (k) = qg (i, k) - - ! dp1: dry air_mass - ! dp1 (k) = dp1 (k) * (1. - (qvz (k) + qlz (k) + qrz (k) + qiz (k) + qsz (k) + qgz (k))) - dp1 (k) = dp1 (k) * (1. - qvz (k)) ! gfs - omq = dp0 (k) / dp1 (k) - - qvz (k) = qvz (k) * omq - qlz (k) = qlz (k) * omq - qrz (k) = qrz (k) * omq - qiz (k) = qiz (k) * omq - qsz (k) = qsz (k) * omq - qgz (k) = qgz (k) * omq - - qa0 (k) = qa (i, k) + ! save moist ratios for te: + q_liq (k) = qlz (k) + qrz (k) + q_sol (k) = qiz (k) + qsz (k) + qgz (k) + q_cond = q_liq (k) + q_sol (k) qaz (k) = 0. - dz0 (k) = dz (i, k) - - den0 (k) = - dp1 (k) / (grav * dz0 (k)) ! density of dry air - p1 (k) = den0 (k) * rdgas * t0 (k) ! dry air pressure - - ! ----------------------------------------------------------------------- - ! save a copy of old value for computing tendencies - ! ----------------------------------------------------------------------- - - qv0 (k) = qvz (k) - ql0 (k) = qlz (k) - qr0 (k) = qrz (k) - qi0 (k) = qiz (k) - qs0 (k) = qsz (k) - qg0 (k) = qgz (k) + dz1 (k) = dz (i, k) + con_r8 = one_r8 - (qvz (k) + q_cond) + ! dp1 is dry mass (no change during mp) + dp1 (k) = dp0 (k) * con_r8 + con_r8 = one_r8 / con_r8 + qvz (k) = qvz (k) * con_r8 + qlz (k) = qlz (k) * con_r8 + qrz (k) = qrz (k) * con_r8 + qiz (k) = qiz (k) * con_r8 + qsz (k) = qsz (k) * con_r8 + qgz (k) = qgz (k) * con_r8 + + den (k) = - dp1 (k) / (grav * dz1 (k)) ! density of dry air + p1 (k) = den (k) * rdgas * tz (k) ! dry air pressure ! ----------------------------------------------------------------------- - ! for sedi_momentum + ! for sedi_momentum transport: ! ----------------------------------------------------------------------- m1 (k) = 0. - u0 (k) = uin (i, k) - v0 (k) = vin (i, k) + u0 (k) = ua (i, k) + v0 (k) = va (i, k) + if (.not. hydrostatic) then + w1 (k) = w (i, k) + endif u1 (k) = u0 (k) v1 (k) = v0 (k) - + denfac (k) = sqrt (sfcrho / den (k)) enddo - if (do_sedi_w) then - do k = ktop, kbot - w1 (k) = w (i, k) + ! ----------------------------------------------------------------------- + ! fix energy conservation + ! ----------------------------------------------------------------------- + + if (consv_te) then + if (hydrostatic) then + do k = ks, ke + te (i, k) = - c_air * tz (k) * delp (i, k) + enddo + else + do k = ks, ke +#ifdef MOIST_CAPPA + q_liq (k) = ql (i, k) + qr (i, k) + q_sol (k) = qi (i, k) + qs (i, k) + qg (i, k) + q_cond = q_liq (k) + q_sol (k) + cvm (k) = (one_r8 - (qv (i, k) + q_cond)) * c_air + & + qv (i, k) * c_vap + q_liq (k) * c_liq + q_sol (k) * c_ice + te (i, k) = - cvm (k) * tz (k) * delp (i, k) +#else + te (i, k) = - c_air * tz (k) * delp (i, k) +#endif + enddo + endif + endif + + ! ----------------------------------------------------------------------- + ! total energy checker + ! ----------------------------------------------------------------------- + + if (consv_checker) then + do k = ks, ke + q_liq (k) = qlz (k) + qrz (k) + q_sol (k) = qiz (k) + qsz (k) + qgz (k) + cvm (k) = c_air + qvz (k) * c_vap + q_liq (k) * c_liq + q_sol (k) * c_ice + te_beg (i, k) = cvm (k) * tz (k) + lv00 * c_air * qvz (k) - li00 * c_air * q_sol (k) + if (hydrostatic) then + te_beg (i, k) = te_beg (i, k) + 0.5 * (u1 (k) ** 2 + v1 (k) ** 2) + else + te_beg (i, k) = te_beg (i, k) + 0.5 * (u1 (k) ** 2 + v1 (k) ** 2 + w1 (k) ** 2) + endif + te_beg (i, k) = rgrav * te_beg (i, k) * dp1 (k) * gsize (i) ** 2.0 + tw_beg (i, k) = rgrav * (qvz (k) + q_liq (k) + q_sol (k)) * dp1 (k) * gsize (i) ** 2.0 enddo + te_b_beg (i) = (dte (i) - li00 * c_air * (ice (i) + snow (i) + graupel (i)) * dt_in / 86400) * gsize (i) ** 2.0 + tw_b_beg (i) = (rain (i) + ice (i) + snow (i) + graupel (i)) * dt_in / 86400 * gsize (i) ** 2.0 endif ! ----------------------------------------------------------------------- @@ -665,24 +687,20 @@ subroutine mpdrv (hydrostatic, uin, vin, w, delp, pt, qv, ql, qr, qi, qs, & cpaut = c_paut * 0.104 * grav / 1.717e-5 if (prog_ccn) then - do k = ktop, kbot - ! convert # / cc to # / m^3 - ccn (k) = qn (i, k) * 1.e6 + do k = ks, ke + ! convert # / cm^3 to # / m^3 + ccn (k) = max (10.0, qnl (i, k)) * 1.e6 + cin (k) = max (10.0, qni (i, k)) * 1.e6 + ccn (k) = ccn (k) / den (k) c_praut (k) = cpaut * (ccn (k) * rhor) ** (- 1. / 3.) enddo - use_ccn = .false. else - ccn0 = (ccn_l * land (i) + ccn_o * (1. - land (i))) * 1.e6 - if (use_ccn) then - ! ----------------------------------------------------------------------- - ! ccn is formulted as ccn = ccn_surface * (den / den_surface) - ! ----------------------------------------------------------------------- - ccn0 = ccn0 * rdgas * tz (kbot) / p1 (kbot) - endif - tmp = cpaut * (ccn0 * rhor) ** (- 1. / 3.) - do k = ktop, kbot - c_praut (k) = tmp - ccn (k) = ccn0 + ! convert # / cm^3 to # / m^3 + ccn0 = (ccn_l * min (1., abs (hs (i)) / (10. * grav)) + & + ccn_o * (1. - min (1., abs (hs (i)) / (10. * grav)))) * 1.e6 + do k = ks, ke + ccn (k) = ccn0 / den (k) + c_praut (k) = cpaut * (ccn (k) * rhor) ** (- 1. / 3.) enddo endif @@ -692,15 +710,15 @@ subroutine mpdrv (hydrostatic, uin, vin, w, delp, pt, qv, ql, qr, qi, qs, & ! default area dependent form: use dx ~ 100 km as the base ! ----------------------------------------------------------------------- - s_leng = sqrt (sqrt (area1 (i) / 1.e10)) + s_leng = sqrt (gsize (i) / 1.e5) t_land = dw_land * s_leng t_ocean = dw_ocean * s_leng - h_var = t_land * land (i) + t_ocean * (1. - land (i)) + tmp = min (1., abs (hs (i)) / (10. * grav)) + h_var = t_land * tmp + t_ocean * (1. - tmp) h_var = min (0.20, max (0.01, h_var)) - ! if (id_var > 0) w_var (i) = h_var ! ----------------------------------------------------------------------- - ! relative humidity increment + ! relative humidity thresholds ! ----------------------------------------------------------------------- rh_adj = 1. - h_var - rh_inc @@ -711,41 +729,26 @@ subroutine mpdrv (hydrostatic, uin, vin, w, delp, pt, qv, ql, qr, qi, qs, & ! ----------------------------------------------------------------------- if (fix_negative) & - call neg_adj (ktop, kbot, tz, dp1, qvz, qlz, qrz, qiz, qsz, qgz) + call neg_adj (ks, ke, tz, dp1, qvz, qlz, qrz, qiz, qsz, qgz, cond) + + condensation (i) = condensation (i) + cond * convt * ntimes m2_rain (i, :) = 0. m2_sol (i, :) = 0. do n = 1, ntimes - ! ----------------------------------------------------------------------- - ! define air density based on hydrostatical property - ! ----------------------------------------------------------------------- - - if (p_nonhydro) then - do k = ktop, kbot - dz1 (k) = dz0 (k) - den (k) = den0 (k) ! dry air density remains the same - denfac (k) = sqrt (sfcrho / den (k)) - enddo - else - do k = ktop, kbot - dz1 (k) = dz0 (k) * tz (k) / t0 (k) ! hydrostatic balance - den (k) = den0 (k) * dz0 (k) / dz1 (k) - denfac (k) = sqrt (sfcrho / den (k)) - enddo - endif - ! ----------------------------------------------------------------------- ! time - split warm rain processes: 1st pass ! ----------------------------------------------------------------------- - call warm_rain (dt_rain, ktop, kbot, dp1, dz1, tz, qvz, qlz, qrz, qiz, qsz, & - qgz, den, denfac, ccn, c_praut, rh_rain, vtrz, r1, m1_rain, w1, h_var) + call warm_rain (dt_rain, ks, ke, dp1, dz1, tz, qvz, qlz, qrz, qiz, qsz, & + qgz, den, denfac, ccn, c_praut, rh_rain, vtrz, r1, m1_rain, w1, h_var, reevap, dte (i)) - rain (i) = rain (i) + r1 + evaporation (i) = evaporation (i) + reevap * convt + rain (i) = rain (i) + r1 * convt - do k = ktop, kbot + do k = ks, ke m2_rain (i, k) = m2_rain (i, k) + m1_rain (k) m1 (k) = m1 (k) + m1_rain (k) enddo @@ -754,34 +757,59 @@ subroutine mpdrv (hydrostatic, uin, vin, w, delp, pt, qv, ql, qr, qi, qs, & ! sedimentation of cloud ice, snow, and graupel ! ----------------------------------------------------------------------- - call fall_speed (ktop, kbot, den, qsz, qiz, qgz, qlz, tz, vtsz, vtiz, vtgz) + call fall_speed (ks, ke, den, qsz, qiz, qgz, qlz, tz, vtsz, vtiz, vtgz) + + call terminal_fall (dts, ks, ke, tz, qvz, qlz, qrz, qgz, qsz, qiz, & + dz1, dp1, den, vtgz, vtsz, vtiz, r1, g1, s1, i1, m1_sol, w1, dte (i)) - call terminal_fall (dts, ktop, kbot, tz, qvz, qlz, qrz, qgz, qsz, qiz, & - dz1, dp1, den, vtgz, vtsz, vtiz, r1, g1, s1, i1, m1_sol, w1) + rain (i) = rain (i) + r1 * convt ! from melted snow & ice that reached the ground + snow (i) = snow (i) + s1 * convt + graupel (i) = graupel (i) + g1 * convt + ice (i) = ice (i) + i1 * convt - rain (i) = rain (i) + r1 ! from melted snow & ice that reached the ground - snow (i) = snow (i) + s1 - graupel (i) = graupel (i) + g1 - ice (i) = ice (i) + i1 + ! ----------------------------------------------------------------------- + ! energy loss during sedimentation heating + ! ----------------------------------------------------------------------- + + if (consv_checker) then + do k = ks, ke + te1 (k) = one_r8 + qvz (k) * c1_vap + (qlz (k) + qrz (k)) * c1_liq + (qiz (k) + qsz (k) + qgz (k)) * c1_ice + te1 (k) = rgrav * te1 (k) * c_air * tz (k) * dp1 (k) + enddo + endif ! ----------------------------------------------------------------------- ! heat transportation during sedimentation ! ----------------------------------------------------------------------- - if (do_sedi_heat) & - call sedi_heat (ktop, kbot, dp1, m1_sol, dz1, tz, qvz, qlz, qrz, qiz, & - qsz, qgz, c_ice) + if (do_sedi_heat) then + call sedi_heat (ks, ke, dp1, m1_sol, dz1, tz, qvz, qlz, qrz, qiz, & + qsz, qgz, c_ice) + endif + + ! ----------------------------------------------------------------------- + ! energy loss during sedimentation heating + ! ----------------------------------------------------------------------- + + if (consv_checker) then + do k = ks, ke + te2 (k) = one_r8 + qvz (k) * c1_vap + (qlz (k) + qrz (k)) * c1_liq + (qiz (k) + qsz (k) + qgz (k)) * c1_ice + te2 (k) = rgrav * te2 (k) * c_air * tz (k) * dp1 (k) + enddo + dte (i) = dte (i) + sum (te1) - sum (te2) + endif ! ----------------------------------------------------------------------- ! time - split warm rain processes: 2nd pass ! ----------------------------------------------------------------------- - call warm_rain (dt_rain, ktop, kbot, dp1, dz1, tz, qvz, qlz, qrz, qiz, qsz, & - qgz, den, denfac, ccn, c_praut, rh_rain, vtrz, r1, m1_rain, w1, h_var) + call warm_rain (dt_rain, ks, ke, dp1, dz1, tz, qvz, qlz, qrz, qiz, qsz, & + qgz, den, denfac, ccn, c_praut, rh_rain, vtrz, r1, m1_rain, w1, h_var, reevap, dte (i)) - rain (i) = rain (i) + r1 + evaporation (i) = evaporation (i) + reevap * convt + rain (i) = rain (i) + r1 * convt - do k = ktop, kbot + do k = ks, ke m2_rain (i, k) = m2_rain (i, k) + m1_rain (k) m2_sol (i, k) = m2_sol (i, k) + m1_sol (k) m1 (k) = m1 (k) + m1_rain (k) + m1_sol (k) @@ -791,8 +819,14 @@ subroutine mpdrv (hydrostatic, uin, vin, w, delp, pt, qv, ql, qr, qi, qs, & ! ice - phase microphysics ! ----------------------------------------------------------------------- - call icloud (ktop, kbot, tz, p1, qvz, qlz, qrz, qiz, qsz, qgz, dp1, den, & - denfac, vtsz, vtgz, vtrz, qaz, rh_adj, rh_rain, dts, h_var) + call icloud (ks, ke, tz, p1, qvz, qlz, qrz, qiz, qsz, qgz, dp1, den, ccn, & + cin, denfac, vtsz, vtgz, vtrz, qaz, rh_adj, rh_rain, dts, h_var, gsize (i), & + cond, dep, reevap, sub, last_step) + + condensation (i) = condensation (i) + cond * convt + deposition (i) = deposition (i) + dep * convt + evaporation (i) = evaporation (i) + reevap * convt + sublimation (i) = sublimation (i) + sub * convt enddo @@ -802,144 +836,213 @@ subroutine mpdrv (hydrostatic, uin, vin, w, delp, pt, qv, ql, qr, qi, qs, & ! ----------------------------------------------------------------------- if (sedi_transport) then - do k = ktop + 1, kbot + do k = ks + 1, ke u1 (k) = (dp0 (k) * u1 (k) + m1 (k - 1) * u1 (k - 1)) / (dp0 (k) + m1 (k - 1)) v1 (k) = (dp0 (k) * v1 (k) + m1 (k - 1) * v1 (k - 1)) / (dp0 (k) + m1 (k - 1)) - u_dt (i, k) = u_dt (i, k) + (u1 (k) - u0 (k)) * rdt - v_dt (i, k) = v_dt (i, k) + (v1 (k) - v0 (k)) * rdt + ua (i, k) = u1 (k) + va (i, k) = v1 (k) enddo + ! sjl modify tz due to ke loss: + ! seperate loop (vectorize better with no k - dependency) + if (disp_heat) then + do k = ks + 1, ke +#ifdef MOIST_CAPPA + c8 = c_air + qvz (k) * c_vap + (qrz (k) + qlz (k)) * c_liq + (qiz (k) + qsz (k) + qgz (k)) * c_ice + tz (k) = tz (k) + 0.5 * (u0 (k) ** 2 + v0 (k) ** 2 - (u1 (k) ** 2 + v1 (k) ** 2)) / c8 +#else + tz (k) = tz (k) + 0.5 * (u0 (k) ** 2 + v0 (k) ** 2 - (u1 (k) ** 2 + v1 (k) ** 2)) / c_air +#endif + enddo + endif endif if (do_sedi_w) then - do k = ktop, kbot + ! conserve local te + !#ifdef disp_w + if (disp_heat) then + do k = ks, ke +#ifdef MOIST_CAPPA + c8 = c_air + qvz (k) * c_vap + (qrz (k) + qlz (k)) * c_liq + (qiz (k) + qsz (k) + qgz (k)) * c_ice + tz (k) = tz (k) + 0.5 * (w (i, k) ** 2 - w1 (k) ** 2) / c8 +#else + tz (k) = tz (k) + 0.5 * (w (i, k) ** 2 - w1 (k) ** 2) / c_air +#endif + enddo + endif + !#endif + do k = ks, ke w (i, k) = w1 (k) enddo endif + ! ----------------------------------------------------------------------- + ! total energy checker + ! ----------------------------------------------------------------------- + + if (consv_checker) then + do k = ks, ke + q_liq (k) = qlz (k) + qrz (k) + q_sol (k) = qiz (k) + qsz (k) + qgz (k) + cvm (k) = c_air + qvz (k) * c_vap + q_liq (k) * c_liq + q_sol (k) * c_ice + te_end (i, k) = cvm (k) * tz (k) + lv00 * c_air * qvz (k) - li00 * c_air * q_sol (k) + if (hydrostatic) then + te_end (i, k) = te_end (i, k) + 0.5 * (u1 (k) ** 2 + v1 (k) ** 2) + else + te_end (i, k) = te_end (i, k) + 0.5 * (u1 (k) ** 2 + v1 (k) ** 2 + w1 (k) ** 2) + endif + te_end (i, k) = rgrav * te_end (i, k) * dp1 (k) * gsize (i) ** 2.0 + tw_end (i, k) = rgrav * (qvz (k) + q_liq (k) + q_sol (k)) * dp1 (k) * gsize (i) ** 2.0 + enddo + te_b_end (i) = (dte (i) - li00 * c_air * (ice (i) + snow (i) + graupel (i)) * dt_in / 86400) * gsize (i) ** 2.0 + tw_b_end (i) = (rain (i) + ice (i) + snow (i) + graupel (i)) * dt_in / 86400 * gsize (i) ** 2.0 + ! total energy loss due to sedimentation and its heating + te_loss (i) = dte (i) * gsize (i) ** 2.0 + endif + ! ----------------------------------------------------------------------- ! update moist air mass (actually hydrostatic pressure) ! convert to dry mixing ratios ! ----------------------------------------------------------------------- - do k = ktop, kbot - omq = dp1 (k) / dp0 (k) - qv_dt (i, k) = qv_dt (i, k) + rdt * (qvz (k) - qv0 (k)) * omq - ql_dt (i, k) = ql_dt (i, k) + rdt * (qlz (k) - ql0 (k)) * omq - qr_dt (i, k) = qr_dt (i, k) + rdt * (qrz (k) - qr0 (k)) * omq - qi_dt (i, k) = qi_dt (i, k) + rdt * (qiz (k) - qi0 (k)) * omq - qs_dt (i, k) = qs_dt (i, k) + rdt * (qsz (k) - qs0 (k)) * omq - qg_dt (i, k) = qg_dt (i, k) + rdt * (qgz (k) - qg0 (k)) * omq - cvm = c_air + qvz (k) * c_vap + (qrz (k) + qlz (k)) * c_liq + (qiz (k) + qsz (k) + qgz (k)) * c_ice - pt_dt (i, k) = pt_dt (i, k) + rdt * (tz (k) - t0 (k)) * cvm / cp_air + do k = ks, ke + ! total mass changed due to sedimentation !!! + con_r8 = one_r8 + qvz (k) + qlz (k) + qrz (k) + qiz (k) + qsz (k) + qgz (k) + delp (i, k) = dp1 (k) * con_r8 + ! convert back to moist mixing ratios + con_r8 = one_r8 / con_r8 + qvz (k) = qvz (k) * con_r8 + qlz (k) = qlz (k) * con_r8 + qrz (k) = qrz (k) * con_r8 + qiz (k) = qiz (k) * con_r8 + qsz (k) = qsz (k) * con_r8 + qgz (k) = qgz (k) * con_r8 + ! all are moist mixing ratios at this point on: + qv (i, k) = qvz (k) + ql (i, k) = qlz (k) + qr (i, k) = qrz (k) + qi (i, k) = qiz (k) + qs (i, k) = qsz (k) + qg (i, k) = qgz (k) + q_liq (k) = qlz (k) + qrz (k) + q_sol (k) = qiz (k) + qsz (k) + qgz (k) + q_cond = q_liq (k) + q_sol (k) + cvm (k) = (one_r8 - (qvz (k) + q_cond)) * c_air + qvz (k) * c_vap + q_liq (k) * c_liq + q_sol (k) * c_ice +#ifdef MOIST_CAPPA + q_con (i, k) = q_cond + tmp = rdgas * (1. + zvir * qvz (k)) + cappa (i, k) = tmp / (tmp + cvm (k)) +#endif + if (do_inline_mp) then +#ifdef MOIST_CAPPA + pt (i, k) = tz (k) * (1. + zvir * qvz (k)) * (1. - q_cond) +#else + pt (i, k) = tz (k) * (1. + zvir * qvz (k)) +#endif + else + pt (i, k) = pt (i, k) + (tz (k) - pt (i, k)) * cvm (k) / cp_air + endif enddo ! ----------------------------------------------------------------------- - ! update cloud fraction tendency + ! total energy checker + ! ----------------------------------------------------------------------- + + if (consv_checker) then + do k = ks, ke + q_liq (k) = ql (i, k) + qr (i, k) + q_sol (k) = qi (i, k) + qs (i, k) + qg (i, k) + cvm (k) = c_air * (1.0 - qv (i, k) - q_liq (k) - q_sol (k)) + & + qv (i, k) * c_vap + q_liq (k) * c_liq + q_sol (k) * c_ice + te_end_0 (i, k) = cvm (k) * tz (k) + lv00 * c_air * qv (i, k) - li00 * c_air * q_sol (k) + te_end_0 (i, k) = te_end_0 (i, k) + 0.5 * (ua (i, k) ** 2 + va (i, k) ** 2 + w (i, k) ** 2) + te_end_0 (i, k) = rgrav * te_end_0 (i, k) * delp (i, k) * gsize (i) ** 2.0 + tw_end_0 (i, k) = rgrav * (qv (i, k) + q_liq (k) + q_sol (k)) * delp (i, k) * gsize (i) ** 2.0 + enddo + te_b_end_0 (i) = (dte (i) - li00 * c_air * (ice (i) + snow (i) + graupel (i)) * dt_in / 86400) * gsize (i) ** 2.0 + tw_b_end_0 (i) = (rain (i) + ice (i) + snow (i) + graupel (i)) * dt_in / 86400 * gsize (i) ** 2.0 + endif + + ! ----------------------------------------------------------------------- + ! fix energy conservation ! ----------------------------------------------------------------------- - do k = ktop, kbot - if (do_qa) then - qa_dt (i, k) = 0. + if (consv_te) then + if (hydrostatic) then + do k = ks, ke + te (i, k) = te (i, k) + c_air * tz (k) * delp (i, k) + enddo else - qa_dt (i, k) = qa_dt (i, k) + rdt * (qaz (k) / real (ntimes) - qa0 (k)) + do k = ks, ke +#ifdef MOIST_CAPPA + te (i, k) = te (i, k) + cvm (k) * tz (k) * delp (i, k) +#else + te (i, k) = te (i, k) + c_air * tz (k) * delp (i, k) +#endif + enddo endif - enddo + endif ! ----------------------------------------------------------------------- - ! fms diagnostics: + ! update cloud fraction tendency ! ----------------------------------------------------------------------- - ! if (id_cond > 0) then - ! do k = ktop, kbot ! total condensate - ! cond (i) = cond (i) + dp1 (k) * (qlz (k) + qrz (k) + qsz (k) + qiz (k) + qgz (k)) - ! enddo - ! endif - ! - ! if (id_vtr > 0) then - ! do k = ktop, kbot - ! vt_r (i, k) = vtrz (k) - ! enddo - ! endif - ! - ! if (id_vts > 0) then - ! do k = ktop, kbot - ! vt_s (i, k) = vtsz (k) - ! enddo - ! endif - ! - ! if (id_vtg > 0) then - ! do k = ktop, kbot - ! vt_g (i, k) = vtgz (k) - ! enddo - ! endif - ! - ! if (id_vts > 0) then - ! do k = ktop, kbot - ! vt_i (i, k) = vtiz (k) - ! enddo - ! endif - ! - ! if (id_droplets > 0) then - ! do k = ktop, kbot - ! qn2 (i, k) = ccn (k) - ! enddo - ! endif + do k = ks, ke + qa (i, k) = qaz (k) + enddo enddo + ! ----------------------------------------------------------------------- + ! total energy checker + ! ----------------------------------------------------------------------- + + if (consv_checker) then + if (abs (sum (te_end) + sum (te_b_end) - sum (te_beg) - sum (te_b_beg)) / (sum (te_beg) + sum (te_b_beg)) .gt. te_err) then + print *, "gfdl_cld_mp te: ", sum (te_beg) / sum (gsize ** 2) + sum (te_b_beg) / sum (gsize ** 2), & + sum (te_end) / sum (gsize ** 2) + sum (te_b_end) / sum (gsize ** 2), & + (sum (te_end) + sum (te_b_end) - sum (te_beg) - sum (te_b_beg)) / (sum (te_beg) + sum (te_b_beg)) + endif + if (abs (sum (tw_end) + sum (tw_b_end) - sum (tw_beg) - sum (tw_b_beg)) / (sum (tw_beg) + sum (tw_b_beg)) .gt. te_err) then + print *, "gfdl_cld_mp tw: ", sum (tw_beg) / sum (gsize ** 2) + sum (tw_b_beg) / sum (gsize ** 2), & + sum (tw_end) / sum (gsize ** 2) + sum (tw_b_end) / sum (gsize ** 2), & + (sum (tw_end) + sum (tw_b_end) - sum (tw_beg) - sum (tw_b_beg)) / (sum (tw_beg) + sum (tw_b_beg)) + endif + ! print *, "gfdl_cld_mp te loss (%) : ", sum (te_loss) / (sum (te_beg) + sum (te_b_beg)) * 100.0 + endif + end subroutine mpdrv ! ----------------------------------------------------------------------- ! sedimentation of heat ! ----------------------------------------------------------------------- -subroutine sedi_heat (ktop, kbot, dm, m1, dz, tz, qv, ql, qr, qi, qs, qg, cw) - - implicit none - +subroutine sedi_heat (ks, ke, dm, m1, dz, tz, qv, ql, qr, qi, qs, qg, cw) + ! revised with a precise energy conserving form: s. - j. lin, jan 22, 2018 ! input q fields are dry mixing ratios, and dm is dry air mass - - integer, intent (in) :: ktop, kbot - - real, intent (in), dimension (ktop:kbot) :: dm, m1, dz, qv, ql, qr, qi, qs, qg - - real, intent (inout), dimension (ktop:kbot) :: tz - + implicit none + integer, intent (in) :: ks, ke + real, intent (in), dimension (ks:ke) :: dm, m1, dz, qv, ql, qr, qi, qs, qg + real (kind = r_grid), intent (inout), dimension (ks:ke) :: tz real, intent (in) :: cw ! heat capacity - - real, dimension (ktop:kbot) :: dgz, cvn - - real :: tmp - + ! local: + real, dimension (ks:ke) :: dgz, cv0 integer :: k - do k = ktop, kbot - dgz (k) = - 0.5 * grav * dz (k) ! > 0 - cvn (k) = dm (k) * (cv_air + qv (k) * cv_vap + (qr (k) + ql (k)) * & - c_liq + (qi (k) + qs (k) + qg (k)) * c_ice) + ! this is the vectorized loop + do k = ks + 1, ke + dgz (k) = - g2 * (dz (k - 1) + dz (k)) + cv0 (k) = dm (k) * (cv_air + qv (k) * cv_vap + (qr (k) + ql (k)) * c_liq + & + (qi (k) + qs (k) + qg (k)) * c_ice) + cw * (m1 (k) - m1 (k - 1)) + ! cvm_new + cw * m1 (k) = cvm_old + cw * m1 (k - 1) enddo - - ! ----------------------------------------------------------------------- - ! sjl, july 2014 - ! assumption: the ke in the falling condensates is negligible compared to the potential energy - ! that was unaccounted for. local thermal equilibrium is assumed, and the loss in pe is transformed - ! into internal energy (to heat the whole grid box) - ! backward time - implicit upwind transport scheme: - ! dm here is dry air mass - ! ----------------------------------------------------------------------- - - k = ktop - tmp = cvn (k) + m1 (k) * cw - tz (k) = (tmp * tz (k) + m1 (k) * dgz (k)) / tmp - ! ----------------------------------------------------------------------- ! implicit algorithm: can't be vectorized ! needs an inner i - loop for vectorization ! ----------------------------------------------------------------------- - - do k = ktop + 1, kbot - tz (k) = ((cvn (k) + cw * (m1 (k) - m1 (k - 1))) * tz (k) + m1 (k - 1) * & - cw * tz (k - 1) + dgz (k) * (m1 (k - 1) + m1 (k))) / (cvn (k) + cw * m1 (k)) + ! top layer: cv0 = cvn + cw * m1 (k) + ! tz (k) = cv0 (k) * tz (k) / (cvn (k) + cw * m1 (k)) = tz (k) -- > no change + do k = ks + 1, ke + tz (k) = (cv0 (k) * tz (k) + m1 (k - 1) * (cw * tz (k - 1) + dgz (k))) / (cv0 (k) + cw * m1 (k - 1)) enddo end subroutine sedi_heat @@ -948,43 +1051,37 @@ end subroutine sedi_heat ! warm rain cloud microphysics ! ----------------------------------------------------------------------- -subroutine warm_rain (dt, ktop, kbot, dp, dz, tz, qv, ql, qr, qi, qs, qg, & - den, denfac, ccn, c_praut, rh_rain, vtr, r1, m1_rain, w1, h_var) +subroutine warm_rain (dt, ks, ke, dp, dz, tz, qv, ql, qr, qi, qs, qg, & + den, denfac, ccn, c_praut, rh_rain, vtr, r1, m1_rain, w1, h_var, reevap, dte) implicit none - integer, intent (in) :: ktop, kbot - + integer, intent (in) :: ks, ke real, intent (in) :: dt ! time step (s) real, intent (in) :: rh_rain, h_var + real, intent (in), dimension (ks:ke) :: dp, dz, den + real, intent (in), dimension (ks:ke) :: denfac, ccn, c_praut - real, intent (in), dimension (ktop:kbot) :: dp, dz, den - real, intent (in), dimension (ktop:kbot) :: denfac, ccn, c_praut - - real, intent (inout), dimension (ktop:kbot) :: tz, vtr - real, intent (inout), dimension (ktop:kbot) :: qv, ql, qr, qi, qs, qg - real, intent (inout), dimension (ktop:kbot) :: m1_rain, w1 - + real (kind = r_grid), intent (inout), dimension (ks:ke) :: tz + real, intent (inout), dimension (ks:ke) :: vtr, qv, ql, qr, qi, qs, qg, m1_rain, w1 + real (kind = r_grid), intent (inout) :: dte real, intent (out) :: r1 - + real, intent (out) :: reevap real, parameter :: so3 = 7. / 3. + ! fall velocity constants: + real, parameter :: vconr = 2503.23638966667 + real, parameter :: normr = 25132741228.7183 + real, parameter :: thr = 1.e-8 - real, dimension (ktop:kbot) :: dl, dm - real, dimension (ktop:kbot + 1) :: ze, zt - - real :: sink, dq, qc0, qc + real, dimension (ks:ke) :: dl, dm + real (kind = r_grid), dimension (ks:ke) :: te1, te2 + real, dimension (ks:ke + 1) :: ze, zt + real :: sink, dq, qc real :: qden real :: zs = 0. real :: dt5 - integer :: k - ! fall velocity constants: - - real, parameter :: vconr = 2503.23638966667 - real, parameter :: normr = 25132741228.7183 - real, parameter :: thr = 1.e-8 - logical :: no_fall dt5 = 0.5 * dt @@ -995,7 +1092,9 @@ subroutine warm_rain (dt, ktop, kbot, dp, dz, tz, qv, ql, qr, qi, qs, qg, & m1_rain (:) = 0. - call check_column (ktop, kbot, qr, no_fall) + call check_column (ks, ke, qr, no_fall) + + reevap = 0 if (no_fall) then vtr (:) = vf_min @@ -1009,7 +1108,7 @@ subroutine warm_rain (dt, ktop, kbot, dp, dz, tz, qv, ql, qr, qi, qs, qg, & if (const_vr) then vtr (:) = vr_fac ! ifs_2016: 4.0 else - do k = ktop, kbot + do k = ks, ke qden = qr (k) * den (k) if (qr (k) < thr) then vtr (k) = vr_min @@ -1021,8 +1120,8 @@ subroutine warm_rain (dt, ktop, kbot, dp, dz, tz, qv, ql, qr, qi, qs, qg, & enddo endif - ze (kbot + 1) = zs - do k = kbot, ktop, - 1 + ze (ke + 1) = zs + do k = ke, ks, - 1 ze (k) = ze (k + 1) - dz (k) ! dz < 0 enddo @@ -1030,32 +1129,54 @@ subroutine warm_rain (dt, ktop, kbot, dp, dz, tz, qv, ql, qr, qi, qs, qg, & ! evaporation and accretion of rain for the first 1 / 2 time step ! ----------------------------------------------------------------------- - ! if (.not. fast_sat_adj) & - call revap_racc (ktop, kbot, dt5, tz, qv, ql, qr, qi, qs, qg, den, denfac, rh_rain, h_var) + call revap_racc (ks, ke, dt5, tz, qv, ql, qr, qi, qs, qg, den, denfac, rh_rain, h_var, dp, reevap) if (do_sedi_w) then - do k = ktop, kbot + do k = ks, ke dm (k) = dp (k) * (1. + qv (k) + ql (k) + qr (k) + qi (k) + qs (k) + qg (k)) enddo endif ! ----------------------------------------------------------------------- - ! mass flux induced by falling rain + ! energy loss during sedimentation ! ----------------------------------------------------------------------- - if (use_ppm) then - zt (ktop) = ze (ktop) - do k = ktop + 1, kbot + if (consv_checker) then + do k = ks, ke + te1 (k) = one_r8 + qv (k) * c1_vap + (ql (k) + qr (k)) * c1_liq + (qi (k) + qs (k) + qg (k)) * c1_ice + te1 (k) = rgrav * te1 (k) * c_air * tz (k) * dp (k) + enddo + endif + + ! ----------------------------------------------------------------------- + ! mass flux induced by falling rain + ! ----------------------------------------------------------------------- + + if (use_ppm) then + zt (ks) = ze (ks) + do k = ks + 1, ke zt (k) = ze (k) - dt5 * (vtr (k - 1) + vtr (k)) enddo - zt (kbot + 1) = zs - dt * vtr (kbot) + zt (ke + 1) = zs - dt * vtr (ke) - do k = ktop, kbot + do k = ks, ke if (zt (k + 1) >= zt (k)) zt (k + 1) = zt (k) - dz_min enddo - call lagrangian_fall_ppm (ktop, kbot, zs, ze, zt, dp, qr, r1, m1_rain, mono_prof) + call lagrangian_fall_ppm (ks, ke, zs, ze, zt, dp, qr, r1, m1_rain, mono_prof) else - call implicit_fall (dt, ktop, kbot, ze, vtr, dp, qr, r1, m1_rain) + call implicit_fall (dt, ks, ke, ze, vtr, dp, qr, r1, m1_rain) + endif + + ! ----------------------------------------------------------------------- + ! energy loss during sedimentation + ! ----------------------------------------------------------------------- + + if (consv_checker) then + do k = ks, ke + te2 (k) = one_r8 + qv (k) * c1_vap + (ql (k) + qr (k)) * c1_liq + (qi (k) + qs (k) + qg (k)) * c1_ice + te2 (k) = rgrav * te2 (k) * c_air * tz (k) * dp (k) + enddo + dte = dte + sum (te1) - sum (te2) endif ! ----------------------------------------------------------------------- @@ -1063,25 +1184,51 @@ subroutine warm_rain (dt, ktop, kbot, dp, dz, tz, qv, ql, qr, qi, qs, qg, & ! ----------------------------------------------------------------------- if (do_sedi_w) then - w1 (ktop) = (dm (ktop) * w1 (ktop) + m1_rain (ktop) * vtr (ktop)) / (dm (ktop) - m1_rain (ktop)) - do k = ktop + 1, kbot - w1 (k) = (dm (k) * w1 (k) - m1_rain (k - 1) * vtr (k - 1) + m1_rain (k) * vtr (k)) & - / (dm (k) + m1_rain (k - 1) - m1_rain (k)) + ! conservation of vertical momentum: + w1 (ks) = w1 (ks) + m1_rain (ks) * vtr (ks) / dm (ks) + do k = ks + 1, ke + w1 (k) = (dm (k) * w1 (k) + m1_rain (k - 1) * (w1 (k - 1) - vtr (k - 1)) + m1_rain (k) * vtr (k)) & + / (dm (k) + m1_rain (k - 1)) + enddo + endif + + ! ----------------------------------------------------------------------- + ! energy loss during sedimentation heating + ! ----------------------------------------------------------------------- + + if (consv_checker) then + do k = ks, ke + te1 (k) = one_r8 + qv (k) * c1_vap + (ql (k) + qr (k)) * c1_liq + (qi (k) + qs (k) + qg (k)) * c1_ice + te1 (k) = rgrav * te1 (k) * c_air * tz (k) * dp (k) enddo endif ! ----------------------------------------------------------------------- - ! heat transportation during sedimentation + ! heat exchanges during sedimentation ! ----------------------------------------------------------------------- - if (do_sedi_heat) & - call sedi_heat (ktop, kbot, dp, m1_rain, dz, tz, qv, ql, qr, qi, qs, qg, c_liq) + if (do_sedi_heat) then + call sedi_heat (ks, ke, dp, m1_rain, dz, tz, qv, ql, qr, qi, qs, qg, c_liq) + endif + + ! ----------------------------------------------------------------------- + ! energy loss during sedimentation heating + ! ----------------------------------------------------------------------- + + if (consv_checker) then + do k = ks, ke + te2 (k) = one_r8 + qv (k) * c1_vap + (ql (k) + qr (k)) * c1_liq + (qi (k) + qs (k) + qg (k)) * c1_ice + te2 (k) = rgrav * te2 (k) * c_air * tz (k) * dp (k) + enddo + dte = dte + sum (te1) - sum (te2) + endif + ! ----------------------------------------------------------------------- ! evaporation and accretion of rain for the remaing 1 / 2 time step ! ----------------------------------------------------------------------- - call revap_racc (ktop, kbot, dt5, tz, qv, ql, qr, qi, qs, qg, den, denfac, rh_rain, h_var) + call revap_racc (ks, ke, dt5, tz, qv, ql, qr, qi, qs, qg, den, denfac, rh_rain, h_var, dp, reevap) endif @@ -1097,17 +1244,9 @@ subroutine warm_rain (dt, ktop, kbot, dp, dz, tz, qv, ql, qr, qi, qs, qg, & ! no subgrid varaibility ! ----------------------------------------------------------------------- - do k = ktop, kbot - qc0 = fac_rc * ccn (k) + do k = ks, ke + qc = fac_rc * ccn (k) if (tz (k) > t_wfr) then - if (use_ccn) then - ! ----------------------------------------------------------------------- - ! ccn is formulted as ccn = ccn_surface * (den / den_surface) - ! ----------------------------------------------------------------------- - qc = qc0 - else - qc = qc0 / den (k) - endif dq = ql (k) - qc if (dq > 0.) then sink = min (dq, dt * c_praut (k) * den (k) * exp (so3 * log (ql (k)))) @@ -1123,23 +1262,15 @@ subroutine warm_rain (dt, ktop, kbot, dp, dz, tz, qv, ql, qr, qi, qs, qg, & ! with subgrid varaibility ! ----------------------------------------------------------------------- - call linear_prof (kbot - ktop + 1, ql (ktop), dl (ktop), z_slope_liq, h_var) + call linear_prof (ke - ks + 1, ql (ks), dl (ks), z_slope_liq, h_var) - do k = ktop, kbot - qc0 = fac_rc * ccn (k) + do k = ks, ke + qc = fac_rc * ccn (k) if (tz (k) > t_wfr + dt_fr) then dl (k) = min (max (1.e-6, dl (k)), 0.5 * ql (k)) ! -------------------------------------------------------------------- ! as in klein's gfdl am2 stratiform scheme (with subgrid variations) ! -------------------------------------------------------------------- - if (use_ccn) then - ! -------------------------------------------------------------------- - ! ccn is formulted as ccn = ccn_surface * (den / den_surface) - ! -------------------------------------------------------------------- - qc = qc0 - else - qc = qc0 / den (k) - endif dq = 0.5 * (ql (k) + dl (k) - qc) ! -------------------------------------------------------------------- ! dq = dl if qc == q_minus = ql - dl @@ -1163,27 +1294,33 @@ end subroutine warm_rain ! evaporation of rain ! ----------------------------------------------------------------------- -subroutine revap_racc (ktop, kbot, dt, tz, qv, ql, qr, qi, qs, qg, den, denfac, rh_rain, h_var) +subroutine revap_racc (ks, ke, dt, tz, qv, ql, qr, qi, qs, qg, den, denfac, rh_rain, h_var, dp, reevap) implicit none - integer, intent (in) :: ktop, kbot - + integer, intent (in) :: ks, ke real, intent (in) :: dt ! time step (s) real, intent (in) :: rh_rain, h_var - - real, intent (in), dimension (ktop:kbot) :: den, denfac - - real, intent (inout), dimension (ktop:kbot) :: tz, qv, qr, ql, qi, qs, qg - - real, dimension (ktop:kbot) :: lhl, cvm, q_liq, q_sol, lcpk - + real, intent (in), dimension (ks:ke) :: den, denfac, dp + real (kind = r_grid), intent (inout), dimension (ks:ke) :: tz + real, intent (inout), dimension (ks:ke) :: qv, qr, ql, qi, qs, qg + real, intent (out) :: reevap + ! local: + real (kind = r_grid), dimension (ks:ke) :: cvm + real, dimension (ks:ke) :: q_liq, q_sol, lcpk real :: dqv, qsat, dqsdt, evap, t2, qden, q_plus, q_minus, sink real :: qpz, dq, dqh, tin + real :: fac_revp, rh_tem integer :: k - do k = ktop, kbot + if (tau_revp .gt. 1.e-6) then + fac_revp = 1. - exp (- dt / tau_revp) + else + fac_revp = 1. + endif + + do k = ks, ke if (tz (k) > t_wfr .and. qr (k) > qrmin) then @@ -1191,19 +1328,19 @@ subroutine revap_racc (ktop, kbot, dt, tz, qv, ql, qr, qi, qs, qg, den, denfac, ! define heat capacity and latent heat coefficient ! ----------------------------------------------------------------------- - lhl (k) = lv00 + d0_vap * tz (k) ! latent heat for liquid water, temp. dependent - q_liq (k) = ql (k) + qr (k) ! amount of liquid water + q_liq (k) = ql (k) + qr (k) q_sol (k) = qi (k) + qs (k) + qg (k) - cvm (k) = c_air + qv (k) * c_vap + q_liq (k) * c_liq + q_sol (k) * c_ice - lcpk (k) = lhl (k) / cvm (k) ! Lv/cv for total air - - tin = tz (k) - lcpk (k) * ql (k) ! presence of clouds suppresses the rain evap ! T if all cloud water evaporates - qpz = qv (k) + ql (k) ! liquid water plus water vapor - qsat = wqs2 (tin, den (k), dqsdt) ! sat vapor pressure - dqh = max (ql (k), h_var * max (qpz, qcmin))!if ql = 0 (no cloud) this is h_var*qv - dqh = min (dqh, 0.2 * qpz) ! new limiter ! if ql = 0 this is min(h_var*qv, 0.2*qv) = h_var*qv, which is no less than 0.01*qv - dqv = qsat - qv (k) ! use this to prevent super - sat the gird box !saturation deficit - q_minus = qpz - dqh ! if ql = 0 this is (1 - h_var)*qv + + cvm (k) = one_r8 + qv (k) * c1_vap + q_liq (k) * c1_liq + q_sol (k) * c1_ice + lcpk (k) = (lv00 + d1_vap * tz (k)) / cvm (k) + tin = (tz (k) * cvm (k) - lv00 * ql (k)) / (1. + (qv (k) + ql (k)) * c1_vap + qr (k) * c1_liq + q_sol (k) * c1_ice) + + qpz = qv (k) + ql (k) + qsat = wqs2 (tin, den (k), dqsdt) + dqh = max (ql (k), h_var * max (qpz, qcmin)) + dqh = min (dqh, 0.2 * qpz) ! new limiter + dqv = qsat - qv (k) ! use this to prevent super - sat the gird box + q_minus = qpz - dqh q_plus = qpz + dqh ! ----------------------------------------------------------------------- @@ -1215,21 +1352,34 @@ subroutine revap_racc (ktop, kbot, dt, tz, qv, ql, qr, qi, qs, qg, den, denfac, ! rain evaporation ! ----------------------------------------------------------------------- - if (dqv > qvmin .and. qsat > q_minus) then ! if sat vapor pressure is > (1 - h_var)*qv ~= qv - if (qsat > q_plus) then ! if significantly unsaturated - dq = qsat - qpz ! sat deficit with cloud water included (evaporate that first) + rh_tem = qpz / iqs1 (tin, den (k)) + + if (dqv > qvmin .and. qsat > q_minus) then + if (qsat > q_plus) then + dq = qsat - qpz else ! ----------------------------------------------------------------------- ! q_minus < qsat < q_plus - ! dq == dqh if qsat == q_plus + ! dq == dqh if qsat == q_minus ! ----------------------------------------------------------------------- - dq = 0.25 * (q_minus - qsat) ** 2 / dqh ! 0 for q_minus = q_sat; + dq = 0.25 * (qsat - q_minus) ** 2 / dqh endif qden = qr (k) * den (k) t2 = tin * tin - evap = crevp (1) * t2 * dq * (crevp (2) * sqrt (qden) + crevp (3) * & - exp (0.725 * log (qden))) / (crevp (4) * t2 + crevp (5) * qsat * den (k)) - evap = min (qr (k), dt * evap, dqv / (1. + lcpk (k) * dqsdt)) + if (use_rhc_revap) then + evap = 0.0 + if (rh_tem < rhc_revap) then + evap = crevp (1) * t2 * dq * (crevp (2) * sqrt (qden) + crevp (3) * & + exp (0.725 * log (qden)) * sqrt (denfac (k))) / (crevp (4) * t2 + crevp (5) * qsat * den (k)) + evap = min (qr (k), dt * fac_revp * evap, dqv / (1. + lcpk (k) * dqsdt)) + endif + else + evap = crevp (1) * t2 * dq * (crevp (2) * sqrt (qden) + crevp (3) * & + exp (0.725 * log (qden))) / (crevp (4) * t2 + crevp (5) * qsat * den (k)) + evap = min (qr (k), dt * fac_revp * evap, dqv / (1. + lcpk (k) * dqsdt)) + endif + reevap = reevap + evap * dp (k) + ! ----------------------------------------------------------------------- ! alternative minimum evap in dry environmental air ! sink = min (qr (k), dim (rh_rain * qsat, qv (k)) / (1. + lcpk (k) * dqsdt)) @@ -1238,8 +1388,7 @@ subroutine revap_racc (ktop, kbot, dt, tz, qv, ql, qr, qi, qs, qg, den, denfac, qr (k) = qr (k) - evap qv (k) = qv (k) + evap q_liq (k) = q_liq (k) - evap - cvm (k) = c_air + qv (k) * c_vap + q_liq (k) * c_liq + q_sol (k) * c_ice - tz (k) = tz (k) - evap * lhl (k) / cvm (k) + tz (k) = (cvm (k) * tz (k) - lv00 * evap) / (one_r8 + qv (k) * c1_vap + q_liq (k) * c1_liq + q_sol (k) * c1_ice) endif ! ----------------------------------------------------------------------- @@ -1271,15 +1420,10 @@ subroutine linear_prof (km, q, dm, z_var, h_var) implicit none integer, intent (in) :: km - real, intent (in) :: q (km), h_var - real, intent (out) :: dm (km) - logical, intent (in) :: z_var - real :: dq (km) - integer :: k if (z_var) then @@ -1327,35 +1471,36 @@ end subroutine linear_prof ! author: shian - jiann lin, gfdl ! ======================================================================= -subroutine icloud (ktop, kbot, tzk, p1, qvk, qlk, qrk, qik, qsk, qgk, dp1, & - den, denfac, vts, vtg, vtr, qak, rh_adj, rh_rain, dts, h_var) +subroutine icloud (ks, ke, tzk, p1, qvk, qlk, qrk, qik, qsk, qgk, dp1, den, & + ccn, cin, denfac, vts, vtg, vtr, qak, rh_adj, rh_rain, dts, h_var, & + gsize, cond, dep, reevap, sub, last_step) implicit none - integer, intent (in) :: ktop, kbot - - real, intent (in), dimension (ktop:kbot) :: p1, dp1, den, denfac, vts, vtg, vtr - - real, intent (inout), dimension (ktop:kbot) :: tzk, qvk, qlk, qrk, qik, qsk, qgk, qak - - real, intent (in) :: rh_adj, rh_rain, dts, h_var - - real, dimension (ktop:kbot) :: lcpk, icpk, tcpk, di, lhl, lhi - real, dimension (ktop:kbot) :: cvm, q_liq, q_sol - + logical, intent (in) :: last_step + integer, intent (in) :: ks, ke + real, intent (in), dimension (ks:ke) :: p1, dp1, den, denfac, vts, vtg, vtr, ccn + real (kind = r_grid), intent (inout), dimension (ks:ke) :: tzk + real, intent (inout), dimension (ks:ke) :: qvk, qlk, qrk, qik, qsk, qgk, qak + real, intent (inout), dimension (ks:ke) :: cin + real, intent (in) :: rh_adj, rh_rain, dts, h_var, gsize + real, intent (out) :: cond, dep, reevap, sub + ! local: + real, dimension (ks:ke) :: icpk, di, qim + real, dimension (ks:ke) :: q_liq, q_sol + real (kind = r_grid), dimension (ks:ke) :: cvm, te8 + real (kind = r_grid) :: tz real :: rdts, fac_g2v, fac_v2g, fac_i2s, fac_imlt - real :: tz, qv, ql, qr, qi, qs, qg, melt + real :: qv, ql, qr, qi, qs, qg, melt real :: pracs, psacw, pgacw, psacr, pgacr, pgaci, praci, psaci - real :: pgmlt, psmlt, pgfr, pgaut, psaut, pgsub - real :: tc, tsq, dqs0, qden, qim, qsm + real :: pgmlt, psmlt, pgfr, psaut + real :: tc, dqs0, qden, qsm real :: dt5, factor, sink, qi_crt real :: tmp, qsw, qsi, dqsdt, dq real :: dtmp, qc, q_plus, q_minus - integer :: k dt5 = 0.5 * dts - rdts = 1. / dts ! ----------------------------------------------------------------------- @@ -1365,449 +1510,421 @@ subroutine icloud (ktop, kbot, tzk, p1, qvk, qlk, qrk, qik, qsk, qgk, dp1, & fac_i2s = 1. - exp (- dts / tau_i2s) fac_g2v = 1. - exp (- dts / tau_g2v) fac_v2g = 1. - exp (- dts / tau_v2g) - fac_imlt = 1. - exp (- dt5 / tau_imlt) ! ----------------------------------------------------------------------- ! define heat capacity and latend heat coefficient ! ----------------------------------------------------------------------- - do k = ktop, kbot - lhi (k) = li00 + dc_ice * tzk (k) + do k = ks, ke q_liq (k) = qlk (k) + qrk (k) q_sol (k) = qik (k) + qsk (k) + qgk (k) - cvm (k) = c_air + qvk (k) * c_vap + q_liq (k) * c_liq + q_sol (k) * c_ice - icpk (k) = lhi (k) / cvm (k) + cvm (k) = one_r8 + qvk (k) * c1_vap + q_liq (k) * c1_liq + q_sol (k) * c1_ice + te8 (k) = cvm (k) * tzk (k) + lv00 * qvk (k) - li00 * q_sol (k) + icpk (k) = (li00 + d1_ice * tzk (k)) / cvm (k) enddo ! ----------------------------------------------------------------------- - ! sources of cloud ice: pihom, cold rain, and the sat_adj - ! (initiation plus deposition) - ! sources of snow: cold rain, auto conversion + accretion (from cloud ice) - ! sat_adj (deposition; requires pre - existing snow) ; initial snow comes from auto conversion + ! similar to lfo 1983: eq. 21 solved implicitly + ! threshold from wsm6 scheme, hong et al 2004, eq (13) : qi0_crt ~0.8e-4 ! ----------------------------------------------------------------------- - do k = ktop, kbot - if (tzk (k) > tice .and. qik (k) > qcmin) then - - ! ----------------------------------------------------------------------- - ! pimlt: instant melting of cloud ice - ! ----------------------------------------------------------------------- - - melt = min (qik (k), fac_imlt * (tzk (k) - tice) / icpk (k)) - tmp = min (melt, dim (ql_mlt, qlk (k))) ! max ql amount - qlk (k) = qlk (k) + tmp - qrk (k) = qrk (k) + melt - tmp - qik (k) = qik (k) - melt - q_liq (k) = q_liq (k) + melt - q_sol (k) = q_sol (k) - melt - cvm (k) = c_air + qvk (k) * c_vap + q_liq (k) * c_liq + q_sol (k) * c_ice - tzk (k) = tzk (k) - melt * lhi (k) / cvm (k) - - elseif (tzk (k) < t_wfr .and. qlk (k) > qcmin) then - - ! ----------------------------------------------------------------------- - ! pihom: homogeneous freezing of cloud water into cloud ice - ! this is the 1st occurance of liquid water freezing in the split mp process - ! ----------------------------------------------------------------------- - - dtmp = t_wfr - tzk (k) - factor = min (1., dtmp / dt_fr) - sink = min (qlk (k) * factor, dtmp / icpk (k)) - qi_crt = qi_gen * min (qi_lim, 0.1 * (tice - tzk (k))) / den (k) - tmp = min (sink, dim (qi_crt, qik (k))) - qlk (k) = qlk (k) - sink - qsk (k) = qsk (k) + sink - tmp - qik (k) = qik (k) + tmp - q_liq (k) = q_liq (k) - sink - q_sol (k) = q_sol (k) + sink - cvm (k) = c_air + qvk (k) * c_vap + q_liq (k) * c_liq + q_sol (k) * c_ice - tzk (k) = tzk (k) + sink * lhi (k) / cvm (k) - + do k = ks, ke + if (qi0_crt < 0.) then + qim (k) = - qi0_crt + else + qim (k) = qi0_crt / den (k) endif enddo - ! ----------------------------------------------------------------------- - ! vertical subgrid variability - ! ----------------------------------------------------------------------- + if (.not. do_warm_rain_mp) then - call linear_prof (kbot - ktop + 1, qik (ktop), di (ktop), z_slope_ice, h_var) + ! ----------------------------------------------------------------------- + ! sources of cloud ice: pihom, cold rain, and the sat_adj + ! (initiation plus deposition) + ! sources of snow: cold rain, auto conversion + accretion (from cloud ice) + ! sat_adj (deposition; requires pre - existing snow) ; initial snow comes from auto conversion + ! ----------------------------------------------------------------------- - ! ----------------------------------------------------------------------- - ! update capacity heat and latend heat coefficient - ! ----------------------------------------------------------------------- + do k = ks, ke + if (tzk (k) > tice_mlt .and. qik (k) > qcmin) then - do k = ktop, kbot - lhl (k) = lv00 + d0_vap * tzk (k) - lhi (k) = li00 + dc_ice * tzk (k) - lcpk (k) = lhl (k) / cvm (k) - icpk (k) = lhi (k) / cvm (k) - tcpk (k) = lcpk (k) + icpk (k) - enddo + ! ----------------------------------------------------------------------- + ! pimlt: instant melting of cloud ice + ! ----------------------------------------------------------------------- - do k = ktop, kbot + melt = min (qik (k), fac_imlt * (tzk (k) - tice_mlt) / icpk (k)) + tmp = min (melt, dim (ql_mlt, qlk (k))) ! max ql amount + qlk (k) = qlk (k) + tmp + qrk (k) = qrk (k) + melt - tmp + qik (k) = qik (k) - melt + q_liq (k) = q_liq (k) + melt + q_sol (k) = q_sol (k) - melt + elseif (tzk (k) < t_wfr .and. qlk (k) > qcmin) then + + ! ----------------------------------------------------------------------- + ! pihom: homogeneous freezing of cloud water into cloud ice + ! ----------------------------------------------------------------------- + + dtmp = t_wfr - tzk (k) + factor = min (1., dtmp / dt_fr) + sink = min (qlk (k) * factor, dtmp / icpk (k)) + tmp = min (sink, dim (qim (k), qik (k))) + qlk (k) = qlk (k) - sink + qsk (k) = qsk (k) + sink - tmp + qik (k) = qik (k) + tmp + q_liq (k) = q_liq (k) - sink + q_sol (k) = q_sol (k) + sink + endif + enddo ! ----------------------------------------------------------------------- - ! do nothing above p_min + ! vertical subgrid variability ! ----------------------------------------------------------------------- - if (p1 (k) < p_min) cycle + call linear_prof (ke - ks + 1, qik (ks), di (ks), z_slope_ice, h_var) - tz = tzk (k) - qv = qvk (k) - ql = qlk (k) - qi = qik (k) - qr = qrk (k) - qs = qsk (k) - qg = qgk (k) + ! ----------------------------------------------------------------------- + ! update capacity heat and latend heat coefficient + ! ----------------------------------------------------------------------- - pgacr = 0. - pgacw = 0. - tc = tz - tice + do k = ks, ke + cvm (k) = one_r8 + qvk (k) * c1_vap + q_liq (k) * c1_liq + q_sol (k) * c1_ice + tzk (k) = (te8 (k) - lv00 * qvk (k) + li00 * q_sol (k)) / cvm (k) + icpk (k) = (li00 + d1_ice * tzk (k)) / cvm (k) + enddo - if (tc .ge. 0.) then + do k = ks, ke ! ----------------------------------------------------------------------- - ! melting of snow + ! do nothing above p_min ! ----------------------------------------------------------------------- - dqs0 = ces0 / p1 (k) - qv - - if (qs > qcmin) then - - ! ----------------------------------------------------------------------- - ! psacw: accretion of cloud water by snow - ! only rate is used (for snow melt) since tc > 0. - ! ----------------------------------------------------------------------- + if (p1 (k) < p_min) cycle - if (ql > qrmin) then - factor = denfac (k) * csacw * exp (0.8125 * log (qs * den (k))) - psacw = factor / (1. + dts * factor) * ql ! rate - else - psacw = 0. - endif + tz = tzk (k) + qv = qvk (k) + ql = qlk (k) + qi = qik (k) + qr = qrk (k) + qs = qsk (k) + qg = qgk (k) - ! ----------------------------------------------------------------------- - ! psacr: accretion of rain by melted snow - ! pracs: accretion of snow by rain - ! ----------------------------------------------------------------------- + pgacr = 0. + pgacw = 0. + tc = tz - tice - if (qr > qrmin) then - psacr = min (acr3d (vts (k), vtr (k), qr, qs, csacr, acco (1, 2), & - den (k)), qr * rdts) - pracs = acr3d (vtr (k), vts (k), qs, qr, cracs, acco (1, 1), den (k)) - else - psacr = 0. - pracs = 0. - endif + if (tc .ge. 0.) then ! ----------------------------------------------------------------------- - ! total snow sink: - ! psmlt: snow melt (due to rain accretion) + ! melting of snow ! ----------------------------------------------------------------------- - psmlt = max (0., smlt (tc, dqs0, qs * den (k), psacw, psacr, csmlt, & - den (k), denfac (k))) - sink = min (qs, dts * (psmlt + pracs), tc / icpk (k)) - qs = qs - sink - ! sjl, 20170321: - tmp = min (sink, dim (qs_mlt, ql)) ! max ql due to snow melt - ql = ql + tmp - qr = qr + sink - tmp - ! qr = qr + sink - ! sjl, 20170321: - q_liq (k) = q_liq (k) + sink - q_sol (k) = q_sol (k) - sink - cvm (k) = c_air + qv * c_vap + q_liq (k) * c_liq + q_sol (k) * c_ice - tz = tz - sink * lhi (k) / cvm (k) - tc = tz - tice - - endif + dqs0 = ces0 / p1 (k) - qv ! not sure if this is correct; check again - ! ----------------------------------------------------------------------- - ! update capacity heat and latend heat coefficient - ! ----------------------------------------------------------------------- + if (qs > qcmin) then - lhi (k) = li00 + dc_ice * tz - icpk (k) = lhi (k) / cvm (k) + ! ----------------------------------------------------------------------- + ! psacw: accretion of cloud water by snow + ! only rate is used (for snow melt) since tc > 0. + ! ----------------------------------------------------------------------- - ! ----------------------------------------------------------------------- - ! melting of graupel - ! ----------------------------------------------------------------------- + if (ql > qrmin) then + factor = denfac (k) * csacw * exp (0.8125 * log (qs * den (k))) + psacw = factor / (1. + dts * factor) * ql ! rate + else + psacw = 0. + endif - if (qg > qcmin .and. tc > 0.) then + ! ----------------------------------------------------------------------- + ! psacr: accretion of rain by melted snow + ! pracs: accretion of snow by rain + ! ----------------------------------------------------------------------- - ! ----------------------------------------------------------------------- - ! pgacr: accretion of rain by graupel - ! ----------------------------------------------------------------------- + if (qr > qrmin) then + psacr = min (acr3d (vts (k), vtr (k), qr, qs, csacr, acco (1, 2), & + den (k)), qr * rdts) + pracs = acr3d (vtr (k), vts (k), qs, qr, cracs, acco (1, 1), den (k)) + else + psacr = 0. + pracs = 0. + endif - if (qr > qrmin) & - pgacr = min (acr3d (vtg (k), vtr (k), qr, qg, cgacr, acco (1, 3), & - den (k)), rdts * qr) + ! ----------------------------------------------------------------------- + ! total snow sink: + ! psmlt: snow melt (due to rain accretion) + ! ----------------------------------------------------------------------- - ! ----------------------------------------------------------------------- - ! pgacw: accretion of cloud water by graupel - ! ----------------------------------------------------------------------- + psmlt = max (0., smlt (tc, dqs0, qs * den (k), psacw, psacr, csmlt, & + den (k), denfac (k))) + sink = min (qs, dts * (psmlt + pracs), tc / icpk (k)) + qs = qs - sink + tmp = min (sink, dim (qs_mlt, ql)) ! max ql due to snow melt + ql = ql + tmp + qr = qr + sink - tmp + q_liq (k) = q_liq (k) + sink + q_sol (k) = q_sol (k) - sink + + cvm (k) = one_r8 + qv * c1_vap + q_liq (k) * c1_liq + q_sol (k) * c1_ice + tz = (te8 (k) - lv00 * qv + li00 * q_sol (k)) / cvm (k) + tc = tz - tice + icpk (k) = (li00 + d1_ice * tz) / cvm (k) - qden = qg * den (k) - if (ql > qrmin) then - factor = cgacw * qden / sqrt (den (k) * sqrt (sqrt (qden))) - pgacw = factor / (1. + dts * factor) * ql ! rate endif ! ----------------------------------------------------------------------- - ! pgmlt: graupel melt + ! melting of graupel ! ----------------------------------------------------------------------- - pgmlt = dts * gmlt (tc, dqs0, qden, pgacw, pgacr, cgmlt, den (k)) - pgmlt = min (max (0., pgmlt), qg, tc / icpk (k)) - qg = qg - pgmlt - qr = qr + pgmlt - q_liq (k) = q_liq (k) + pgmlt - q_sol (k) = q_sol (k) - pgmlt - cvm (k) = c_air + qv * c_vap + q_liq (k) * c_liq + q_sol (k) * c_ice - tz = tz - pgmlt * lhi (k) / cvm (k) - - endif + if (qg > qcmin .and. tc > 0.) then - else + ! ----------------------------------------------------------------------- + ! pgacr: accretion of rain by graupel + ! ----------------------------------------------------------------------- - ! ----------------------------------------------------------------------- - ! cloud ice proc: - ! ----------------------------------------------------------------------- + if (qr > qrmin) & + pgacr = min (acr3d (vtg (k), vtr (k), qr, qg, cgacr, acco (1, 3), & + den (k)), rdts * qr) - ! ----------------------------------------------------------------------- - ! psaci: accretion of cloud ice by snow - ! ----------------------------------------------------------------------- + ! ----------------------------------------------------------------------- + ! pgacw: accretion of cloud water by graupel + ! ----------------------------------------------------------------------- - if (qi > 3.e-7) then ! cloud ice sink terms + qden = qg * den (k) + if (ql > qrmin) then + factor = cgacw * qden / sqrt (den (k) * sqrt (sqrt (qden))) + pgacw = factor / (1. + dts * factor) * ql ! rate + endif - if (qs > 1.e-7) then ! ----------------------------------------------------------------------- - ! sjl added (following lin eq. 23) the temperature dependency - ! to reduce accretion, use esi = exp (0.05 * tc) as in hong et al 2004 + ! pgmlt: graupel melt ! ----------------------------------------------------------------------- - factor = dts * denfac (k) * csaci * exp (0.05 * tc + 0.8125 * log (qs * den (k))) - psaci = factor / (1. + factor) * qi - else - psaci = 0. + + pgmlt = dts * gmlt (tc, dqs0, qden, pgacw, pgacr, cgmlt, den (k)) + pgmlt = min (max (0., pgmlt), qg, tc / icpk (k)) + qg = qg - pgmlt + qr = qr + pgmlt + q_liq (k) = q_liq (k) + pgmlt + q_sol (k) = q_sol (k) - pgmlt + cvm (k) = one_r8 + qv * c1_vap + q_liq (k) * c1_liq + q_sol (k) * c1_ice + tz = (te8 (k) - lv00 * qv + li00 * q_sol (k)) / cvm (k) endif - ! ----------------------------------------------------------------------- - ! pasut: autoconversion: cloud ice -- > snow - ! ----------------------------------------------------------------------- + else ! ----------------------------------------------------------------------- - ! similar to lfo 1983: eq. 21 solved implicitly - ! threshold from wsm6 scheme, hong et al 2004, eq (13) : qi0_crt ~0.8e-4 + ! cloud ice proc: ! ----------------------------------------------------------------------- - if (qi0_crt < 0.) then - qim = - qi0_crt - else - qim = qi0_crt / den (k) - endif - ! ----------------------------------------------------------------------- - ! assuming linear subgrid vertical distribution of cloud ice - ! the mismatch computation following lin et al. 1994, mwr + ! psaci: accretion of cloud ice by snow ! ----------------------------------------------------------------------- - if (const_vi) then - tmp = fac_i2s - else - tmp = fac_i2s * exp (0.025 * tc) - endif + if (qi > 3.e-7) then ! cloud ice sink terms - di (k) = max (di (k), qrmin) - q_plus = qi + di (k) - if (q_plus > (qim + qrmin)) then - if (qim > (qi - di (k))) then - dq = (0.25 * (q_plus - qim) ** 2) / di (k) + if (qs > 1.e-7) then + ! ----------------------------------------------------------------------- + ! sjl added (following lin eq. 23) the temperature dependency + ! to reduce accretion, use esi = exp (0.05 * tc) as in hong et al 2004 + ! ----------------------------------------------------------------------- + factor = dts * denfac (k) * csaci * exp (0.05 * tc + 0.8125 * log (qs * den (k))) + psaci = factor / (1. + factor) * qi else - dq = qi - qim + psaci = 0. endif - psaut = tmp * dq - else - psaut = 0. - endif - ! ----------------------------------------------------------------------- - ! sink is no greater than 75% of qi - ! ----------------------------------------------------------------------- - sink = min (0.75 * qi, psaci + psaut) - qi = qi - sink - qs = qs + sink - - ! ----------------------------------------------------------------------- - ! pgaci: accretion of cloud ice by graupel - ! ----------------------------------------------------------------------- - if (qg > 1.e-6) then ! ----------------------------------------------------------------------- - ! factor = dts * cgaci / sqrt (den (k)) * exp (0.05 * tc + 0.875 * log (qg * den (k))) - ! simplified form: remove temp dependency & set the exponent "0.875" -- > 1 + ! assuming linear subgrid vertical distribution of cloud ice + ! the mismatch computation following lin et al. 1994, mwr ! ----------------------------------------------------------------------- - factor = dts * cgaci * sqrt (den (k)) * qg - pgaci = factor / (1. + factor) * qi - qi = qi - pgaci - qg = qg + pgaci - endif - endif + if (const_vi) then + tmp = fac_i2s + else + tmp = fac_i2s * exp (0.025 * tc) + endif - ! ----------------------------------------------------------------------- - ! cold - rain proc: - ! ----------------------------------------------------------------------- + di (k) = max (di (k), qrmin) + q_plus = qi + di (k) + if (q_plus > (qim (k) + qrmin)) then + if (qim (k) > (qi - di (k))) then + dq = (0.25 * (q_plus - qim (k)) ** 2) / di (k) + else + dq = qi - qim (k) + endif + psaut = tmp * dq + else + psaut = 0. + endif + ! ----------------------------------------------------------------------- + ! sink is no greater than 75% of qi + ! ----------------------------------------------------------------------- + sink = min (0.75 * qi, psaci + psaut) + qi = qi - sink + qs = qs + sink - ! ----------------------------------------------------------------------- - ! rain to ice, snow, graupel processes: - ! ----------------------------------------------------------------------- + ! ----------------------------------------------------------------------- + ! pgaci: accretion of cloud ice by graupel + ! ----------------------------------------------------------------------- - tc = tz - tice + if (qg > 1.e-6) then + ! ----------------------------------------------------------------------- + ! factor = dts * cgaci / sqrt (den (k)) * exp (0.05 * tc + 0.875 * log (qg * den (k))) + ! simplified form: remove temp dependency & set the exponent "0.875" -- > 1 + ! ----------------------------------------------------------------------- + factor = dts * cgaci / sqrt (den (k)) * exp (0.875 * log (qg * den (k))) + pgaci = factor / (1. + factor) * qi + qi = qi - pgaci + qg = qg + pgaci + endif - if (qr > 1.e-7 .and. tc < 0.) then + endif ! ----------------------------------------------------------------------- - ! * sink * terms to qr: psacr + pgfr - ! source terms to qs: psacr - ! source terms to qg: pgfr + ! cold - rain proc: ! ----------------------------------------------------------------------- ! ----------------------------------------------------------------------- - ! psacr accretion of rain by snow + ! rain to ice, snow, graupel processes: ! ----------------------------------------------------------------------- - if (qs > 1.e-7) then ! if snow exists - psacr = dts * acr3d (vts (k), vtr (k), qr, qs, csacr, acco (1, 2), den (k)) - else - psacr = 0. - endif + tc = tz - tice - ! ----------------------------------------------------------------------- - ! pgfr: rain freezing -- > graupel - ! ----------------------------------------------------------------------- + if (qr > 1.e-7 .and. tc < 0.) then - pgfr = dts * cgfr (1) / den (k) * (exp (- cgfr (2) * tc) - 1.) * & - exp (1.75 * log (qr * den (k))) + ! ----------------------------------------------------------------------- + ! * sink * terms to qr: psacr + pgfr + ! source terms to qs: psacr + ! source terms to qg: pgfr + ! ----------------------------------------------------------------------- - ! ----------------------------------------------------------------------- - ! total sink to qr - ! ----------------------------------------------------------------------- + ! ----------------------------------------------------------------------- + ! psacr accretion of rain by snow + ! ----------------------------------------------------------------------- - sink = psacr + pgfr - factor = min (sink, qr, - tc / icpk (k)) / max (sink, qrmin) + if (qs > 1.e-7) then ! if snow exists + psacr = dts * acr3d (vts (k), vtr (k), qr, qs, csacr, acco (1, 2), den (k)) + else + psacr = 0. + endif - psacr = factor * psacr - pgfr = factor * pgfr + ! ----------------------------------------------------------------------- + ! pgfr: rain freezing -- > graupel + ! ----------------------------------------------------------------------- - sink = psacr + pgfr - qr = qr - sink - qs = qs + psacr - qg = qg + pgfr - q_liq (k) = q_liq (k) - sink - q_sol (k) = q_sol (k) + sink - cvm (k) = c_air + qv * c_vap + q_liq (k) * c_liq + q_sol (k) * c_ice - tz = tz + sink * lhi (k) / cvm (k) + pgfr = dts * cgfr (1) / den (k) * (exp (- cgfr (2) * tc) - 1.) * & + exp (1.75 * log (qr * den (k))) - endif + ! ----------------------------------------------------------------------- + ! total sink to qr + ! ----------------------------------------------------------------------- - ! ----------------------------------------------------------------------- - ! update capacity heat and latend heat coefficient - ! ----------------------------------------------------------------------- + sink = psacr + pgfr + factor = min (sink, qr, - tc / icpk (k)) / max (sink, qrmin) - lhi (k) = li00 + dc_ice * tz - icpk (k) = lhi (k) / cvm (k) + psacr = factor * psacr + pgfr = factor * pgfr - ! ----------------------------------------------------------------------- - ! graupel production terms: - ! ----------------------------------------------------------------------- + sink = psacr + pgfr + qr = qr - sink + qs = qs + psacr + qg = qg + pgfr + q_liq (k) = q_liq (k) - sink + q_sol (k) = q_sol (k) + sink - if (qs > 1.e-7) then + cvm (k) = one_r8 + qv * c1_vap + q_liq (k) * c1_liq + q_sol (k) * c1_ice + tz = (te8 (k) - lv00 * qv + li00 * q_sol (k)) / cvm (k) + icpk (k) = (li00 + d1_ice * tz) / cvm (k) + endif ! ----------------------------------------------------------------------- - ! accretion: snow -- > graupel + ! graupel production terms: ! ----------------------------------------------------------------------- - if (qg > qrmin) then - sink = dts * acr3d (vtg (k), vts (k), qs, qg, cgacs, acco (1, 4), den (k)) - else - sink = 0. - endif + if (qs > 1.e-7) then - ! ----------------------------------------------------------------------- - ! autoconversion snow -- > graupel - ! ----------------------------------------------------------------------- + ! ----------------------------------------------------------------------- + ! accretion: snow -- > graupel + ! ----------------------------------------------------------------------- - qsm = qs0_crt / den (k) - if (qs > qsm) then - factor = dts * 1.e-3 * exp (0.09 * (tz - tice)) - sink = sink + factor / (1. + factor) * (qs - qsm) - endif - sink = min (qs, sink) - qs = qs - sink - qg = qg + sink + if (qg > qrmin) then + sink = dts * acr3d (vtg (k), vts (k), qs, qg, cgacs, acco (1, 4), den (k)) + else + sink = 0. + endif - endif ! snow existed + ! ----------------------------------------------------------------------- + ! autoconversion snow -- > graupel + ! ----------------------------------------------------------------------- - if (qg > 1.e-7 .and. tz < tice0) then + qsm = qs0_crt / den (k) + if (qs > qsm) then + factor = dts * 1.e-3 * exp (0.09 * (tz - tice)) + sink = sink + factor / (1. + factor) * (qs - qsm) + endif + sink = min (qs, sink) + qs = qs - sink + qg = qg + sink - ! ----------------------------------------------------------------------- - ! pgacw: accretion of cloud water by graupel - ! ----------------------------------------------------------------------- + endif ! snow existed - if (ql > 1.e-6) then - qden = qg * den (k) - factor = dts * cgacw * qden / sqrt (den (k) * sqrt (sqrt (qden))) - pgacw = factor / (1. + factor) * ql - else - pgacw = 0. - endif + if (qg > 1.e-7 .and. tz < tice) then - ! ----------------------------------------------------------------------- - ! pgacr: accretion of rain by graupel - ! ----------------------------------------------------------------------- + ! ----------------------------------------------------------------------- + ! pgacw: accretion of cloud water by graupel + ! ----------------------------------------------------------------------- - if (qr > 1.e-6) then - pgacr = min (dts * acr3d (vtg (k), vtr (k), qr, qg, cgacr, acco (1, 3), & - den (k)), qr) - else - pgacr = 0. - endif + if (ql > 1.e-6) then + qden = qg * den (k) + factor = dts * cgacw * qden / sqrt (den (k) * sqrt (sqrt (qden))) + pgacw = factor / (1. + factor) * ql + else + pgacw = 0. + endif - sink = pgacr + pgacw - factor = min (sink, dim (tice, tz) / icpk (k)) / max (sink, qrmin) - pgacr = factor * pgacr - pgacw = factor * pgacw + ! ----------------------------------------------------------------------- + ! pgacr: accretion of rain by graupel + ! ----------------------------------------------------------------------- - sink = pgacr + pgacw - qg = qg + sink - qr = qr - pgacr - ql = ql - pgacw - q_liq (k) = q_liq (k) - sink - q_sol (k) = q_sol (k) + sink - cvm (k) = c_air + qv * c_vap + q_liq (k) * c_liq + q_sol (k) * c_ice - tz = tz + sink * lhi (k) / cvm (k) + if (qr > 1.e-6) then + pgacr = min (dts * acr3d (vtg (k), vtr (k), qr, qg, cgacr, acco (1, 3), & + den (k)), qr) + else + pgacr = 0. + endif - endif + sink = pgacr + pgacw + factor = min (sink, dim (tice, tz) / icpk (k)) / max (sink, qrmin) + pgacr = factor * pgacr + pgacw = factor * pgacw - endif + sink = pgacr + pgacw + qg = qg + sink + qr = qr - pgacr + ql = ql - pgacw - tzk (k) = tz - qvk (k) = qv - qlk (k) = ql - qik (k) = qi - qrk (k) = qr - qsk (k) = qs - qgk (k) = qg + q_liq (k) = q_liq (k) - sink + q_sol (k) = q_sol (k) + sink + tz = (te8 (k) - lv00 * qv + li00 * q_sol (k)) / (one_r8 + qv * c1_vap + q_liq (k) * c1_liq + q_sol (k) * c1_ice) + endif - enddo + endif - ! ----------------------------------------------------------------------- - ! subgrid cloud microphysics - ! ----------------------------------------------------------------------- + tzk (k) = tz + qvk (k) = qv + qlk (k) = ql + qik (k) = qi + qrk (k) = qr + qsk (k) = qs + qgk (k) = qg - call subgrid_z_proc (ktop, kbot, p1, den, denfac, dts, rh_adj, tzk, qvk, & - qlk, qrk, qik, qsk, qgk, qak, h_var, rh_rain) + enddo + + endif + + call subgrid_z_proc (ks, ke, p1, den, denfac, dts, rh_adj, tzk, qvk, qlk, & + qrk, qik, qsk, qgk, qak, dp1, h_var, rh_rain, te8, ccn, cin, gsize, & + cond, dep, reevap, sub, last_step) end subroutine icloud @@ -1815,40 +1932,39 @@ end subroutine icloud ! temperature sentive high vertical resolution processes ! ======================================================================= -subroutine subgrid_z_proc (ktop, kbot, p1, den, denfac, dts, rh_adj, tz, qv, & - ql, qr, qi, qs, qg, qa, h_var, rh_rain) +subroutine subgrid_z_proc (ks, ke, p1, den, denfac, dts, rh_adj, tz, qv, ql, qr, & + qi, qs, qg, qa, dp1, h_var, rh_rain, te8, ccn, cin, gsize, cond, dep, reevap, sub, last_step) implicit none - integer, intent (in) :: ktop, kbot - - real, intent (in), dimension (ktop:kbot) :: p1, den, denfac - - real, intent (in) :: dts, rh_adj, h_var, rh_rain - - real, intent (inout), dimension (ktop:kbot) :: tz, qv, ql, qr, qi, qs, qg, qa - - real, dimension (ktop:kbot) :: lcpk, icpk, tcpk, tcp3, lhl, lhi - real, dimension (ktop:kbot) :: cvm, q_liq, q_sol, q_cond - - real :: fac_v2l, fac_l2v - + integer, intent (in) :: ks, ke + real, intent (in) :: dts, rh_adj, h_var, rh_rain, gsize + real, intent (in), dimension (ks:ke) :: p1, den, denfac, ccn, dp1 + real (kind = r_grid), intent (in), dimension (ks:ke) :: te8 + real (kind = r_grid), intent (inout), dimension (ks:ke) :: tz + real, intent (inout), dimension (ks:ke) :: qv, ql, qr, qi, qs, qg, qa + real, intent (inout), dimension (ks:ke) :: cin + logical, intent (in) :: last_step + real, intent (out) :: cond, dep, reevap, sub + ! local: + real, dimension (ks:ke) :: lcpk, icpk, tcpk, tcp3 + real, dimension (ks:ke) :: q_liq, q_sol, q_cond + real (kind = r_grid), dimension (ks:ke) :: cvm real :: pidep, qi_crt - + real :: sigma, gam ! ----------------------------------------------------------------------- ! qstar over water may be accurate only down to - 80 deg c with ~10% uncertainty ! must not be too large to allow psc ! ----------------------------------------------------------------------- - - real :: rh, rqi, tin, qsw, qsi, qpz, qstar - real :: dqsdt, dwsdt, dq, dq0, factor, tmp + real :: rh, rqi, tin, qsw, qsi, qpz, qstar, rh_tem + real :: dqsdt, dwsdt, dq, dq0, factor, tmp, liq, ice real :: q_plus, q_minus, dt_evap, dt_pisub - real :: evap, sink, tc, pisub, q_adj, dtmp - real :: pssub, pgsub, tsq, qden, fac_g2v, fac_v2g - + real :: evap, sink, tc, dtmp, qa10, qa100 + real :: pssub, pgsub, tsq, qden + real :: fac_l2v, fac_v2l, fac_g2v, fac_v2g integer :: k - if (fast_sat_adj) then + if (do_sat_adj) then dt_evap = 0.5 * dts else dt_evap = dts @@ -1858,9 +1974,8 @@ subroutine subgrid_z_proc (ktop, kbot, p1, den, denfac, dts, rh_adj, tz, qv, & ! define conversion scalar / factor ! ----------------------------------------------------------------------- - fac_v2l = 1. - exp (- dt_evap / tau_v2l) fac_l2v = 1. - exp (- dt_evap / tau_l2v) - + fac_v2l = 1. - exp (- dt_evap / tau_v2l) fac_g2v = 1. - exp (- dts / tau_g2v) fac_v2g = 1. - exp (- dts / tau_v2g) @@ -1868,290 +1983,284 @@ subroutine subgrid_z_proc (ktop, kbot, p1, den, denfac, dts, rh_adj, tz, qv, & ! define heat capacity and latend heat coefficient ! ----------------------------------------------------------------------- - do k = ktop, kbot - lhl (k) = lv00 + d0_vap * tz (k) - lhi (k) = li00 + dc_ice * tz (k) + do k = ks, ke q_liq (k) = ql (k) + qr (k) q_sol (k) = qi (k) + qs (k) + qg (k) - cvm (k) = c_air + qv (k) * c_vap + q_liq (k) * c_liq + q_sol (k) * c_ice - lcpk (k) = lhl (k) / cvm (k) - icpk (k) = lhi (k) / cvm (k) - tcpk (k) = lcpk (k) + icpk (k) + cvm (k) = one_r8 + qv (k) * c1_vap + q_liq (k) * c1_liq + q_sol (k) * c1_ice + lcpk (k) = (lv00 + d1_vap * tz (k)) / cvm (k) + icpk (k) = (li00 + d1_ice * tz (k)) / cvm (k) tcp3 (k) = lcpk (k) + icpk (k) * min (1., dim (tice, tz (k)) / (tice - t_wfr)) enddo - do k = ktop, kbot + cond = 0 + dep = 0 + reevap = 0 + sub = 0 - if (p1 (k) < p_min) cycle + do k = ks, ke - ! ----------------------------------------------------------------------- - ! instant deposit all water vapor to cloud ice when temperature is super low - ! ----------------------------------------------------------------------- - - if (tz (k) < t_min) then - sink = dim (qv (k), 1.e-7) - qv (k) = qv (k) - sink - qi (k) = qi (k) + sink - q_sol (k) = q_sol (k) + sink - cvm (k) = c_air + qv (k) * c_vap + q_liq (k) * c_liq + q_sol (k) * c_ice - tz (k) = tz (k) + sink * (lhl (k) + lhi (k)) / cvm (k) - if (.not. do_qa) qa (k) = qa (k) + 1. ! air fully saturated; 100 % cloud cover - cycle - endif + if (p1 (k) < p_min) cycle - ! ----------------------------------------------------------------------- - ! update heat capacity and latend heat coefficient - ! ----------------------------------------------------------------------- + if (.not. do_warm_rain_mp) then - lhl (k) = lv00 + d0_vap * tz (k) - lhi (k) = li00 + dc_ice * tz (k) - lcpk (k) = lhl (k) / cvm (k) - icpk (k) = lhi (k) / cvm (k) - tcpk (k) = lcpk (k) + icpk (k) - tcp3 (k) = lcpk (k) + icpk (k) * min (1., dim (tice, tz (k)) / (tice - t_wfr)) + ! ----------------------------------------------------------------------- + ! instant deposit all water vapor to cloud ice when temperature is super low + ! ----------------------------------------------------------------------- - ! ----------------------------------------------------------------------- - ! instant evaporation / sublimation of all clouds if rh < rh_adj -- > cloud free - ! ----------------------------------------------------------------------- + if (tz (k) < t_min) then + sink = dim (qv (k), 1.e-7) + dep = dep + sink * dp1 (k) + qv (k) = qv (k) - sink + qi (k) = qi (k) + sink + q_sol (k) = q_sol (k) + sink + tz (k) = (te8 (k) - lv00 * qv (k) + li00 * q_sol (k)) / & + (one_r8 + qv (k) * c1_vap + q_liq (k) * c1_liq + q_sol (k) * c1_ice) + if (do_qa) qa (k) = 1. ! air fully saturated; 100 % cloud cover + cycle + endif - qpz = qv (k) + ql (k) + qi (k) - tin = tz (k) - (lhl (k) * (ql (k) + qi (k)) + lhi (k) * qi (k)) / (c_air + & - qpz * c_vap + qr (k) * c_liq + (qs (k) + qg (k)) * c_ice) - if (tin > t_sub + 6.) then - rh = qpz / iqs1 (tin, den (k)) - if (rh < rh_adj) then ! qpz / rh_adj < qs - tz (k) = tin - qv (k) = qpz - ql (k) = 0. - qi (k) = 0. - cycle ! cloud free + ! ----------------------------------------------------------------------- + ! instant evaporation / sublimation of all clouds if rh < rh_adj -- > cloud free + ! ----------------------------------------------------------------------- + ! rain water is handled in warm - rain process. + qpz = qv (k) + ql (k) + qi (k) + tin = (te8 (k) - lv00 * qpz + li00 * (qs (k) + qg (k))) / & + (one_r8 + qpz * c1_vap + qr (k) * c1_liq + (qs (k) + qg (k)) * c1_ice) + if (tin > t_sub + 6.) then + rh = qpz / iqs1 (tin, den (k)) + if (rh < rh_adj) then ! qpz / rh_adj < qs + reevap = reevap + ql (k) * dp1 (k) + sub = sub + qi (k) * dp1 (k) + tz (k) = tin + qv (k) = qpz + ql (k) = 0. + qi (k) = 0. + cycle ! cloud free + endif endif + endif ! ----------------------------------------------------------------------- ! cloud water < -- > vapor adjustment: ! ----------------------------------------------------------------------- - qsw = wqs2 (tz (k), den (k), dwsdt) + tin = tz (k) + rh_tem = qpz / iqs1 (tin, den (k)) + qsw = wqs2 (tin, den (k), dwsdt) dq0 = qsw - qv (k) - if (dq0 > 0.) then - ! sjl 20170703 added ql factor to prevent the situation of high ql and low rh - ! factor = min (1., fac_l2v * sqrt (max (0., ql (k)) / 1.e-5) * 10. * dq0 / qsw) - ! factor = fac_l2v - ! factor = 1 - factor = min (1., fac_l2v * (10. * dq0 / qsw)) ! the rh dependent factor = 1 at 90% - evap = min (ql (k), factor * dq0 / (1. + tcp3 (k) * dwsdt)) - else ! condensate all excess vapor into cloud water - ! ----------------------------------------------------------------------- - ! evap = fac_v2l * dq0 / (1. + tcp3 (k) * dwsdt) - ! sjl, 20161108 - ! ----------------------------------------------------------------------- - evap = dq0 / (1. + tcp3 (k) * dwsdt) + if (use_rhc_cevap) then + evap = 0. + if (rh_tem .lt. rhc_cevap) then + if (dq0 > 0.) then ! evaporation + factor = min (1., fac_l2v * (10. * dq0 / qsw)) ! the rh dependent factor = 1 at 90% + evap = min (ql (k), factor * dq0 / (1. + tcp3 (k) * dwsdt)) + reevap = reevap + evap * dp1 (k) + elseif (do_cond_timescale) then + factor = min (1., fac_v2l * (10. * (- dq0) / qsw)) + evap = - min (qv (k), factor * (- dq0) / (1. + tcp3 (k) * dwsdt)) + cond = cond - evap * dp1 (k) + else ! condensate all excess vapor into cloud water + evap = dq0 / (1. + tcp3 (k) * dwsdt) + cond = cond - evap * dp1 (k) + endif + endif + else + if (dq0 > 0.) then ! evaporation + factor = min (1., fac_l2v * (10. * dq0 / qsw)) ! the rh dependent factor = 1 at 90% + evap = min (ql (k), factor * dq0 / (1. + tcp3 (k) * dwsdt)) + reevap = reevap + evap * dp1 (k) + elseif (do_cond_timescale) then + factor = min (1., fac_v2l * (10. * (- dq0) / qsw)) + evap = - min (qv (k), factor * (- dq0) / (1. + tcp3 (k) * dwsdt)) + cond = cond - evap * dp1 (k) + else ! condensate all excess vapor into cloud water + evap = dq0 / (1. + tcp3 (k) * dwsdt) + cond = cond - evap * dp1 (k) + endif endif + ! sjl on jan 23 2018: reversible evap / condensation: qv (k) = qv (k) + evap ql (k) = ql (k) - evap q_liq (k) = q_liq (k) - evap - cvm (k) = c_air + qv (k) * c_vap + q_liq (k) * c_liq + q_sol (k) * c_ice - tz (k) = tz (k) - evap * lhl (k) / cvm (k) - - ! ----------------------------------------------------------------------- - ! update heat capacity and latend heat coefficient - ! ----------------------------------------------------------------------- - - lhi (k) = li00 + dc_ice * tz (k) - icpk (k) = lhi (k) / cvm (k) - - ! ----------------------------------------------------------------------- - ! enforce complete freezing below - 48 c - ! ----------------------------------------------------------------------- - dtmp = t_wfr - tz (k) ! [ - 40, - 48] - if (dtmp > 0. .and. ql (k) > qcmin) then - sink = min (ql (k), ql (k) * dtmp * 0.125, dtmp / icpk (k)) - ql (k) = ql (k) - sink - qi (k) = qi (k) + sink - q_liq (k) = q_liq (k) - sink - q_sol (k) = q_sol (k) + sink - cvm (k) = c_air + qv (k) * c_vap + q_liq (k) * c_liq + q_sol (k) * c_ice - tz (k) = tz (k) + sink * lhi (k) / cvm (k) - endif + cvm (k) = one_r8 + qv (k) * c1_vap + q_liq (k) * c1_liq + q_sol (k) * c1_ice + tz (k) = (te8 (k) - lv00 * qv (k) + li00 * q_sol (k)) / cvm (k) ! ----------------------------------------------------------------------- ! update heat capacity and latend heat coefficient ! ----------------------------------------------------------------------- - lhi (k) = li00 + dc_ice * tz (k) - icpk (k) = lhi (k) / cvm (k) + icpk (k) = (li00 + d1_ice * tz (k)) / cvm (k) - ! ----------------------------------------------------------------------- - ! bigg mechanism - ! ----------------------------------------------------------------------- + if (.not. do_warm_rain_mp) then - if (fast_sat_adj) then - dt_pisub = 0.5 * dts - else - dt_pisub = dts - tc = tice - tz (k) - if (ql (k) > qrmin .and. tc > 0.) then - sink = 3.3333e-10 * dts * (exp (0.66 * tc) - 1.) * den (k) * ql (k) * ql (k) - sink = min (ql (k), tc / icpk (k), sink) + ! ----------------------------------------------------------------------- + ! enforce complete freezing below - 48 c + ! ----------------------------------------------------------------------- + + dtmp = t_wfr - tz (k) ! [ - 40, - 48] + if (dtmp > 0. .and. ql (k) > qcmin) then + sink = min (ql (k), ql (k) * dtmp * 0.125, dtmp / icpk (k)) ql (k) = ql (k) - sink qi (k) = qi (k) + sink q_liq (k) = q_liq (k) - sink q_sol (k) = q_sol (k) + sink - cvm (k) = c_air + qv (k) * c_vap + q_liq (k) * c_liq + q_sol (k) * c_ice - tz (k) = tz (k) + sink * lhi (k) / cvm (k) - endif ! significant ql existed - endif - - ! ----------------------------------------------------------------------- - ! update capacity heat and latend heat coefficient - ! ----------------------------------------------------------------------- - - lhl (k) = lv00 + d0_vap * tz (k) - lhi (k) = li00 + dc_ice * tz (k) - lcpk (k) = lhl (k) / cvm (k) - icpk (k) = lhi (k) / cvm (k) - tcpk (k) = lcpk (k) + icpk (k) + cvm (k) = one_r8 + qv (k) * c1_vap + q_liq (k) * c1_liq + q_sol (k) * c1_ice + tz (k) = (te8 (k) - lv00 * qv (k) + li00 * q_sol (k)) / cvm (k) + icpk (k) = (li00 + d1_ice * tz (k)) / cvm (k) + endif - ! ----------------------------------------------------------------------- - ! sublimation / deposition of ice - ! ----------------------------------------------------------------------- + ! ----------------------------------------------------------------------- + ! bigg mechanism + ! ----------------------------------------------------------------------- - if (tz (k) < tice) then - qsi = iqs2 (tz (k), den (k), dqsdt) - dq = qv (k) - qsi - sink = dq / (1. + tcpk (k) * dqsdt) - if (qi (k) > qrmin) then - ! eq 9, hong et al. 2004, mwr - ! for a and b, see dudhia 1989: page 3103 eq (b7) and (b8) - pidep = dt_pisub * dq * 349138.78 * exp (0.875 * log (qi (k) * den (k))) & - / (qsi * den (k) * lat2 / (0.0243 * rvgas * tz (k) ** 2) + 4.42478e4) + if (do_sat_adj) then + dt_pisub = 0.5 * dts else - pidep = 0. - endif - if (dq > 0.) then ! vapor - > ice - tmp = tice - tz (k) - ! 20160912: the following should produce more ice at higher altitude - ! qi_crt = 4.92e-11 * exp (1.33 * log (1.e3 * exp (0.1 * tmp))) / den (k) - qi_crt = qi_gen * min (qi_lim, 0.1 * tmp) / den (k) - sink = min (sink, max (qi_crt - qi (k), pidep), tmp / tcpk (k)) - else ! ice -- > vapor - pidep = pidep * min (1., dim (tz (k), t_sub) * 0.2) - sink = max (pidep, sink, - qi (k)) + dt_pisub = dts + tc = tice - tz (k) + if (ql (k) > qrmin .and. tc > 0.1) then + sink = 100. / (rhow * ccn (k)) * dts * (exp (0.66 * tc) - 1.) * ql (k) ** 2 + sink = min (ql (k), tc / icpk (k), sink) + ql (k) = ql (k) - sink + qi (k) = qi (k) + sink + q_liq (k) = q_liq (k) - sink + q_sol (k) = q_sol (k) + sink + cvm (k) = one_r8 + qv (k) * c1_vap + q_liq (k) * c1_liq + q_sol (k) * c1_ice + tz (k) = (te8 (k) - lv00 * qv (k) + li00 * q_sol (k)) / cvm (k) + endif ! significant ql existed endif - qv (k) = qv (k) - sink - qi (k) = qi (k) + sink - q_sol (k) = q_sol (k) + sink - cvm (k) = c_air + qv (k) * c_vap + q_liq (k) * c_liq + q_sol (k) * c_ice - tz (k) = tz (k) + sink * (lhl (k) + lhi (k)) / cvm (k) - endif - ! ----------------------------------------------------------------------- - ! update capacity heat and latend heat coefficient - ! ----------------------------------------------------------------------- + ! ----------------------------------------------------------------------- + ! update capacity heat and latend heat coefficient + ! ----------------------------------------------------------------------- - lhl (k) = lv00 + d0_vap * tz (k) - lhi (k) = li00 + dc_ice * tz (k) - lcpk (k) = lhl (k) / cvm (k) - icpk (k) = lhi (k) / cvm (k) - tcpk (k) = lcpk (k) + icpk (k) + tcpk (k) = (li20 + (d1_vap + d1_ice) * tz (k)) / cvm (k) - ! ----------------------------------------------------------------------- - ! sublimation / deposition of snow - ! this process happens for all temp rage - ! ----------------------------------------------------------------------- + ! ----------------------------------------------------------------------- + ! sublimation / deposition of ice + ! ----------------------------------------------------------------------- - if (qs (k) > qrmin) then - qsi = iqs2 (tz (k), den (k), dqsdt) - qden = qs (k) * den (k) - tmp = exp (0.65625 * log (qden)) - tsq = tz (k) * tz (k) - dq = (qsi - qv (k)) / (1. + tcpk (k) * dqsdt) - pssub = cssub (1) * tsq * (cssub (2) * sqrt (qden) + cssub (3) * tmp * & - sqrt (denfac (k))) / (cssub (4) * tsq + cssub (5) * qsi * den (k)) - pssub = (qsi - qv (k)) * dts * pssub - if (pssub > 0.) then ! qs -- > qv, sublimation - pssub = min (pssub * min (1., dim (tz (k), t_sub) * 0.2), qs (k)) - else - if (tz (k) > tice) then - pssub = 0. ! no deposition + if (tz (k) < tice) then + qsi = iqs2 (tz (k), den (k), dqsdt) + dq = qv (k) - qsi + sink = dq / (1. + tcpk (k) * dqsdt) + if (qi (k) > qrmin) then + if (.not. prog_ccn) then + if (inflag .eq. 1) & + ! hong et al., 2004 + cin (k) = 5.38e7 * exp (0.75 * log (qi (k) * den (k))) + if (inflag .eq. 2) & + ! meyers et al., 1992 + cin (k) = exp (-2.80 + 0.262 * (tice - tz (k))) * 1000.0 ! convert from L^-1 to m^-3 + if (inflag .eq. 3) & + ! meyers et al., 1992 + cin (k) = exp (-0.639 + 12.96 * (qv (k) / qsi - 1.0)) * 1000.0 ! convert from L^-1 to m^-3 + if (inflag .eq. 4) & + ! cooper, 1986 + cin (k) = 5.e-3 * exp (0.304 * (tice - tz (k))) * 1000.0 ! convert from L^-1 to m^-3 + if (inflag .eq. 5) & + ! flecther, 1962 + cin (k) = 1.e-5 * exp (0.5 * (tice - tz (k))) * 1000.0 ! convert from L^-1 to m^-3 + endif + pidep = dt_pisub * dq * 4.0 * 11.9 * exp (0.5 * log (qi (k) * den (k) * cin (k))) & + / (qsi * den (k) * lat2 / (0.0243 * rvgas * tz (k) ** 2) + 4.42478e4) else - pssub = max (pssub, dq, (tz (k) - tice) / tcpk (k)) + pidep = 0. + endif + if (dq > 0.) then ! vapor - > ice + tmp = tice - tz (k) + ! 20160912: the following should produce more ice at higher altitude + ! qi_crt = 4.92e-11 * exp (1.33 * log (1.e3 * exp (0.1 * tmp))) / den (k) + qi_crt = qi_gen * min (qi_lim, 0.1 * tmp) / den (k) + sink = min (sink, max (qi_crt - qi (k), pidep), tmp / tcpk (k)) + dep = dep + sink * dp1 (k) + else ! ice -- > vapor + pidep = pidep * min (1., dim (tz (k), t_sub) * 0.2) + sink = max (pidep, sink, - qi (k)) + sub = sub - sink * dp1 (k) endif + qv (k) = qv (k) - sink + qi (k) = qi (k) + sink + q_sol (k) = q_sol (k) + sink + cvm (k) = one_r8 + qv (k) * c1_vap + q_liq (k) * c1_liq + q_sol (k) * c1_ice + tz (k) = (te8 (k) - lv00 * qv (k) + li00 * q_sol (k)) / cvm (k) endif - qs (k) = qs (k) - pssub - qv (k) = qv (k) + pssub - q_sol (k) = q_sol (k) - pssub - cvm (k) = c_air + qv (k) * c_vap + q_liq (k) * c_liq + q_sol (k) * c_ice - tz (k) = tz (k) - pssub * (lhl (k) + lhi (k)) / cvm (k) - endif - ! ----------------------------------------------------------------------- - ! update capacity heat and latend heat coefficient - ! ----------------------------------------------------------------------- + ! ----------------------------------------------------------------------- + ! update capacity heat and latend heat coefficient + ! ----------------------------------------------------------------------- - lhl (k) = lv00 + d0_vap * tz (k) - lhi (k) = li00 + dc_ice * tz (k) - lcpk (k) = lhl (k) / cvm (k) - icpk (k) = lhi (k) / cvm (k) - tcpk (k) = lcpk (k) + icpk (k) + tcpk (k) = (li20 + (d1_vap + d1_ice) * tz (k)) / cvm (k) - ! ----------------------------------------------------------------------- - ! simplified 2 - way grapuel sublimation - deposition mechanism - ! ----------------------------------------------------------------------- + ! ----------------------------------------------------------------------- + ! sublimation / deposition of snow + ! this process happens for all temp rage + ! ----------------------------------------------------------------------- - if (qg (k) > qrmin) then - qsi = iqs2 (tz (k), den (k), dqsdt) - dq = (qv (k) - qsi) / (1. + tcpk (k) * dqsdt) - pgsub = (qv (k) / qsi - 1.) * qg (k) - if (pgsub > 0.) then ! deposition - if (tz (k) > tice) then - pgsub = 0. ! no deposition + if (qs (k) > qrmin) then + qsi = iqs2 (tz (k), den (k), dqsdt) + qden = qs (k) * den (k) + tmp = exp (0.65625 * log (qden)) + tsq = tz (k) * tz (k) + dq = (qsi - qv (k)) / (1. + tcpk (k) * dqsdt) + pssub = cssub (1) * tsq * (cssub (2) * sqrt (qden) + cssub (3) * tmp * & + sqrt (denfac (k))) / (cssub (4) * tsq + cssub (5) * qsi * den (k)) + pssub = (qsi - qv (k)) * dts * pssub + if (pssub > 0.) then ! qs -- > qv, sublimation + pssub = min (pssub * min (1., dim (tz (k), t_sub) * 0.2), qs (k)) + sub = sub + pssub * dp1 (k) else - pgsub = min (fac_v2g * pgsub, 0.2 * dq, ql (k) + qr (k), & - (tice - tz (k)) / tcpk (k)) + if (tz (k) > tice) then + pssub = 0. ! no deposition + else + pssub = max (pssub, dq, (tz (k) - tice) / tcpk (k)) + endif + dep = dep - pssub * dp1 (k) endif - else ! submilation - pgsub = max (fac_g2v * pgsub, dq) * min (1., dim (tz (k), t_sub) * 0.1) + qs (k) = qs (k) - pssub + qv (k) = qv (k) + pssub + q_sol (k) = q_sol (k) - pssub + cvm (k) = one_r8 + qv (k) * c1_vap + q_liq (k) * c1_liq + q_sol (k) * c1_ice + tz (k) = (te8 (k) - lv00 * qv (k) + li00 * q_sol (k)) / cvm (k) + tcpk (k) = (li20 + (d1_vap + d1_ice) * tz (k)) / cvm (k) endif - qg (k) = qg (k) + pgsub - qv (k) = qv (k) - pgsub - q_sol (k) = q_sol (k) + pgsub - cvm (k) = c_air + qv (k) * c_vap + q_liq (k) * c_liq + q_sol (k) * c_ice - tz (k) = tz (k) + pgsub * (lhl (k) + lhi (k)) / cvm (k) - endif - -#ifdef USE_MIN_EVAP - ! ----------------------------------------------------------------------- - ! update capacity heat and latend heat coefficient - ! ----------------------------------------------------------------------- - lhl (k) = lv00 + d0_vap * tz (k) - lcpk (k) = lhl (k) / cvm (k) + ! ----------------------------------------------------------------------- + ! sublimation / deposition of graupel + ! this process happens for all temp rage + ! ----------------------------------------------------------------------- - ! ----------------------------------------------------------------------- - ! * minimum evap of rain in dry environmental air - ! ----------------------------------------------------------------------- + if (qg (k) > qrmin) then + qsi = iqs2 (tz (k), den (k), dqsdt) + qden = qg (k) * den (k) + tmp = exp (0.6875 * log (qden)) + tsq = tz (k) * tz (k) + dq = (qsi - qv (k)) / (1. + tcpk (k) * dqsdt) + pgsub = cgsub (1) * tsq * (cgsub (2) * sqrt (qden) + cgsub (3) * tmp / & + sqrt (sqrt (den (k)))) / (cgsub (4) * tsq + cgsub (5) * qsi * den (k)) + pgsub = (qsi - qv (k)) * dts * pgsub + if (pgsub > 0.) then ! qs -- > qv, sublimation + pgsub = min (pgsub * min (1., dim (tz (k), t_sub) * 0.2), qg (k)) + sub = sub + pgsub * dp1 (k) + else + if (tz (k) > tice) then + pgsub = 0. ! no deposition + else + pgsub = max (pgsub, dq, (tz (k) - tice) / tcpk (k)) + endif + dep = dep - pgsub * dp1 (k) + endif + qg (k) = qg (k) - pgsub + qv (k) = qv (k) + pgsub + q_sol (k) = q_sol (k) - pgsub + cvm (k) = one_r8 + qv (k) * c1_vap + q_liq (k) * c1_liq + q_sol (k) * c1_ice + tz (k) = (te8 (k) - lv00 * qv (k) + li00 * q_sol (k)) / cvm (k) + tcpk (k) = (li20 + (d1_vap + d1_ice) * tz (k)) / cvm (k) + endif - if (qr (k) > qcmin) then - qsw = wqs2 (tz (k), den (k), dqsdt) - sink = min (qr (k), dim (rh_rain * qsw, qv (k)) / (1. + lcpk (k) * dqsdt)) - qv (k) = qv (k) + sink - qr (k) = qr (k) - sink - q_liq (k) = q_liq (k) - sink - cvm (k) = c_air + qv (k) * c_vap + q_liq (k) * c_liq + q_sol (k) * c_ice - tz (k) = tz (k) - sink * lhl (k) / cvm (k) endif -#endif - - ! ----------------------------------------------------------------------- - ! update capacity heat and latend heat coefficient - ! ----------------------------------------------------------------------- - - lhl (k) = lv00 + d0_vap * tz (k) - cvm (k) = c_air + (qv (k) + q_liq (k) + q_sol (k)) * c_vap - lcpk (k) = lhl (k) / cvm (k) ! ----------------------------------------------------------------------- ! compute cloud fraction @@ -2161,30 +2270,37 @@ subroutine subgrid_z_proc (ktop, kbot, p1, den, denfac, dts, rh_adj, tz, qv, & ! combine water species ! ----------------------------------------------------------------------- - if (do_qa) cycle + if (.not. (do_qa .and. last_step)) cycle + ice = q_sol (k) if (rad_snow) then - q_sol (k) = qi (k) + qs (k) + if (rad_graupel) then + q_sol (k) = qi (k) + qs (k) + qg (k) + else + q_sol (k) = qi (k) + qs (k) + endif else q_sol (k) = qi (k) endif + liq = q_liq (k) if (rad_rain) then q_liq (k) = ql (k) + qr (k) else q_liq (k) = ql (k) endif - q_cond (k) = q_liq (k) + q_sol (k) - qpz = qv (k) + q_cond (k) ! qpz is conserved + q_cond (k) = q_liq (k) + q_sol (k) + qpz = qv (k) + q_cond (k) ! ----------------------------------------------------------------------- ! use the "liquid - frozen water temperature" (tin) to compute saturated specific humidity ! ----------------------------------------------------------------------- - - tin = tz (k) - (lcpk (k) * q_cond (k) + icpk (k) * q_sol (k)) ! minimum temperature - ! tin = tz (k) - ((lv00 + d0_vap * tz (k)) * q_cond (k) + & - ! (li00 + dc_ice * tz (k)) * q_sol (k)) / (c_air + qpz * c_vap) - + ! tin = tz (k) - (lcpk (k) * q_cond (k) + icpk (k) * q_sol (k)) ! minimum temperature + !! tin = (tz (k) * cvm (i) + li00 * q_sol (k) - lv00 * q_cond (k)) / & + !! (one_r8 + (qv (k) + q_cond (k)) * c1_vap) + ice = ice - q_sol (k) + liq = liq - q_liq (k) + tin = (te8 (k) - lv00 * qpz + li00 * ice) / (one_r8 + qpz * c1_vap + liq * c1_liq + ice * c1_ice) ! ----------------------------------------------------------------------- ! determine saturated specific humidity ! ----------------------------------------------------------------------- @@ -2215,16 +2331,116 @@ subroutine subgrid_z_proc (ktop, kbot, p1, den, denfac, dts, rh_adj, tz, qv, & ! binary cloud scheme ! ----------------------------------------------------------------------- - if (qpz > qrmin) then - ! partial cloudiness by pdf: - dq = max (qcmin, h_var * qpz) - q_plus = qpz + dq ! cloud free if qstar > q_plus - q_minus = qpz - dq - if (qstar < q_minus) then - qa (k) = qa (k) + 1. ! air fully saturated; 100 % cloud cover - elseif (qstar < q_plus .and. q_cond (k) > qc_crt) then - qa (k) = qa (k) + (q_plus - qstar) / (dq + dq) ! partial cloud cover - ! qa (k) = sqrt (qa (k) + (q_plus - qstar) / (dq + dq)) + ! ----------------------------------------------------------------------- + ! partial cloudiness by pdf: + ! assuming subgrid linear distribution in horizontal; this is effectively a smoother for the + ! binary cloud scheme; qa = 0.5 if qstar == qpz + ! ----------------------------------------------------------------------- + + qpz = cld_fac * qpz + rh = qpz / qstar + + ! ----------------------------------------------------------------------- + ! icloud_f = 0: bug - fixed + ! icloud_f = 1: old fvgfs gfdl) mp implementation + ! icloud_f = 2: binary cloud scheme (0 / 1) + ! icloud_f = 3: revision of icloud = 0 + ! ----------------------------------------------------------------------- + + if (use_xr_cloud) then ! xu and randall cloud scheme (1996) + if (rh >= 1.0) then + qa (k) = 1.0 + elseif (rh > rh_thres .and. q_cond (k) > 1.e-6) then + qa (k) = rh ** xr_a * (1.0 - exp (- xr_b * max (0.0, q_cond (k)) / & + max (1.e-5, (max (1.e-10, 1.0 - rh) * qstar) ** xr_c))) + qa (k) = max (0.0, min (1., qa (k))) + else + qa (k) = 0.0 + endif + elseif (use_park_cloud) then ! park et al. 2016 (mon. wea. review) + if (q_cond (k) > 1.e-6) then + qa (k) = 1. / 50. * (5.77 * (100. - gsize / 1000.) * max (0.0, q_cond (k) * 1000.) ** 1.07 + & + 4.82 * (gsize / 1000. - 50.) * max (0.0, q_cond (k) * 1000.) ** 0.94) + qa (k) = qa (k) * (0.92 / 0.96 * q_liq (k) / q_cond (k) + 1.0 / 0.96 * q_sol (k) / q_cond (k)) + qa (k) = max (0.0, min (1., qa (k))) + else + qa (k) = 0.0 + endif + elseif (use_gi_cloud) then ! gultepe and isaac (2007) + sigma = 0.28 + max (0.0, q_cond (k) * 1000.) ** 0.49 + gam = max (0.0, q_cond (k) * 1000.) / sigma + if (gam < 0.18) then + qa10 = 0. + elseif (gam > 2.0) then + qa10 = 1.0 + else + qa10 = - 0.1754 + 0.9811 * gam - 0.2223 * gam ** 2 + 0.0104 * gam ** 3 + qa10 = max (0.0, min (1., qa10)) + endif + if (gam < 0.12) then + qa100 = 0. + elseif (gam > 1.85) then + qa100 = 1.0 + else + qa100 = - 0.0913 + 0.7213 * gam + 0.1060 * gam ** 2 - 0.0946 * gam ** 3 + qa100 = max (0.0, min (1., qa100)) + endif + qa (k) = qa10 + (log10 (gsize / 1000.) - 1) * (qa100 - qa10) + qa (k) = max (0.0, min (1., qa (k))) + else + if (rh > rh_thres .and. qpz > 1.e-6) then + + dq = h_var * qpz + if (do_cld_adj) then + q_plus = qpz + dq * f_dq_p * min(1.0, max(0.0, (p1 (k) - 200.e2) / (1000.e2 - 200.e2))) + else + q_plus = qpz + dq * f_dq_p + endif + q_minus = qpz - dq * f_dq_m + + if (icloud_f .eq. 2) then + if (qstar < qpz) then + qa (k) = 1. + else + qa (k) = 0. + endif + elseif (icloud_f .eq. 3) then + if (qstar < qpz) then + qa (k) = 1. + else + if (qstar < q_plus) then + qa (k) = (q_plus - qstar) / (dq * f_dq_p) + else + qa (k) = 0. + endif + ! impose minimum cloudiness if substantial q_cond (k) exist + if (q_cond (k) > 1.e-6) then + qa (k) = max (cld_min, qa (k)) + endif + qa (k) = min (1., qa (k)) + endif + else + if (qstar < q_minus) then + qa (k) = 1. + else + if (qstar < q_plus) then + if (icloud_f .eq. 0) then + qa (k) = (q_plus - qstar) / (dq * f_dq_p + dq * f_dq_m) + else + qa (k) = (q_plus - qstar) / ((dq * f_dq_p + dq * f_dq_m) * (1. - q_cond (k))) + endif + else + qa (k) = 0. + endif + ! impose minimum cloudiness if substantial q_cond (k) exist + if (q_cond (k) > 1.e-6) then + qa (k) = max (cld_min, qa (k)) + endif + qa (k) = min (1., qa (k)) + endif + endif + else + qa (k) = 0. endif endif @@ -2330,35 +2546,30 @@ end subroutine revap_rac1 ! consider cloud ice, snow, and graupel's melting during fall ! ======================================================================= -subroutine terminal_fall (dtm, ktop, kbot, tz, qv, ql, qr, qg, qs, qi, dz, dp, & - den, vtg, vts, vti, r1, g1, s1, i1, m1_sol, w1) +subroutine terminal_fall (dtm, ks, ke, tz, qv, ql, qr, qg, qs, qi, dz, dp, & + den, vtg, vts, vti, r1, g1, s1, i1, m1_sol, w1, dte) implicit none - integer, intent (in) :: ktop, kbot - + integer, intent (in) :: ks, ke real, intent (in) :: dtm ! time step (s) - - real, intent (in), dimension (ktop:kbot) :: vtg, vts, vti, den, dp, dz - - real, intent (inout), dimension (ktop:kbot) :: qv, ql, qr, qg, qs, qi, tz, m1_sol, w1 - + real, intent (in), dimension (ks:ke) :: vtg, vts, vti, den, dp, dz + real (kind = r_grid), intent (inout), dimension (ks:ke) :: tz + real, intent (inout), dimension (ks:ke) :: qv, ql, qr, qg, qs, qi, m1_sol, w1 + real (kind = r_grid), intent (inout) :: dte real, intent (out) :: r1, g1, s1, i1 - - real, dimension (ktop:kbot + 1) :: ze, zt - + ! local: + real, dimension (ks:ke + 1) :: ze, zt real :: qsat, dqsdt, dt5, evap, dtime real :: factor, frac real :: tmp, precip, tc, sink - - real, dimension (ktop:kbot) :: lcpk, icpk, cvm, q_liq, q_sol, lhl, lhi - real, dimension (ktop:kbot) :: m1, dm - + real, dimension (ks:ke) :: lcpk, icpk, cvm, q_liq, q_sol + real, dimension (ks:ke) :: m1, dm + real (kind = r_grid), dimension (ks:ke) :: te1, te2 real :: zs = 0. real :: fac_imlt integer :: k, k0, m - logical :: no_fall dt5 = 0.5 * dtm @@ -2368,23 +2579,21 @@ subroutine terminal_fall (dtm, ktop, kbot, tz, qv, ql, qr, qg, qs, qi, dz, dp, & ! define heat capacity and latend heat coefficient ! ----------------------------------------------------------------------- - do k = ktop, kbot + do k = ks, ke m1_sol (k) = 0. - lhl (k) = lv00 + d0_vap * tz (k) - lhi (k) = li00 + dc_ice * tz (k) q_liq (k) = ql (k) + qr (k) q_sol (k) = qi (k) + qs (k) + qg (k) - cvm (k) = c_air + qv (k) * c_vap + q_liq (k) * c_liq + q_sol (k) * c_ice - lcpk (k) = lhl (k) / cvm (k) - icpk (k) = lhi (k) / cvm (k) + cvm (k) = 1. + qv (k) * c1_vap + q_liq (k) * c1_liq + q_sol (k) * c1_ice + lcpk (k) = (lv00 + d1_vap * tz (k)) / cvm (k) + icpk (k) = (li00 + d1_ice * tz (k)) / cvm (k) enddo ! ----------------------------------------------------------------------- ! find significant melting level ! ----------------------------------------------------------------------- - k0 = kbot - do k = ktop, kbot - 1 + k0 = ke + do k = ks, ke - 1 if (tz (k) > tice) then k0 = k exit @@ -2395,7 +2604,7 @@ subroutine terminal_fall (dtm, ktop, kbot, tz, qv, ql, qr, qg, qs, qi, dz, dp, & ! melting of cloud_ice (before fall) : ! ----------------------------------------------------------------------- - do k = k0, kbot + do k = k0, ke tc = tz (k) - tice if (qi (k) > qcmin .and. tc > 0.) then sink = min (qi (k), fac_imlt * tc / icpk (k)) @@ -2405,8 +2614,9 @@ subroutine terminal_fall (dtm, ktop, kbot, tz, qv, ql, qr, qg, qs, qi, dz, dp, & qi (k) = qi (k) - sink q_liq (k) = q_liq (k) + sink q_sol (k) = q_sol (k) - sink - cvm (k) = c_air + qv (k) * c_vap + q_liq (k) * c_liq + q_sol (k) * c_ice - tz (k) = tz (k) - sink * lhi (k) / cvm (k) + tz (k) = tz (k) * cvm (k) - li00 * sink + cvm (k) = 1. + qv (k) * c1_vap + q_liq (k) * c1_liq + q_sol (k) * c1_ice + tz (k) = tz (k) / cvm (k) tc = tz (k) - tice endif enddo @@ -2415,51 +2625,49 @@ subroutine terminal_fall (dtm, ktop, kbot, tz, qv, ql, qr, qg, qs, qi, dz, dp, & ! turn off melting when cloud microphysics time step is small ! ----------------------------------------------------------------------- - if (dtm < 60.) k0 = kbot - ! sjl, turn off melting of falling cloud ice, snow and graupel - k0 = kbot + ! if (dtm < 60.) k0 = ke + k0 = ke ! sjl, turn off melting of falling cloud ice, snow and graupel - ze (kbot + 1) = zs - do k = kbot, ktop, - 1 + ze (ke + 1) = zs + do k = ke, ks, - 1 ze (k) = ze (k + 1) - dz (k) ! dz < 0 enddo - zt (ktop) = ze (ktop) + zt (ks) = ze (ks) ! ----------------------------------------------------------------------- ! update capacity heat and latend heat coefficient ! ----------------------------------------------------------------------- - do k = k0, kbot - lhi (k) = li00 + dc_ice * tz (k) - icpk (k) = lhi (k) / cvm (k) + do k = k0, ke + icpk (k) = (li00 + d1_ice * tz (k)) / cvm (k) enddo ! ----------------------------------------------------------------------- - ! melting of falling cloud ice into rain + ! melting of falling cloud ice into cloud water and rain ! ----------------------------------------------------------------------- - call check_column (ktop, kbot, qi, no_fall) + call check_column (ks, ke, qi, no_fall) if (vi_fac < 1.e-5 .or. no_fall) then i1 = 0. else - do k = ktop + 1, kbot + do k = ks + 1, ke zt (k) = ze (k) - dt5 * (vti (k - 1) + vti (k)) enddo - zt (kbot + 1) = zs - dtm * vti (kbot) + zt (ke + 1) = zs - dtm * vti (ke) - do k = ktop, kbot + do k = ks, ke if (zt (k + 1) >= zt (k)) zt (k + 1) = zt (k) - dz_min enddo - if (k0 < kbot) then - do k = kbot - 1, k0, - 1 + if (k0 < ke) then + do k = ke - 1, k0, - 1 if (qi (k) > qrmin) then - do m = k + 1, kbot + do m = k + 1, ke if (zt (k + 1) >= ze (m)) exit if (zt (k) < ze (m + 1) .and. tz (m) > tice) then dtime = min (1.0, (ze (m) - ze (m + 1)) / (max (vr_min, vti (k)) * tau_imlt)) @@ -2467,8 +2675,9 @@ subroutine terminal_fall (dtm, ktop, kbot, tz, qv, ql, qr, qg, qs, qi, dz, dp, & tmp = min (sink, dim (ql_mlt, ql (m))) ql (m) = ql (m) + tmp qr (m) = qr (m) - tmp + sink - tz (m) = tz (m) - sink * icpk (m) qi (k) = qi (k) - sink * dp (m) / dp (k) + tz (m) = (tz (m) * cvm (m) - li00 * sink) / & + (1. + qv (m) * c1_vap + (ql (m) + qr (m)) * c1_liq + (qi (m) + qs (m) + qg (m)) * c1_ice) endif enddo endif @@ -2476,22 +2685,45 @@ subroutine terminal_fall (dtm, ktop, kbot, tz, qv, ql, qr, qg, qs, qi, dz, dp, & endif if (do_sedi_w) then - do k = ktop, kbot + do k = ks, ke dm (k) = dp (k) * (1. + qv (k) + ql (k) + qr (k) + qi (k) + qs (k) + qg (k)) enddo endif - if (use_ppm) then - call lagrangian_fall_ppm (ktop, kbot, zs, ze, zt, dp, qi, i1, m1_sol, mono_prof) + ! ----------------------------------------------------------------------- + ! energy loss during sedimentation + ! ----------------------------------------------------------------------- + + if (consv_checker) then + do k = ks, ke + te1 (k) = one_r8 + qv (k) * c1_vap + (ql (k) + qr (k)) * c1_liq + (qi (k) + qs (k) + qg (k)) * c1_ice + te1 (k) = rgrav * te1 (k) * c_air * tz (k) * dp (k) + enddo + endif + + if (use_ppm_ice) then + call lagrangian_fall_ppm (ks, ke, zs, ze, zt, dp, qi, i1, m1_sol, mono_prof) else - call implicit_fall (dtm, ktop, kbot, ze, vti, dp, qi, i1, m1_sol) + call implicit_fall (dtm, ks, ke, ze, vti, dp, qi, i1, m1_sol) + endif + + ! ----------------------------------------------------------------------- + ! energy loss during sedimentation + ! ----------------------------------------------------------------------- + + if (consv_checker) then + do k = ks, ke + te2 (k) = one_r8 + qv (k) * c1_vap + (ql (k) + qr (k)) * c1_liq + (qi (k) + qs (k) + qg (k)) * c1_ice + te2 (k) = rgrav * te2 (k) * c_air * tz (k) * dp (k) + enddo + dte = dte + sum (te1) - sum (te2) endif if (do_sedi_w) then - w1 (ktop) = (dm (ktop) * w1 (ktop) + m1_sol (ktop) * vti (ktop)) / (dm (ktop) - m1_sol (ktop)) - do k = ktop + 1, kbot - w1 (k) = (dm (k) * w1 (k) - m1_sol (k - 1) * vti (k - 1) + m1_sol (k) * vti (k)) & - / (dm (k) + m1_sol (k - 1) - m1_sol (k)) + w1 (ks) = w1 (ks) + m1_sol (ks) * vti (ks) / dm (ks) + do k = ks + 1, ke + w1 (k) = (dm (k) * w1 (k) + m1_sol (k - 1) * (w1 (k - 1) - vti (k - 1)) + m1_sol (k) * vti (k)) & + / (dm (k) + m1_sol (k - 1)) enddo endif @@ -2503,25 +2735,25 @@ subroutine terminal_fall (dtm, ktop, kbot, tz, qv, ql, qr, qg, qs, qi, dz, dp, & r1 = 0. - call check_column (ktop, kbot, qs, no_fall) + call check_column (ks, ke, qs, no_fall) if (no_fall) then s1 = 0. else - do k = ktop + 1, kbot + do k = ks + 1, ke zt (k) = ze (k) - dt5 * (vts (k - 1) + vts (k)) enddo - zt (kbot + 1) = zs - dtm * vts (kbot) + zt (ke + 1) = zs - dtm * vts (ke) - do k = ktop, kbot + do k = ks, ke if (zt (k + 1) >= zt (k)) zt (k + 1) = zt (k) - dz_min enddo - if (k0 < kbot) then - do k = kbot - 1, k0, - 1 + if (k0 < ke) then + do k = ke - 1, k0, - 1 if (qs (k) > qrmin) then - do m = k + 1, kbot + do m = k + 1, ke if (zt (k + 1) >= ze (m)) exit dtime = min (dtm, (ze (m) - ze (m + 1)) / (vr_min + vts (k))) if (zt (k) < ze (m + 1) .and. tz (m) > tice) then @@ -2543,26 +2775,49 @@ subroutine terminal_fall (dtm, ktop, kbot, tz, qv, ql, qr, qg, qs, qi, dz, dp, & endif if (do_sedi_w) then - do k = ktop, kbot + do k = ks, ke dm (k) = dp (k) * (1. + qv (k) + ql (k) + qr (k) + qi (k) + qs (k) + qg (k)) enddo endif + ! ----------------------------------------------------------------------- + ! energy loss during sedimentation + ! ----------------------------------------------------------------------- + + if (consv_checker) then + do k = ks, ke + te1 (k) = one_r8 + qv (k) * c1_vap + (ql (k) + qr (k)) * c1_liq + (qi (k) + qs (k) + qg (k)) * c1_ice + te1 (k) = rgrav * te1 (k) * c_air * tz (k) * dp (k) + enddo + endif + if (use_ppm) then - call lagrangian_fall_ppm (ktop, kbot, zs, ze, zt, dp, qs, s1, m1, mono_prof) + call lagrangian_fall_ppm (ks, ke, zs, ze, zt, dp, qs, s1, m1, mono_prof) else - call implicit_fall (dtm, ktop, kbot, ze, vts, dp, qs, s1, m1) + call implicit_fall (dtm, ks, ke, ze, vts, dp, qs, s1, m1) + endif + + ! ----------------------------------------------------------------------- + ! energy loss during sedimentation + ! ----------------------------------------------------------------------- + + if (consv_checker) then + do k = ks, ke + te2 (k) = one_r8 + qv (k) * c1_vap + (ql (k) + qr (k)) * c1_liq + (qi (k) + qs (k) + qg (k)) * c1_ice + te2 (k) = rgrav * te2 (k) * c_air * tz (k) * dp (k) + enddo + dte = dte + sum (te1) - sum (te2) endif - do k = ktop, kbot + do k = ks, ke m1_sol (k) = m1_sol (k) + m1 (k) enddo if (do_sedi_w) then - w1 (ktop) = (dm (ktop) * w1 (ktop) + m1 (ktop) * vts (ktop)) / (dm (ktop) - m1 (ktop)) - do k = ktop + 1, kbot - w1 (k) = (dm (k) * w1 (k) - m1 (k - 1) * vts (k - 1) + m1 (k) * vts (k)) & - / (dm (k) + m1 (k - 1) - m1 (k)) + w1 (ks) = w1 (ks) + m1 (ks) * vts (ks) / dm (ks) + do k = ks + 1, ke + w1 (k) = (dm (k) * w1 (k) + m1 (k - 1) * (w1 (k - 1) - vts (k - 1)) + m1 (k) * vts (k)) & + / (dm (k) + m1 (k - 1)) enddo endif @@ -2572,25 +2827,25 @@ subroutine terminal_fall (dtm, ktop, kbot, tz, qv, ql, qr, qg, qs, qi, dz, dp, & ! melting of falling graupel into rain ! ---------------------------------------------- - call check_column (ktop, kbot, qg, no_fall) + call check_column (ks, ke, qg, no_fall) if (no_fall) then g1 = 0. else - do k = ktop + 1, kbot + do k = ks + 1, ke zt (k) = ze (k) - dt5 * (vtg (k - 1) + vtg (k)) enddo - zt (kbot + 1) = zs - dtm * vtg (kbot) + zt (ke + 1) = zs - dtm * vtg (ke) - do k = ktop, kbot + do k = ks, ke if (zt (k + 1) >= zt (k)) zt (k + 1) = zt (k) - dz_min enddo - if (k0 < kbot) then - do k = kbot - 1, k0, - 1 + if (k0 < ke) then + do k = ke - 1, k0, - 1 if (qg (k) > qrmin) then - do m = k + 1, kbot + do m = k + 1, ke if (zt (k + 1) >= ze (m)) exit dtime = min (dtm, (ze (m) - ze (m + 1)) / vtg (k)) if (zt (k) < ze (m + 1) .and. tz (m) > tice) then @@ -2611,26 +2866,49 @@ subroutine terminal_fall (dtm, ktop, kbot, tz, qv, ql, qr, qg, qs, qi, dz, dp, & endif if (do_sedi_w) then - do k = ktop, kbot + do k = ks, ke dm (k) = dp (k) * (1. + qv (k) + ql (k) + qr (k) + qi (k) + qs (k) + qg (k)) enddo endif + ! ----------------------------------------------------------------------- + ! energy loss during sedimentation + ! ----------------------------------------------------------------------- + + if (consv_checker) then + do k = ks, ke + te1 (k) = one_r8 + qv (k) * c1_vap + (ql (k) + qr (k)) * c1_liq + (qi (k) + qs (k) + qg (k)) * c1_ice + te1 (k) = rgrav * te1 (k) * c_air * tz (k) * dp (k) + enddo + endif + if (use_ppm) then - call lagrangian_fall_ppm (ktop, kbot, zs, ze, zt, dp, qg, g1, m1, mono_prof) + call lagrangian_fall_ppm (ks, ke, zs, ze, zt, dp, qg, g1, m1, mono_prof) else - call implicit_fall (dtm, ktop, kbot, ze, vtg, dp, qg, g1, m1) + call implicit_fall (dtm, ks, ke, ze, vtg, dp, qg, g1, m1) + endif + + ! ----------------------------------------------------------------------- + ! energy loss during sedimentation + ! ----------------------------------------------------------------------- + + if (consv_checker) then + do k = ks, ke + te2 (k) = one_r8 + qv (k) * c1_vap + (ql (k) + qr (k)) * c1_liq + (qi (k) + qs (k) + qg (k)) * c1_ice + te2 (k) = rgrav * te2 (k) * c_air * tz (k) * dp (k) + enddo + dte = dte + sum (te1) - sum (te2) endif - do k = ktop, kbot + do k = ks, ke m1_sol (k) = m1_sol (k) + m1 (k) enddo if (do_sedi_w) then - w1 (ktop) = (dm (ktop) * w1 (ktop) + m1 (ktop) * vtg (ktop)) / (dm (ktop) - m1 (ktop)) - do k = ktop + 1, kbot - w1 (k) = (dm (k) * w1 (k) - m1 (k - 1) * vtg (k - 1) + m1 (k) * vtg (k)) & - / (dm (k) + m1 (k - 1) - m1 (k)) + w1 (ks) = w1 (ks) + m1 (ks) * vtg (ks) / dm (ks) + do k = ks + 1, ke + w1 (k) = (dm (k) * w1 (k) + m1 (k - 1) * (w1 (k - 1) - vtg (k - 1)) + m1 (k) * vtg (k)) & + / (dm (k) + m1 (k - 1)) enddo endif @@ -2642,21 +2920,18 @@ end subroutine terminal_fall ! check if water species large enough to fall ! ======================================================================= -subroutine check_column (ktop, kbot, q, no_fall) +subroutine check_column (ks, ke, q, no_fall) implicit none - integer, intent (in) :: ktop, kbot - - real, intent (in) :: q (ktop:kbot) - + integer, intent (in) :: ks, ke + real, intent (in) :: q (ks:ke) logical, intent (out) :: no_fall - integer :: k no_fall = .true. - do k = ktop, kbot + do k = ks, ke if (q (k) > qrmin) then no_fall = .false. exit @@ -2670,29 +2945,21 @@ end subroutine check_column ! developed by sj lin, 2016 ! ======================================================================= -subroutine implicit_fall (dt, ktop, kbot, ze, vt, dp, q, precip, m1) +subroutine implicit_fall (dt, ks, ke, ze, vt, dp, q, precip, m1) implicit none - integer, intent (in) :: ktop, kbot - + integer, intent (in) :: ks, ke real, intent (in) :: dt - - real, intent (in), dimension (ktop:kbot + 1) :: ze - - real, intent (in), dimension (ktop:kbot) :: vt, dp - - real, intent (inout), dimension (ktop:kbot) :: q - - real, intent (out), dimension (ktop:kbot) :: m1 - + real, intent (in), dimension (ks:ke + 1) :: ze + real, intent (in), dimension (ks:ke) :: vt, dp + real, intent (inout), dimension (ks:ke) :: q + real, intent (out), dimension (ks:ke) :: m1 real, intent (out) :: precip - - real, dimension (ktop:kbot) :: dz, qm, dd - + real, dimension (ks:ke) :: dz, qm, dd integer :: k - do k = ktop, kbot + do k = ks, ke dz (k) = ze (k) - ze (k + 1) dd (k) = dt * vt (k) q (k) = q (k) * dp (k) @@ -2702,8 +2969,8 @@ subroutine implicit_fall (dt, ktop, kbot, ze, vt, dp, q, precip, m1) ! sedimentation: non - vectorizable loop ! ----------------------------------------------------------------------- - qm (ktop) = q (ktop) / (dz (ktop) + dd (ktop)) - do k = ktop + 1, kbot + qm (ks) = q (ks) / (dz (ks) + dd (ks)) + do k = ks + 1, ke qm (k) = (q (k) + dd (k - 1) * qm (k - 1)) / (dz (k) + dd (k)) enddo @@ -2711,7 +2978,7 @@ subroutine implicit_fall (dt, ktop, kbot, ze, vt, dp, q, precip, m1) ! qm is density at this stage ! ----------------------------------------------------------------------- - do k = ktop, kbot + do k = ks, ke qm (k) = qm (k) * dz (k) enddo @@ -2719,17 +2986,17 @@ subroutine implicit_fall (dt, ktop, kbot, ze, vt, dp, q, precip, m1) ! output mass fluxes: non - vectorizable loop ! ----------------------------------------------------------------------- - m1 (ktop) = q (ktop) - qm (ktop) - do k = ktop + 1, kbot + m1 (ks) = q (ks) - qm (ks) + do k = ks + 1, ke m1 (k) = m1 (k - 1) + q (k) - qm (k) enddo - precip = m1 (kbot) + precip = m1 (ke) ! ----------------------------------------------------------------------- ! update: ! ----------------------------------------------------------------------- - do k = ktop, kbot + do k = ks, ke q (k) = qm (k) / dp (k) enddo @@ -2737,43 +3004,34 @@ end subroutine implicit_fall ! ======================================================================= ! lagrangian scheme -! developed by sj lin, ???? +! developed by sj lin, around 2006 ! ======================================================================= -subroutine lagrangian_fall_ppm (ktop, kbot, zs, ze, zt, dp, q, precip, m1, mono) +subroutine lagrangian_fall_ppm (ks, ke, zs, ze, zt, dp, q, precip, m1, mono) implicit none - integer, intent (in) :: ktop, kbot - + integer, intent (in) :: ks, ke real, intent (in) :: zs - logical, intent (in) :: mono - - real, intent (in), dimension (ktop:kbot + 1) :: ze, zt - - real, intent (in), dimension (ktop:kbot) :: dp + real, intent (in), dimension (ks:ke + 1) :: ze, zt + real, intent (in), dimension (ks:ke) :: dp ! m1: flux - real, intent (inout), dimension (ktop:kbot) :: q, m1 - + real, intent (inout), dimension (ks:ke) :: q, m1 real, intent (out) :: precip + real, dimension (ks:ke) :: qm, dz - real, dimension (ktop:kbot) :: qm, dz - - real :: a4 (4, ktop:kbot) - + real :: a4 (4, ks:ke) real :: pl, pr, delz, esl - integer :: k, k0, n, m - real, parameter :: r3 = 1. / 3., r23 = 2. / 3. ! ----------------------------------------------------------------------- ! density: ! ----------------------------------------------------------------------- - do k = ktop, kbot + do k = ks, ke dz (k) = zt (k) - zt (k + 1) ! note: dz is positive q (k) = q (k) * dp (k) a4 (1, k) = q (k) / dz (k) @@ -2784,11 +3042,11 @@ subroutine lagrangian_fall_ppm (ktop, kbot, zs, ze, zt, dp, q, precip, m1, mono) ! construct vertical profile with zt as coordinate ! ----------------------------------------------------------------------- - call cs_profile (a4 (1, ktop), dz (ktop), kbot - ktop + 1, mono) + call cs_profile (a4 (1, ks), dz (ks), ke - ks + 1, mono) - k0 = ktop - do k = ktop, kbot - do n = k0, kbot + k0 = ks + do k = ks, ke + do n = k0, ke if (ze (k) <= zt (n) .and. ze (k) >= zt (n + 1)) then pl = (zt (n) - ze (k)) / dz (n) if (zt (n + 1) <= ze (k + 1)) then @@ -2802,8 +3060,8 @@ subroutine lagrangian_fall_ppm (ktop, kbot, zs, ze, zt, dp, q, precip, m1, mono) else qm (k) = (ze (k) - zt (n + 1)) * (a4 (2, n) + 0.5 * (a4 (4, n) + & a4 (3, n) - a4 (2, n)) * (1. + pl) - a4 (4, n) * (r3 * (1. + pl * (1. + pl)))) - if (n < kbot) then - do m = n + 1, kbot + if (n < ke) then + do m = n + 1, ke ! locate the bottom edge: ze (k + 1) if (ze (k + 1) < zt (m + 1)) then qm (k) = qm (k) + q (m) @@ -2824,16 +3082,16 @@ subroutine lagrangian_fall_ppm (ktop, kbot, zs, ze, zt, dp, q, precip, m1, mono) 555 continue enddo - m1 (ktop) = q (ktop) - qm (ktop) - do k = ktop + 1, kbot + m1 (ks) = q (ks) - qm (ks) + do k = ks + 1, ke m1 (k) = m1 (k - 1) + q (k) - qm (k) enddo - precip = m1 (kbot) + precip = m1 (ke) ! convert back to * dry * mixing ratio: ! dp must be dry air_mass (because moist air mass will be changed due to terminal fall) . - do k = ktop, kbot + do k = ks, ke q (k) = qm (k) / dp (k) enddo @@ -2844,15 +3102,10 @@ subroutine cs_profile (a4, del, km, do_mono) implicit none integer, intent (in) :: km ! vertical dimension - real, intent (in) :: del (km) - logical, intent (in) :: do_mono - real, intent (inout) :: a4 (4, km) - real, parameter :: qp_min = 1.e-6 - real :: gam (km) real :: q (km + 1) real :: d4, bet, a_bot, grat, pmp, lac @@ -3056,14 +3309,15 @@ end subroutine cs_limiters ! calculation of vertical fall speed ! ======================================================================= -subroutine fall_speed (ktop, kbot, den, qs, qi, qg, ql, tk, vts, vti, vtg) +subroutine fall_speed (ks, ke, den, qs, qi, qg, ql, tk, vts, vti, vtg) implicit none - integer, intent (in) :: ktop, kbot + integer, intent (in) :: ks, ke - real, intent (in), dimension (ktop:kbot) :: den, qs, qi, qg, ql, tk - real, intent (out), dimension (ktop:kbot) :: vts, vti, vtg + real (kind = r_grid), intent (in), dimension (ks:ke) :: tk + real, intent (in), dimension (ks:ke) :: den, qs, qi, qg, ql + real, intent (out), dimension (ks:ke) :: vts, vti, vtg ! fall velocity constants: @@ -3081,12 +3335,12 @@ subroutine fall_speed (ktop, kbot, den, qs, qi, qg, ql, tk, vts, vti, vtg) real, parameter :: vcons = 6.6280504 real, parameter :: vcong = 87.2382675 - real, parameter :: vconh = vcong * sqrt (rhoh / rhog) + real, parameter :: vconh = vcong * sqrt (rhoh / rhog) ! 132.087495104005 real, parameter :: norms = 942477796.076938 real, parameter :: normg = 5026548245.74367 - real, parameter :: normh = pi * rhoh * rnzh + real, parameter :: normh = pi * rhoh * rnzh ! 115233618.533674 - real, dimension (ktop:kbot) :: qden, tc, rhof + real, dimension (ks:ke) :: qden, tc, rhof real :: vi0 @@ -3101,7 +3355,7 @@ subroutine fall_speed (ktop, kbot, den, qs, qi, qg, ql, tk, vts, vti, vtg) ! much smaller than sfcrho over high mountains ! ----------------------------------------------------------------------- - do k = ktop, kbot + do k = ks, ke rhof (k) = sqrt (min (10., sfcrho / den (k))) enddo @@ -3116,13 +3370,19 @@ subroutine fall_speed (ktop, kbot, den, qs, qi, qg, ql, tk, vts, vti, vtg) ! use deng and mace (2008, grl), which gives smaller fall speed than hd90 formula ! ----------------------------------------------------------------------- vi0 = 0.01 * vi_fac - do k = ktop, kbot + do k = ks, ke if (qi (k) < thi) then ! this is needed as the fall - speed maybe problematic for small qi vti (k) = vf_min else tc (k) = tk (k) - tice - vti (k) = (3. + log10 (qi (k) * den (k))) * (tc (k) * (aa * tc (k) + bb) + cc) + dd * tc (k) + ee - vti (k) = vi0 * exp (log_10 * vti (k)) + if (hd_icefall) then + ! heymsfield and donner, 1990, jas + vti (k) = vi_fac * 3.29 * (qi (k) * den (k)) ** 0.16 + else + ! deng and mace, 2008, grl + vti (k) = (3. + log10 (qi (k) * den (k))) * (tc (k) * (aa * tc (k) + bb) + cc) + dd * tc (k) + ee + vti (k) = vi0 * exp (log_10 * vti (k)) + endif vti (k) = min (vi_max, max (vf_min, vti (k))) endif enddo @@ -3135,7 +3395,7 @@ subroutine fall_speed (ktop, kbot, den, qs, qi, qg, ql, tk, vts, vti, vtg) if (const_vs) then vts (:) = vs_fac ! 1. ifs_2016 else - do k = ktop, kbot + do k = ks, ke if (qs (k) < ths) then vts (k) = vf_min else @@ -3153,7 +3413,7 @@ subroutine fall_speed (ktop, kbot, den, qs, qi, qg, ql, tk, vts, vti, vtg) vtg (:) = vg_fac ! 2. else if (do_hail) then - do k = ktop, kbot + do k = ks, ke if (qg (k) < thg) then vtg (k) = vf_min else @@ -3162,7 +3422,7 @@ subroutine fall_speed (ktop, kbot, den, qs, qi, qg, ql, tk, vts, vti, vtg) endif enddo else - do k = ktop, kbot + do k = ks, ke if (qg (k) < thg) then vtg (k) = vf_min else @@ -3194,9 +3454,8 @@ subroutine setupm gam425 = 8.285063, gam450 = 11.631769, gam480 = 17.837789, & gam625 = 184.860962, gam680 = 496.604067 - ! density / slope parameters now moved up to module level - real, parameter :: acc (3) = (/ 5.0, 2.0, 0.5 /) + real den_rc integer :: i, k @@ -3220,11 +3479,11 @@ subroutine setupm tcond = 2.36e-2 visk = 1.259e-5 - hlts = 2.8336e6 - hltc = 2.5e6 - hltf = 3.336e5 + hlts = hlv + hlf + hltc = hlv + hltf = hlf - ch2o = 4.1855e3 + ch2o = c_liq ri50 = 1.e-4 pisq = pie * pie @@ -3331,7 +3590,7 @@ subroutine setupm cgmlt (4) = cgsub (3) cgmlt (5) = ch2o / hltf - es0 = 6.107799961e2 ! ~6.1 mb + es0 = e00 ces0 = eps * es0 end subroutine setupm @@ -3340,53 +3599,21 @@ end subroutine setupm ! initialization of gfdl cloud microphysics ! ======================================================================= -!subroutine gfdl_cloud_microphys_init (id, jd, kd, axes, time) -subroutine gfdl_cloud_microphys_init (me, master, nlunit, input_nml_file, logunit, fn_nml) +subroutine gfdl_cld_mp_init (input_nml_file, logunit) implicit none - integer, intent (in) :: me - integer, intent (in) :: master - integer, intent (in) :: nlunit - integer, intent (in) :: logunit - - character (len = 64), intent (in) :: fn_nml character (len = *), intent (in) :: input_nml_file (:) + integer, intent (in) :: logunit - integer :: ios logical :: exists - ! integer, intent (in) :: id, jd, kd - ! integer, intent (in) :: axes (4) - ! type (time_type), intent (in) :: time - - ! integer :: unit, io, ierr, k, logunit - ! logical :: flag - ! real :: tmp, q1, q2 - - ! master = (mpp_pe () .eq.mpp_root_pe ()) - -#ifdef INTERNAL_FILE_NML - read (input_nml_file, nml = gfdl_cloud_microphysics_nml, iostat = ios) -#else - inquire (file = trim (fn_nml), exist = exists) - if (.not. exists) then - write (6, *) 'gfdl - mp :: namelist file: ', trim (fn_nml), ' does not exist' - call mpp_error (fatal, 'gfdl - mp :: namelist file: ' // trim (fn_nml) // ' does not exist') - else - open (unit = nlunit, file = fn_nml, readonly, status = 'old', iostat = ios) - endif - rewind (nlunit) - read (nlunit, nml = gfdl_cloud_microphysics_nml, iostat = ios) - close (nlunit) -#endif + read (input_nml_file, nml = gfdl_mp_nml) ! write version number and namelist to log file - if (me == master) then - write (logunit, *) " ================================================================== " - write (logunit, *) "gfdl_cloud_microphys_mod" - write (logunit, nml = gfdl_cloud_microphysics_nml) - endif + write (logunit, *) " ================================================================== " + write (logunit, *) "gfdl_mp_mod" + write (logunit, nml = gfdl_mp_nml) if (do_setup) then call setup_con @@ -3394,43 +3621,24 @@ subroutine gfdl_cloud_microphys_init (me, master, nlunit, input_nml_file, loguni do_setup = .false. endif + g2 = 0.5 * grav log_10 = log (10.) - tice0 = tice - 0.01 - t_wfr = tice - 40.0 ! supercooled water can exist down to - 48 c, which is the "absolute" - - ! if (master) write (logunit, nml = gfdl_cloud_microphys_nml) - - ! if (master) write (*, *) 'prec_lin diagnostics initialized.', id_prec - - ! call qsmith_init - - ! testing the water vapor tables - - ! if (mp_debug .and. master) then - ! write (*, *) 'testing water vapor tables in gfdl_cloud_microphys' - ! tmp = tice - 90. - ! do k = 1, 25 - ! q1 = wqsat_moist (tmp, 0., 1.e5) - ! q2 = qs1d_m (tmp, 0., 1.e5) - ! write (*, *) nint (tmp - tice), q1, q2, 'dq = ', q1 - q2 - ! tmp = tmp + 5. - ! enddo - ! endif - - ! if (master) write (*, *) 'gfdl_cloud_micrphys diagnostics initialized.' - - ! gfdl_mp_clock = mpp_clock_id ('gfdl_cloud_microphys', grain = clock_routine) + if (do_warm_rain_mp) then + t_wfr = t_min + else + t_wfr = t_ice - 40.0 + endif module_is_initialized = .true. -end subroutine gfdl_cloud_microphys_init +end subroutine gfdl_cld_mp_init ! ======================================================================= ! end of gfdl cloud microphysics ! ======================================================================= -subroutine gfdl_cloud_microphys_end +subroutine gfdl_cld_mp_end implicit none @@ -3445,7 +3653,7 @@ subroutine gfdl_cloud_microphys_end tables_are_initialized = .false. -end subroutine gfdl_cloud_microphys_end +end subroutine gfdl_cld_mp_end ! ======================================================================= ! qsmith table initialization @@ -3457,8 +3665,6 @@ subroutine setup_con ! master = (mpp_pe () .eq.mpp_root_pe ()) - rgrav = 1. / grav - if (.not. qsmith_tables_initialized) call qsmith_init qsmith_tables_initialized = .true. @@ -3545,17 +3751,6 @@ subroutine qsmith_init if (.not. tables_are_initialized) then - ! master = (mpp_pe () .eq. mpp_root_pe ()) - ! if (master) print *, ' gfdl mp: initializing qs tables' - - ! debug code - ! print *, mpp_pe (), allocated (table), allocated (table2), & - ! allocated (table3), allocated (tablew), allocated (des), & - ! allocated (des2), allocated (des3), allocated (desw) - ! end debug code - - ! generate es table (dt = 0.1 deg. c) - allocate (table (length)) allocate (table2 (length)) allocate (table3 (length)) @@ -3625,11 +3820,8 @@ real function wqs2 (ta, den, dqdt) ! input "den" can be either dry or moist air density real, intent (in) :: ta, den - real, intent (out) :: dqdt - real :: es, ap1, tmin - integer :: it tmin = table_ice - 160. @@ -3647,6 +3839,43 @@ real function wqs2 (ta, den, dqdt) end function wqs2 +! ======================================================================= +! compute the gradient of saturated specific humidity for table ii +! it is the same as "wqs2", but written as vector function +! ======================================================================= + +subroutine wqs2_vect (is, ie, ta, den, wqsat, dqdt) + + implicit none + + ! pure water phase; universal dry / moist formular using air density + ! input "den" can be either dry or moist air density + + integer, intent (in) :: is, ie + + real, intent (in), dimension (is:ie) :: ta, den + + real, intent (out), dimension (is:ie) :: wqsat, dqdt + + real :: es, ap1, tmin + + integer :: i, it + + tmin = t_ice - 160. + + do i = is, ie + ap1 = 10. * dim (ta (i), tmin) + 1. + ap1 = min (2621., ap1) + it = ap1 + es = tablew (it) + (ap1 - it) * desw (it) + wqsat (i) = es / (rvgas * ta (i) * den (i)) + it = ap1 - 0.5 + ! finite diff, del_t = 0.1: + dqdt (i) = 10. * (desw (it) + (ap1 - it) * (desw (it + 1) - desw (it))) / (rvgas * ta (i) * den (i)) + enddo + +end subroutine wqs2_vect + ! ======================================================================= ! compute wet buld temperature ! ======================================================================= @@ -3710,12 +3939,10 @@ real function iqs2 (ta, den, dqdt) ! water - ice phase; universal dry / moist formular using air density ! input "den" can be either dry or moist air density - real, intent (in) :: ta, den - + real (kind = r_grid), intent (in) :: ta + real, intent (in) :: den real, intent (out) :: dqdt - - real :: es, ap1, tmin - + real (kind = r_grid) :: tmin, es, ap1 integer :: it tmin = table_ice - 160. @@ -3997,8 +4224,8 @@ subroutine qs_tablew (n) integer, intent (in) :: n - real :: delt = 0.1 - real :: tmin, tem, fac0, fac1, fac2 + real (kind = r_grid) :: delt = 0.1 + real (kind = r_grid) :: tmin, tem, fac0, fac1, fac2 integer :: i @@ -4029,8 +4256,8 @@ subroutine qs_table2 (n) integer, intent (in) :: n - real :: delt = 0.1 - real :: tmin, tem0, tem1, fac0, fac1, fac2 + real (kind = r_grid) :: delt = 0.1 + real (kind = r_grid) :: tmin, tem0, tem1, fac0, fac1, fac2 integer :: i, i0, i1 @@ -4079,9 +4306,9 @@ subroutine qs_table3 (n) integer, intent (in) :: n - real :: delt = 0.1 - real :: esbasw, tbasw, esbasi, tmin, tem, aa, b, c, d, e - real :: tem0, tem1 + real (kind = r_grid) :: delt = 0.1 + real (kind = r_grid) :: esbasw, tbasw, esbasi, tmin, tem, aa, b, c, d, e + real (kind = r_grid) :: tem0, tem1 integer :: i, i0, i1 @@ -4099,9 +4326,9 @@ subroutine qs_table3 (n) ! see smithsonian meteorological tables page 350. ! ----------------------------------------------------------------------- aa = - 9.09718 * (table_ice / tem - 1.) - b = - 3.56654 * alog10 (table_ice / tem) + b = - 3.56654 * log10 (table_ice / tem) c = 0.876793 * (1. - tem / table_ice) - e = alog10 (esbasi) + e = log10 (esbasi) table3 (i) = 0.1 * 10 ** (aa + b + c + e) else ! ----------------------------------------------------------------------- @@ -4109,10 +4336,10 @@ subroutine qs_table3 (n) ! see smithsonian meteorological tables page 350. ! ----------------------------------------------------------------------- aa = - 7.90298 * (tbasw / tem - 1.) - b = 5.02808 * alog10 (tbasw / tem) + b = 5.02808 * log10 (tbasw / tem) c = - 1.3816e-7 * (10 ** ((1. - tem / tbasw) * 11.344) - 1.) d = 8.1328e-3 * (10 ** ((tbasw / tem - 1.) * (- 3.49149)) - 1.) - e = alog10 (esbasw) + e = log10 (esbasw) table3 (i) = 0.1 * 10 ** (aa + b + c + d + e) endif enddo @@ -4165,10 +4392,10 @@ subroutine qs_table (n) integer, intent (in) :: n - real :: delt = 0.1 - real :: tmin, tem, esh20 - real :: wice, wh2o, fac0, fac1, fac2 - real :: esupc (200) + real (kind = r_grid) :: delt = 0.1 + real (kind = r_grid) :: tmin, tem, esh20 + real (kind = r_grid) :: wice, wh2o, fac0, fac1, fac2 + real (kind = r_grid) :: esupc (200) integer :: i @@ -4274,17 +4501,17 @@ end subroutine qsmith ! this is designed for 6 - class micro - physics schemes ! ======================================================================= -subroutine neg_adj (ktop, kbot, pt, dp, qv, ql, qr, qi, qs, qg) +subroutine neg_adj (ks, ke, pt, dp, qv, ql, qr, qi, qs, qg, cond) implicit none - integer, intent (in) :: ktop, kbot + integer, intent (in) :: ks, ke + real, intent (in), dimension (ks:ke) :: dp + real (kind = r_grid), intent (inout), dimension (ks:ke) :: pt + real, intent (inout), dimension (ks:ke) :: qv, ql, qr, qi, qs, qg + real, intent (out) :: cond - real, intent (in), dimension (ktop:kbot) :: dp - - real, intent (inout), dimension (ktop:kbot) :: pt, qv, ql, qr, qi, qs, qg - - real, dimension (ktop:kbot) :: lcpk, icpk + real, dimension (ks:ke) :: lcpk, icpk real :: dq, cvm @@ -4294,13 +4521,15 @@ subroutine neg_adj (ktop, kbot, pt, dp, qv, ql, qr, qi, qs, qg) ! define heat capacity and latent heat coefficient ! ----------------------------------------------------------------------- - do k = ktop, kbot - cvm = c_air + qv (k) * c_vap + (qr (k) + ql (k)) * c_liq + (qi (k) + qs (k) + qg (k)) * c_ice - lcpk (k) = (lv00 + d0_vap * pt (k)) / cvm - icpk (k) = (li00 + dc_ice * pt (k)) / cvm + do k = ks, ke + cvm = 1. + qv (k) * c1_vap + (qr (k) + ql (k)) * c1_liq + (qi (k) + qs (k) + qg (k)) * c1_ice + lcpk (k) = (lv00 + d1_vap * pt (k)) / cvm + icpk (k) = (li00 + d1_ice * pt (k)) / cvm enddo - do k = ktop, kbot + cond = 0 + + do k = ks, ke ! ----------------------------------------------------------------------- ! ice phase: @@ -4334,6 +4563,7 @@ subroutine neg_adj (ktop, kbot, pt, dp, qv, ql, qr, qi, qs, qg) endif ! if cloud water < 0, borrow from water vapor if (ql (k) < 0.) then + cond = cond - ql (k) * dp (k) qv (k) = qv (k) + ql (k) pt (k) = pt (k) - ql (k) * lcpk (k) ! heating ql (k) = 0. @@ -4345,7 +4575,7 @@ subroutine neg_adj (ktop, kbot, pt, dp, qv, ql, qr, qi, qs, qg) ! fix water vapor; borrow from below ! ----------------------------------------------------------------------- - do k = ktop, kbot - 1 + do k = ks, ke - 1 if (qv (k) < 0.) then qv (k + 1) = qv (k + 1) + qv (k) * dp (k) / dp (k + 1) qv (k) = 0. @@ -4356,102 +4586,12 @@ subroutine neg_adj (ktop, kbot, pt, dp, qv, ql, qr, qi, qs, qg) ! bottom layer; borrow from above ! ----------------------------------------------------------------------- - if (qv (kbot) < 0. .and. qv (kbot - 1) > 0.) then - dq = min (- qv (kbot) * dp (kbot), qv (kbot - 1) * dp (kbot - 1)) - qv (kbot - 1) = qv (kbot - 1) - dq / dp (kbot - 1) - qv (kbot) = qv (kbot) + dq / dp (kbot) + if (qv (ke) < 0. .and. qv (ke - 1) > 0.) then + dq = min (- qv (ke) * dp (ke), qv (ke - 1) * dp (ke - 1)) + qv (ke - 1) = qv (ke - 1) - dq / dp (ke - 1) + qv (ke) = qv (ke) + dq / dp (ke) endif end subroutine neg_adj -! ======================================================================= -! compute global sum -! quick local sum algorithm -! ======================================================================= - -!real function g_sum (p, ifirst, ilast, jfirst, jlast, area, mode) -! -! use mpp_mod, only: mpp_sum -! -! implicit none -! -! integer, intent (in) :: ifirst, ilast, jfirst, jlast -! integer, intent (in) :: mode ! if == 1 divided by area -! -! real, intent (in), dimension (ifirst:ilast, jfirst:jlast) :: p, area -! -! integer :: i, j -! -! real :: gsum -! -! if (global_area < 0.) then -! global_area = 0. -! do j = jfirst, jlast -! do i = ifirst, ilast -! global_area = global_area + area (i, j) -! enddo -! enddo -! call mpp_sum (global_area) -! endif -! -! gsum = 0. -! do j = jfirst, jlast -! do i = ifirst, ilast -! gsum = gsum + p (i, j) * area (i, j) -! enddo -! enddo -! call mpp_sum (gsum) -! -! if (mode == 1) then -! g_sum = gsum / global_area -! else -! g_sum = gsum -! endif -! -!end function g_sum - -! ======================================================================= -! interpolate to a prescribed height -! ======================================================================= - -subroutine interpolate_z (is, ie, km, zl, hgt, a3, a2) - - implicit none - - integer, intent (in) :: is, ie, km - - real, intent (in), dimension (is:ie, km) :: a3 - - real, intent (in), dimension (is:ie, km + 1) :: hgt ! hgt (k) > hgt (k + 1) - - real, intent (in) :: zl - - real, intent (out), dimension (is:ie) :: a2 - - real, dimension (km) :: zm ! middle layer height - - integer :: i, k - - !$omp parallel do default (none) shared (is, ie, km, hgt, zl, a2, a3) private (zm) - - do i = is, ie - do k = 1, km - zm (k) = 0.5 * (hgt (i, k) + hgt (i, k + 1)) - enddo - if (zl >= zm (1)) then - a2 (i) = a3 (i, 1) - elseif (zl <= zm (km)) then - a2 (i) = a3 (i, km) - else - do k = 1, km - 1 - if (zl <= zm (k) .and. zl >= zm (k + 1)) then - a2 (i) = a3 (i, k) + (a3 (i, k + 1) - a3 (i, k)) * (zm (k) - zl) / (zm (k) - zm (k + 1)) - exit - endif - enddo - endif - enddo - -end subroutine interpolate_z - -end module gfdl_cloud_microphys_mod +end module gfdl_cld_mp_mod diff --git a/model/gfdl_mp.F90 b/model/gfdl_mp.F90 index 825dc513b..f9b8b9fd7 100644 --- a/model/gfdl_mp.F90 +++ b/model/gfdl_mp.F90 @@ -10,7 +10,7 @@ !* (at your option) any later version. !* !* The FV3 dynamical core is distributed in the hope that it will be -!* useful, but WITHOUT ANYWARRANTY; without even the implied warranty +!* useful, but WITHOUT ANY WARRANTY; without even the implied warranty !* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. !* See the GNU General Public License for more details. !* @@ -25,133 +25,159 @@ ! bears little to no similarity to the original lin mp in zetac. ! therefore, it is best to be called gfdl micro - physics (gfdl mp) . ! developer: shian - jiann lin, linjiong zhou -! revision: inline gfdl cloud microphysics, 9 / 8 / 2017 ! ======================================================================= module gfdl_mp_mod - ! use mpp_mod, only: stdlog, mpp_pe, mpp_root_pe, mpp_clock_id, & - ! mpp_clock_begin, mpp_clock_end, clock_routine, & - ! input_nml_file - ! use time_manager_mod, only: time_type - ! use constants_mod, only: grav, rdgas, rvgas, cp_air, hlv, hlf, pi => pi_8 - ! use fms_mod, only: write_version_number, open_namelist_file, & - ! check_nml_error, file_exist, close_file use fv_arrays_mod, only: r_grid + use fv_mp_mod, only : is_master implicit none private - public gfdl_mp_driver, gfdl_mp_init, gfdl_mp_end, wqs1, do_hail, wqs2, iqs1, iqs2, qsmith_init, c_liq + public gfdl_mp_driver, gfdl_mp_init, gfdl_mp_end + public wqs1, wqs2, iqs1, iqs2, mpdrv, sedi_heat, warm_rain, revap_racc, & + linear_prof, icloud, subgrid_z_proc, terminal_fall, check_column, implicit_fall, & + lagrangian_fall_ppm, cs_profile, cs_limiters, fall_speed, setupm, setup_con, & + qsmith_init, qs_tablew, qs_table2, qs_table3, qs_table, neg_adj, acr3d, smlt, gmlt, & + wet_bulb, qsmith, qs_blend, es3_table1d, es2_table1d, esw_table1d, es2_table, & + esw_table, d_sat, qs1d_m, wqsat_moist, wqsat2_moist, qs1d_moist, revap_rac1, & + wqs2_vect, rhow, rhor, rhos, rhog, rhoh, rnzr, rnzs, rnzg, rnzh, rvgas, rdgas, & + grav, hlv, hlf, cp_air, cp_vap, cv_air, cv_vap, c_ice, c_liq, dc_vap, dc_ice, & + t_ice, t_wfr, e00, pi, zvir, rgrav real :: missing_value = - 1.e10 logical :: module_is_initialized = .false. logical :: qsmith_tables_initialized = .false. - character (len = 17) :: mod_name = 'gfdl_mp' - real, parameter :: grav = 9.80665 ! gfs: acceleration due to gravity real, parameter :: rdgas = 287.05 ! gfs: gas constant for dry air real, parameter :: rvgas = 461.50 ! gfs: gas constant for water vapor - real, parameter :: cp_air = 1004.6 ! gfs: heat capacity of dry air at constant pressure + real, parameter :: cp_air = 1.0046e3 ! gfs: heat capacity of dry air at constant pressure real, parameter :: hlv = 2.5e6 ! gfs: latent heat of evaporation real, parameter :: hlf = 3.3358e5 ! gfs: latent heat of fusion real, parameter :: pi = 3.1415926535897931 ! gfs: ratio of circle circumference to diameter + ! real, parameter :: cp_air = rdgas * 7. / 2. ! 1004.675, heat capacity of dry air at constant pressure real, parameter :: cp_vap = 4.0 * rvgas ! 1846.0, heat capacity of water vapore at constnat pressure - ! real, parameter :: cv_air = 717.56 ! satoh value + ! real, parameter :: cv_air = 717.56 ! satoh value, heat capacity of dry air at constant volume real, parameter :: cv_air = cp_air - rdgas ! 717.55, heat capacity of dry air at constant volume - ! real, parameter :: cv_vap = 1410.0 ! emanuel value + ! real, parameter :: cv_vap = 1410.0 ! emanuel value, heat capacity of water vapor at constant volume real, parameter :: cv_vap = 3.0 * rvgas ! 1384.5, heat capacity of water vapor at constant volume -#ifdef TEST_ICE0 - real, parameter :: c_ice = 1972. ! gfdl: heat capacity of ice at - 15 deg c - real, parameter :: c_liq = 4.1855e+3 ! gfs: heat capacity of water at 15 c - ! c_liq - c_ice = 2213 -#else - real, parameter :: c_ice = 2106. ! heat capacity of ice at 0. deg c - ! ifs documentation: - real, parameter :: c_liq = 4218. ! c_liq - c_ice = 2112 - ! emanual's book: - ! real, parameter :: c_liq = 4190.0 ! heat capacity of water at 0 deg c -#endif + ! http: // www.engineeringtoolbox.com / ice - thermal - properties - d_576.html + ! c_ice = 2050.0 at 0 deg c + ! c_ice = 2000.0 at - 10 deg c + ! c_ice = 1943.0 at - 20 deg c + ! c_ice = 1882.0 at - 30 deg c + ! c_ice = 1818.0 at - 40 deg c + + ! https: // www.engineeringtoolbox.com / specific - heat - capacity - water - d_660.html + ! c_liq = 4219.9 at 0.01 deg c + ! c_liq = 4195.5 at 10 deg c + ! c_liq = 4184.4 at 20 deg c + ! c_liq = 4180.1 at 30 deg c + ! c_liq = 4179.6 at 40 deg c + + ! the following two are from emanuel's book "atmospheric convection" + ! real, parameter :: c_ice = 2.106e3 ! heat capacity of ice at 0 deg c: c = c_ice + 7.3 * (t - tice) + ! real, parameter :: c_liq = 4.190e3 ! heat capacity of water at 0 deg c + ! real, parameter :: c_ice = 1.972e3 ! gfdl: heat capacity of ice at - 15 deg c + ! real, parameter :: c_liq = 4.1855e3 ! gfdl: heat capacity of water at 15 deg c + ! real, parameter :: c_ice = 2.106e3 ! gfs: heat capacity of ice at 0 deg c + ! real, parameter :: c_liq = 4.1855e3 ! gfs: heat capacity of liquid at 15 deg c + real, parameter :: c_ice = 2.106e3 ! ifs: heat capacity of ice at 0 deg c + real, parameter :: c_liq = 4.218e3 ! ifs: heat capacity of water at 0 deg c real, parameter :: eps = rdgas / rvgas ! 0.6219934995 real, parameter :: zvir = rvgas / rdgas - 1. ! 0.6077338443 + real, parameter :: dc_vap = cp_vap - c_liq ! - 2.372e3, isobaric heating / cooling + real, parameter :: dc_ice = c_liq - c_ice ! 2.112e3, isobaric heating / colling + real, parameter :: t_ice = 273.16 ! freezing temperature real, parameter :: table_ice = 273.16 ! freezing point for qs table + real :: t_wfr ! complete freezing temperature - ! real, parameter :: e00 = 610.71 ! gfdl: saturation vapor pressure at 0 deg c real (kind = r_grid), parameter :: e00 = 611.21 ! ifs: saturation vapor pressure at 0 deg c - - real, parameter :: dc_vap = cp_vap - c_liq ! - 2339.5, isobaric heating / cooling - real, parameter :: dc_ice = c_liq - c_ice ! 2213.5, isobaric heating / colling + ! real (kind = r_grid), parameter :: e00 = 610.71 ! gfdl: saturation vapor pressure at 0 deg c real, parameter :: hlv0 = hlv ! gfs: evaporation latent heat coefficient at 0 deg c - ! real, parameter :: hlv0 = 2.501e6 ! emanuel appendix - 2 + ! real, parameter :: hlv0 = 2.501e6 ! emanuel value real, parameter :: hlf0 = hlf ! gfs: fussion latent heat coefficient at 0 deg c - ! real, parameter :: hlf0 = 3.337e5 ! emanuel + ! real, parameter :: hlf0 = 3.337e5 ! emanuel value - real, parameter :: lv0 = hlv0 - dc_vap * t_ice! 3.13905782e6, evaporation latent heat coefficient at 0 deg k - real, parameter :: li0 = hlf0 - dc_ice * t_ice! - 2.7105966e5, fussion latend heat coefficient at 0 deg k + real, parameter :: lv0 = hlv0 - dc_vap * t_ice ! 3.14893552e6, evaporation latent heat coefficient at 0 deg k + real, parameter :: li0 = hlf0 - dc_ice * t_ice ! - 2.2691392e5, fussion latend heat coefficient at 0 deg k - ! real (kind = r_grid), parameter :: d2ice = dc_vap + dc_ice ! - 126, isobaric heating / cooling - real (kind = r_grid), parameter :: d2ice = cp_vap - c_ice - ! d2ice = cp_vap - c_ice - real (kind = r_grid), parameter :: li2 = lv0 + li0 ! 2.86799816e6, sublimation latent heat coefficient at 0 deg k + real (kind = r_grid), parameter :: d2ice = cp_vap - c_ice ! - 260.0, isobaric heating / cooling + real (kind = r_grid), parameter :: li2 = lv0 + li0 ! 2.9220216e6, sublimation latent heat coefficient at 0 deg k - real, parameter :: qrmin = 1.e-8 ! min value for ??? + real, parameter :: qrmin = 1.e-8 ! min value for cloud condensates real, parameter :: qvmin = 1.e-20 ! min value for water vapor (treated as zero) real, parameter :: qcmin = 1.e-12 ! min value for cloud condensates real, parameter :: vr_min = 1.e-3 ! min fall speed for rain real, parameter :: vf_min = 1.e-5 ! min fall speed for cloud ice, snow, graupel - real, parameter :: dz_min = 1.e-2 ! use for correcting flipped height + real, parameter :: dz_min = 1.e-2 ! used for correcting flipped height real, parameter :: sfcrho = 1.2 ! surface air density - ! intercept parameters + real, parameter :: rnzr = 8.0e6 ! lin et al. 1983 + real, parameter :: rnzs = 3.0e6 ! lin et al. 1983 + real, parameter :: rnzg = 4.0e6 ! rutledge and hobbs 1984 + ! lmh, 20170929 + real, parameter :: rnzh = 4.0e4 ! lin et al. 1983 - real, parameter :: rnzr = 8.0e6 ! lin83 - real, parameter :: rnzs = 3.0e6 ! lin83 - real, parameter :: rnzg = 4.0e6 ! rh84 - real, parameter :: rnzh = 4.0e4 ! lin83 --- lmh 29 sep 17 + real, parameter :: rhow = 1.0e3 ! density of cloud water + real, parameter :: rhor = 1.0e3 ! lin et al. 1983 + real, parameter :: rhos = 0.1e3 ! lin et al. 1983 + real, parameter :: rhog = 0.4e3 ! rutledge and hobbs 1984 + ! lmh, 20170929 + real, parameter :: rhoh = 0.917e3 ! lin et al. 1983 - ! density parameters - - real, parameter :: rhor = 1.e3 ! density of rain water, lin83 - real, parameter :: rhos = 0.1e3 ! lin83 (snow density; 1 / 10 of water) - real, parameter :: rhog = 0.4e3 ! rh84 (graupel density) - real, parameter :: rhoh = 0.917e3 ! lin83 --- lmh 29 sep 17 + real, parameter :: rgrav = 1. / grav real :: cracs, csacr, cgacr, cgacs, csacw, craci, csaci, cgacw, cgaci, cracw ! constants for accretions real :: acco (3, 4) ! constants for accretions + ! constants for sublimation / deposition, freezing / melting, condensation / evaporation real :: cssub (5), cgsub (5), crevp (5), cgfr (2), csmlt (5), cgmlt (5) real :: es0, ces0 - real :: pie, rgrav, fac_rc + real :: pie, fac_rc real :: c_air, c_vap real :: lat2, lcp, icp, tcp ! used in bigg mechanism and wet bulk real :: d0_vap ! the same as dc_vap, except that cp_vap can be cp_vap or cv_vap real (kind = r_grid) :: lv00, li00, li20 - ! scaled constants: real (kind = r_grid) :: d1_vap, d1_ice, c1_vap, c1_liq, c1_ice real (kind = r_grid), parameter :: one_r8 = 1. - integer :: ntimes = 1 ! cloud microphysics sub cycles + real, allocatable :: table (:), table2 (:), table3 (:), tablew (:) + real, allocatable :: des (:), des2 (:), des3 (:), desw (:) + + logical :: tables_are_initialized = .false. + + real, parameter :: dt_fr = 8. ! homogeneous freezing of all cloud water at t_wfr - dt_fr + ! minimum temperature water can exist (moore & molinero nov. 2011, nature) + ! dt_fr can be considered as the error bar - ! cloud microphysics switchers + real, parameter :: p0_min = 100. ! minimum pressure (pascal) for mp to operate + real :: p_min + + ! ----------------------------------------------------------------------- + ! namelist parameters + ! ----------------------------------------------------------------------- + + integer :: ntimes = 1 ! cloud microphysics sub cycles integer :: icloud_f = 0 ! cloud scheme integer :: irain_f = 0 ! cloud water to rain auto conversion scheme - logical :: de_ice = .false. ! to prevent excessive build - up of cloud ice from external sources logical :: sedi_transport = .true. ! transport of momentum in sedimentation logical :: do_sedi_w = .true. ! transport of vertical momentum during sedimentation logical :: do_sedi_heat = .true. ! transport of heat in sedimentation @@ -165,43 +191,18 @@ module gfdl_mp_mod logical :: disp_heat = .false. ! dissipative heating due to sedimentation logical :: do_cond_timescale = .false. ! whether to apply a timescale to condensation - real, allocatable :: table (:), table2 (:), table3 (:), tablew (:) - real, allocatable :: des (:), des2 (:), des3 (:), desw (:) - - logical :: tables_are_initialized = .false. - - ! logical :: master - ! integer :: id_rh, id_vtr, id_vts, id_vtg, id_vti, id_rain, id_snow, id_graupel, & - ! id_ice, id_prec, id_cond, id_var, id_droplets - ! integer :: gfdl_mp_clock ! clock for timing of driver routine - - real, parameter :: dt_fr = 8. ! homogeneous freezing of all cloud water at t_wfr - dt_fr - ! minimum temperature water can exist (moore & molinero nov. 2011, nature) - ! dt_fr can be considered as the error bar - - real, parameter :: p0_min = 100. ! minimum pressure (pascal) for mp to operate - real :: p_min - - ! ----------------------------------------------------------------------- - ! namelist parameters - ! ----------------------------------------------------------------------- - real :: cld_fac = 1.0 ! multiplication factor for cloud fraction real :: cld_min = 0.05 ! minimum cloud fraction real :: tice = 273.16 ! set tice = 165. to trun off ice - phase phys (kessler emulator) + real :: tice_mlt = 273.16 ! set ice melting temperature to 268.0 based on observation (kay et al., 2016, jc) - ! real :: t_min = 178. ! min temp to freeze - dry all water vapor - ! sjl 20181123 - real :: t_min = 170. ! min temp to freeze - dry all water vapor + real :: t_min = 178. ! min temp to freeze - dry all water vapor real :: t_sub = 184. ! min temp for sublimation of cloud ice - - ! relative humidity increment + real :: mp_time = 150. ! maximum micro - physics time step (sec) real :: rh_inc = 0.25 ! rh increment for complete evaporation of cloud water and cloud ice - real :: rh_inr = 0.1 ! rh increment for minimum evaporation of rain (not used---originally for "alternative minimum evaporation") - real :: rh_ins = 0.1 ! rh increment for sublimation of snow (not used) - - ! conversion time scale + real :: rh_inr = 0.25 ! rh increment for minimum evaporation of rain + real :: rh_ins = 0.25 ! rh increment for sublimation of snow real :: tau_r2g = 900. ! rain freezing during fast_sat real :: tau_smlt = 900. ! snow melting @@ -213,18 +214,15 @@ module gfdl_mp_mod real :: tau_l2v = 300. ! cloud water to water vapor (evaporation) real :: tau_g2v = 900. ! grapuel sublimation real :: tau_v2g = 21600. ! grapuel deposition -- make it a slow process - - ! horizontal subgrid variability + real :: tau_revp = 0. ! rain evaporation real :: dw_land = 0.20 ! base value for subgrid deviation / variability over land real :: dw_ocean = 0.10 ! base value for ocean - ! prescribed ccn - real :: ccn_o = 90. ! ccn over ocean (cm^ - 3) real :: ccn_l = 270. ! ccn over land (cm^ - 3) - real :: rthresh = 10.0e-6 ! critical cloud drop radius (micro m) + real :: rthresh = 10.0e-6 ! critical cloud drop radius (micron) ! ----------------------------------------------------------------------- ! wrf / wsm6 scheme: qi_gen = 4.92e-11 * (1.e3 * exp (0.1 * tmp)) ** 1.33 @@ -243,17 +241,18 @@ module gfdl_mp_mod real :: ql_mlt = 2.0e-3 ! max value of cloud water allowed from melted cloud ice real :: qs_mlt = 1.0e-6 ! max cloud water due to snow melt - real :: ql_gen = 1.0e-3 ! max cloud water generation during remapping step if fast_sat_adj = .t. + real :: ql_gen = 1.0e-3 ! max cloud water generation during remapping step if do_sat_adj = .t. real :: qi_gen = 1.82e-6 ! max cloud ice generation during remapping step ! cloud condensate upper bounds: "safety valves" for ql & qi real :: ql0_max = 2.0e-3 ! max cloud water value (auto converted to rain) - real :: qi0_max = 1.0e-4 ! max cloud ice value (by other sources) + real :: qi0_max = 1.0e-4 ! max cloud ice value (by other sources) (not used) + real :: qi0_crt = 1.0e-4 ! cloud ice to snow autoconversion threshold (was 1.e-4) ! qi0_crt if negative, its magnitude is used as the mixing ration threshold; otherwise, used as density - real :: qr0_crt = 1.0e-4 ! rain to snow or graupel / hail threshold (not used) - ! lfo used * mixing ratio * = 1.e-4 (hail in lfo) + real :: qr0_crt = 1.0e-4 ! rain to snow or graupel / hail threshold + ! lin et al. (1983) used * mixing ratio * = 1.e-4 (hail) real :: qs0_crt = 1.0e-3 ! snow to graupel density threshold (0.6e-3 in purdue lin scheme) real :: c_paut = 0.55 ! autoconversion cloud water to rain (use 0.5 to reduce autoconversion) @@ -264,46 +263,64 @@ module gfdl_mp_mod ! decreasing clin to reduce csacw (so as to reduce cloud water --- > snow) - real :: alin = 842.0 ! "a" in lin1983 - real :: clin = 4.8 ! "c" in lin 1983, 4.8 -- > 6. (to ehance ql -- > qs) - - ! fall velocity tuning constants: + real :: alin = 842.0 ! "a" in lin et al. (1983) + real :: clin = 4.8 ! "c" in lin et al. (1983), 4.8 -- > 6. (to ehance ql -- > qs) logical :: const_vi = .false. ! if .t. the constants are specified by v * _fac logical :: const_vs = .false. ! if .t. the constants are specified by v * _fac logical :: const_vg = .false. ! if .t. the constants are specified by v * _fac logical :: const_vr = .false. ! if .t. the constants are specified by v * _fac - ! good values: - - real :: vi_fac = 1. ! if const_vi: 1 / 3 - real :: vs_fac = 1. ! if const_vs: 1. - real :: vg_fac = 1. ! if const_vg: 2. - real :: vr_fac = 1. ! if const_vr: 4. - - ! upper bounds of fall speed (with variable speed option) + real :: vi_fac = 1. ! ifs: if const_vi: 1 / 3 + real :: vs_fac = 1. ! ifs: if const_vs: 1. + real :: vg_fac = 1. ! ifs: if const_vg: 2. + real :: vr_fac = 1. ! ifs: if const_vr: 4. real :: vi_max = 0.5 ! max fall speed for ice real :: vs_max = 5.0 ! max fall speed for snow real :: vg_max = 8.0 ! max fall speed for graupel real :: vr_max = 12. ! max fall speed for rain - ! cloud microphysics switchers + real :: xr_a = 0.25 ! p value in xu and randall, 1996 + real :: xr_b = 100. ! alpha_0 value in xu and randall, 1996 + real :: xr_c = 0.49 ! gamma value in xu and randall, 1996 + + real :: te_err = 1.e-14 ! 64bit: 1.e-14, 32bit: 1.e-7 - ! this should be removed with the inline code - logical :: fast_sat_adj = .false. ! has fast saturation adjustments + logical :: do_sat_adj = .false. ! has fast saturation adjustments logical :: z_slope_liq = .true. ! use linear mono slope for autocconversions logical :: z_slope_ice = .false. ! use linear mono slope for autocconversions logical :: use_ccn = .false. ! must be true when prog_ccn is false logical :: use_ppm = .false. ! use ppm fall scheme logical :: use_ppm_ice = .false. ! use ppm fall scheme for cloud ice logical :: mono_prof = .true. ! perform terminal fall with mono ppm scheme - logical :: mp_print = .false. ! cloud microphysics debugging printout logical :: do_hail = .false. ! use hail parameters instead of graupel - - ! real :: global_area = - 1. - - real :: g2, log_10, tice0, t_wfr + logical :: hd_icefall = .false. ! use heymsfield and donner, 1990's fall speed of cloud ice + logical :: use_xr_cloud = .false. ! use xu and randall, 1996's cloud diagnosis + logical :: use_park_cloud = .false. ! park et al. 2016 + logical :: use_gi_cloud = .false. ! gultepe and isaac (2007, grl) + logical :: use_rhc_cevap = .false. ! cap of rh for cloud water evaporation + logical :: use_rhc_revap = .false. ! cap of rh for rain evaporation + logical :: consv_checker = .false. ! turn on energy and water conservation checker + logical :: do_warm_rain_mp = .false. ! do warm rain cloud microphysics only + ! turn off to save time, turn on only in c48 64bit + + real :: g2, log_10 + + real :: rh_thres = 0.75 + real :: rhc_cevap = 0.85 ! cloud water + real :: rhc_revap = 0.85 ! cloud water + + real :: f_dq_p = 1.0 + real :: f_dq_m = 1.0 + logical :: do_cld_adj = .false. + + integer :: inflag = 1 ! ice nucleation scheme + ! 1: hong et al., 2004 + ! 2: meyers et al., 1992 + ! 3: meyers et al., 1992 + ! 4: cooper, 1986 + ! 5: flecther, 1962 ! ----------------------------------------------------------------------- ! namelist @@ -313,14 +330,33 @@ module gfdl_mp_mod t_min, t_sub, tau_r2g, tau_smlt, tau_g2r, dw_land, dw_ocean, & vi_fac, vr_fac, vs_fac, vg_fac, ql_mlt, do_qa, fix_negative, vi_max, & vs_max, vg_max, vr_max, qs_mlt, qs0_crt, qi_gen, ql0_max, qi0_max, & - qi0_crt, fast_sat_adj, rh_inc, rh_ins, rh_inr, const_vi, & + qi0_crt, do_sat_adj, rh_inc, rh_ins, rh_inr, const_vi, & + const_vs, const_vg, const_vr, use_ccn, rthresh, ccn_l, ccn_o, qc_crt, & + tau_g2v, tau_v2g, sat_adj0, tau_imlt, tau_v2l, tau_l2v, & + tau_i2s, tau_l2r, qi_lim, ql_gen, c_paut, c_psaci, c_pgacs, & + z_slope_liq, z_slope_ice, prog_ccn, c_cracw, alin, clin, tice, & + rad_snow, rad_graupel, rad_rain, cld_fac, cld_min, use_ppm, use_ppm_ice, mono_prof, & + do_sedi_heat, sedi_transport, do_sedi_w, icloud_f, irain_f, & + ntimes, disp_heat, do_hail, use_xr_cloud, xr_a, xr_b, xr_c, tau_revp, tice_mlt, hd_icefall, & + do_cond_timescale, mp_time, consv_checker, te_err, use_park_cloud, & + use_gi_cloud, use_rhc_cevap, use_rhc_revap, inflag, do_warm_rain_mp, & + rh_thres, f_dq_p, f_dq_m, do_cld_adj + + public & + t_min, t_sub, tau_r2g, tau_smlt, tau_g2r, dw_land, dw_ocean, & + vi_fac, vr_fac, vs_fac, vg_fac, ql_mlt, do_qa, fix_negative, vi_max, & + vs_max, vg_max, vr_max, qs_mlt, qs0_crt, qi_gen, ql0_max, qi0_max, & + qi0_crt, do_sat_adj, rh_inc, rh_ins, rh_inr, const_vi, & const_vs, const_vg, const_vr, use_ccn, rthresh, ccn_l, ccn_o, qc_crt, & tau_g2v, tau_v2g, sat_adj0, tau_imlt, tau_v2l, tau_l2v, & tau_i2s, tau_l2r, qi_lim, ql_gen, c_paut, c_psaci, c_pgacs, & z_slope_liq, z_slope_ice, prog_ccn, c_cracw, alin, clin, tice, & rad_snow, rad_graupel, rad_rain, cld_fac, cld_min, use_ppm, use_ppm_ice, mono_prof, & - do_sedi_heat, sedi_transport, do_sedi_w, de_ice, icloud_f, irain_f, mp_print, & - ntimes, disp_heat, do_hail, do_cond_timescale + do_sedi_heat, sedi_transport, do_sedi_w, icloud_f, irain_f, & + ntimes, disp_heat, do_hail, use_xr_cloud, xr_a, xr_b, xr_c, tau_revp, tice_mlt, hd_icefall, & + do_cond_timescale, mp_time, consv_checker, te_err, use_park_cloud, & + use_gi_cloud, use_rhc_cevap, use_rhc_revap, inflag, do_warm_rain_mp, & + rh_thres, f_dq_p, f_dq_m, do_cld_adj contains @@ -328,16 +364,17 @@ module gfdl_mp_mod ! the driver of the gfdl cloud microphysics ! ----------------------------------------------------------------------- -subroutine gfdl_mp_driver (qv, ql, qr, qi, qs, qg, qa, qn, & +subroutine gfdl_mp_driver (qv, ql, qr, qi, qs, qg, qa, qnl, qni, & pt, w, ua, va, dz, delp, gsize, dts, hs, rain, snow, ice, & - graupel, hydrostatic, phys_hydrostatic, is, ie, ks, ke, q_con, cappa, consv_te, & - te, last_step) + graupel, hydrostatic, is, ie, ks, ke, q_con, cappa, consv_te, & + te, condensation, deposition, evaporation, sublimation, last_step, do_inline_mp) implicit none - logical, intent (in) :: hydrostatic, phys_hydrostatic + logical, intent (in) :: hydrostatic logical, intent (in) :: last_step logical, intent (in) :: consv_te + logical, intent (in) :: do_inline_mp integer, intent (in) :: is, ie ! physics window integer, intent (in) :: ks, ke ! vertical dimension @@ -347,22 +384,22 @@ subroutine gfdl_mp_driver (qv, ql, qr, qi, qs, qg, qa, qn, & real, intent (in), dimension (is:ie) :: hs, gsize real, intent (in), dimension (is:ie, ks:ke) :: dz - real, intent (in), dimension (is:ie, ks:ke) :: qn + real, intent (in), dimension (is:ie, ks:ke) :: qnl, qni real, intent (inout), dimension (is:ie, ks:ke) :: delp real, intent (inout), dimension (is:ie, ks:ke) :: qv, ql, qr, qi, qs, qg, qa real, intent (inout), dimension (is:ie, ks:ke) :: pt, ua, va, w - real, intent (inout), dimension (is:ie, ks:ke) :: q_con, cappa + real, intent (inout), dimension (is:, ks:) :: q_con, cappa real, intent (inout), dimension (is:ie) :: rain, snow, ice, graupel + real, intent (inout), dimension (is:ie) :: condensation, deposition + real, intent (inout), dimension (is:ie) :: evaporation, sublimation - real, intent (out), dimension (is:ie, ks:ke) :: te + real, intent (inout), dimension (is:ie, ks:ke) :: te ! logical :: used real, dimension (is:ie) :: w_var - real, dimension (is:ie, ks:ke) :: vt_r, vt_s, vt_g, vt_i, qn2 + real, dimension (is:ie, ks:ke) :: vt_r, vt_s, vt_g, vt_i real, dimension (is:ie, ks:ke) :: m2_rain, m2_sol - ! call mpp_clock_begin (gfdl_mp_clock) - if (last_step) then p_min = p0_min ! final clean - up else @@ -373,10 +410,10 @@ subroutine gfdl_mp_driver (qv, ql, qr, qi, qs, qg, qa, qn, & ! define heat capacity of dry air and water vapor based on hydrostatical property ! ----------------------------------------------------------------------- - if (hydrostatic .or. phys_hydrostatic) then + if (hydrostatic) then c_air = cp_air c_vap = cp_vap - if (hydrostatic) do_sedi_w = .false. + do_sedi_w = .false. else c_air = cv_air c_vap = cv_vap @@ -413,12 +450,10 @@ subroutine gfdl_mp_driver (qv, ql, qr, qi, qs, qg, qa, qn, & ! ----------------------------------------------------------------------- call mpdrv (hydrostatic, ua, va, w, delp, pt, qv, ql, qr, qi, qs, qg, & - qa, qn, dz, is, ie, ks, ke, dts, & + qa, qnl, qni, dz, is, ie, ks, ke, dts, & rain, snow, graupel, ice, m2_rain, m2_sol, gsize, hs, & - w_var, vt_r, vt_s, vt_g, vt_i, qn2, q_con, cappa, consv_te, te, & - last_step) - - ! call mpp_clock_end (gfdl_mp_clock) + w_var, vt_r, vt_s, vt_g, vt_i, q_con, cappa, consv_te, te, & + condensation, deposition, evaporation, sublimation, last_step, do_inline_mp) end subroutine gfdl_mp_driver @@ -438,31 +473,34 @@ end subroutine gfdl_mp_driver ! ----------------------------------------------------------------------- subroutine mpdrv (hydrostatic, ua, va, w, delp, pt, qv, ql, qr, qi, qs, & - qg, qa, qn, dz, is, ie, ks, ke, dt_in, & + qg, qa, qnl, qni, dz, is, ie, ks, ke, dt_in, & rain, snow, graupel, ice, m2_rain, m2_sol, gsize, hs, & - w_var, vt_r, vt_s, vt_g, vt_i, qn2, q_con, cappa, consv_te, te, & - last_step) + w_var, vt_r, vt_s, vt_g, vt_i, q_con, cappa, consv_te, te, & + condensation, deposition, evaporation, sublimation, last_step, do_inline_mp) implicit none logical, intent (in) :: hydrostatic logical, intent (in) :: last_step logical, intent (in) :: consv_te + logical, intent (in) :: do_inline_mp integer, intent (in) :: is, ie, ks, ke real, intent (in) :: dt_in real, intent (in), dimension (is:ie) :: gsize real, intent (in), dimension (is:ie) :: hs real, intent (in), dimension (is:ie, ks:ke) :: dz - real, intent (in), dimension (is:ie, ks:ke) :: qn + real, intent (in), dimension (is:ie, ks:ke) :: qnl, qni real, intent (inout), dimension (is:ie, ks:ke) :: delp real, intent (inout), dimension (is:ie, ks:ke) :: qv, ql, qr, qi, qs, qg, qa real, intent (inout), dimension (is:ie, ks:ke) :: pt, ua, va, w - real, intent (inout), dimension (is:ie, ks:ke) :: q_con, cappa + real, intent (inout), dimension (is:, ks:) :: q_con, cappa real, intent (inout), dimension (is:ie) :: rain, snow, ice, graupel + real, intent (inout), dimension (is:ie) :: condensation, deposition + real, intent (inout), dimension (is:ie) :: evaporation, sublimation real, intent (out), dimension (is:ie) :: w_var - real, intent (out), dimension (is:ie, ks:ke) :: vt_r, vt_s, vt_g, vt_i, qn2 + real, intent (out), dimension (is:ie, ks:ke) :: vt_r, vt_s, vt_g, vt_i real, intent (out), dimension (is:ie, ks:ke) :: m2_rain, m2_sol real, intent (out), dimension (is:ie, ks:ke) :: te ! local: @@ -471,9 +509,15 @@ subroutine mpdrv (hydrostatic, ua, va, w, delp, pt, qv, ql, qr, qi, qs, & real, dimension (ks:ke) :: vtiz, vtsz, vtgz, vtrz real, dimension (ks:ke) :: dp1, dz1 real, dimension (ks:ke) :: den, p1, denfac - real, dimension (ks:ke) :: ccn, c_praut, m1_rain, m1_sol, m1 + real, dimension (ks:ke) :: ccn, cin, c_praut, m1_rain, m1_sol, m1 real, dimension (ks:ke) :: u0, v0, u1, v1, w1 + real (kind = r_grid), dimension (is:ie, ks:ke) :: te_beg, te_end, tw_beg, tw_end + real (kind = r_grid), dimension (is:ie, ks:ke) :: te_beg_0, te_end_0, tw_beg_0, tw_end_0 + real (kind = r_grid), dimension (is:ie) :: te_b_beg, te_b_end, tw_b_beg, tw_b_end, dte, te_loss + real (kind = r_grid), dimension (is:ie) :: te_b_beg_0, te_b_end_0, tw_b_beg_0, tw_b_end_0 + real (kind = r_grid), dimension (ks:ke) :: te1, te2 + real :: cpaut, rh_adj, rh_rain real :: r1, s1, i1, g1, rdt, ccn0 real :: dt_rain @@ -481,17 +525,23 @@ subroutine mpdrv (hydrostatic, ua, va, w, delp, pt, qv, ql, qr, qi, qs, & real (kind = r_grid), dimension (ks:ke) :: dp0, tz, cvm real (kind = r_grid) :: con_r8, c8 real :: convt - real :: dts + real :: dts, q_cond + real :: cond, dep, reevap, sub integer :: i, k, n + + ntimes = max (ntimes, int (dt_in / min (dt_in, mp_time))) dts = dt_in / real (ntimes) dt_rain = dts * 0.5 rdt = one_r8 / dts + dte = 0.0 + ! convert to mm / day convt = 86400. * rdt * rgrav + cond = 0.0 ! ----------------------------------------------------------------------- ! use local variables @@ -500,11 +550,41 @@ subroutine mpdrv (hydrostatic, ua, va, w, delp, pt, qv, ql, qr, qi, qs, & do i = is, ie do k = ks, ke + if (do_inline_mp) then #ifdef MOIST_CAPPA - tz (k) = pt (i, k) / ((1. + zvir * qv (i, k)) * (1. - (ql (i, k) + qr (i, k) + qi (i, k) + qs (i, k) + qg (i, k)))) + tz (k) = pt (i, k) / ((1. + zvir * qv (i, k)) * (1. - (ql (i, k) + qr (i, k) + qi (i, k) + qs (i, k) + qg (i, k)))) #else - tz (k) = pt (i, k) / (1. + zvir * qv (i, k)) + tz (k) = pt (i, k) / (1. + zvir * qv (i, k)) #endif + else + tz (k) = pt (i, k) + endif + enddo + + ! ----------------------------------------------------------------------- + ! total energy checker + ! ----------------------------------------------------------------------- + + if (consv_checker) then + do k = ks, ke + q_liq (k) = ql (i, k) + qr (i, k) + q_sol (k) = qi (i, k) + qs (i, k) + qg (i, k) + cvm (k) = c_air * (1.0 - qv (i, k) - q_liq (k) - q_sol (k)) + & + qv (i, k) * c_vap + q_liq (k) * c_liq + q_sol (k) * c_ice + te_beg_0 (i, k) = cvm (k) * tz (k) + lv00 * c_air * qv (i, k) - li00 * c_air * q_sol (k) + if (hydrostatic) then + te_beg_0 (i, k) = te_beg_0 (i, k) + 0.5 * (ua (i, k) ** 2 + va (i, k) ** 2) + else + te_beg_0 (i, k) = te_beg_0 (i, k) + 0.5 * (ua (i, k) ** 2 + va (i, k) ** 2 + w (i, k) ** 2) + endif + te_beg_0 (i, k) = rgrav * te_beg_0 (i, k) * delp (i, k) * gsize (i) ** 2.0 + tw_beg_0 (i, k) = rgrav * (qv (i, k) + q_liq (k) + q_sol (k)) * delp (i, k) * gsize (i) ** 2.0 + enddo + te_b_beg_0 (i) = (dte (i) - li00 * c_air * (ice (i) + snow (i) + graupel (i)) * dt_in / 86400) * gsize (i) ** 2.0 + tw_b_beg_0 (i) = (rain (i) + ice (i) + snow (i) + graupel (i)) * dt_in / 86400 * gsize (i) ** 2.0 + endif + + do k = ks, ke dp0 (k) = delp (i, k) ! ----------------------------------------------------------------------- ! convert moist mixing ratios to dry mixing ratios @@ -518,10 +598,10 @@ subroutine mpdrv (hydrostatic, ua, va, w, delp, pt, qv, ql, qr, qi, qs, & ! save moist ratios for te: q_liq (k) = qlz (k) + qrz (k) q_sol (k) = qiz (k) + qsz (k) + qgz (k) - q_con (i, k) = q_liq (k) + q_sol (k) + q_cond = q_liq (k) + q_sol (k) qaz (k) = 0. dz1 (k) = dz (i, k) - con_r8 = one_r8 - (qvz (k) + q_con (i, k)) + con_r8 = one_r8 - (qvz (k) + q_cond) ! dp1 is dry mass (no change during mp) dp1 (k) = dp0 (k) * con_r8 con_r8 = one_r8 / con_r8 @@ -542,7 +622,9 @@ subroutine mpdrv (hydrostatic, ua, va, w, delp, pt, qv, ql, qr, qi, qs, & m1 (k) = 0. u0 (k) = ua (i, k) v0 (k) = va (i, k) - w1 (k) = w (i, k) + if (.not. hydrostatic) then + w1 (k) = w (i, k) + endif u1 (k) = u0 (k) v1 (k) = v0 (k) denfac (k) = sqrt (sfcrho / den (k)) @@ -562,8 +644,9 @@ subroutine mpdrv (hydrostatic, ua, va, w, delp, pt, qv, ql, qr, qi, qs, & #ifdef MOIST_CAPPA q_liq (k) = ql (i, k) + qr (i, k) q_sol (k) = qi (i, k) + qs (i, k) + qg (i, k) - q_con (i, k) = q_liq (k) + q_sol (k) - cvm (k) = (one_r8 - (qv (i, k) + q_con (i, k))) * c_air + qv (i, k) * c_vap + q_liq (k) * c_liq + q_sol (k) * c_ice + q_cond = q_liq (k) + q_sol (k) + cvm (k) = (one_r8 - (qv (i, k) + q_cond)) * c_air + & + qv (i, k) * c_vap + q_liq (k) * c_liq + q_sol (k) * c_ice te (i, k) = - cvm (k) * tz (k) * delp (i, k) #else te (i, k) = - c_air * tz (k) * delp (i, k) @@ -572,6 +655,28 @@ subroutine mpdrv (hydrostatic, ua, va, w, delp, pt, qv, ql, qr, qi, qs, & endif endif + ! ----------------------------------------------------------------------- + ! total energy checker + ! ----------------------------------------------------------------------- + + if (consv_checker) then + do k = ks, ke + q_liq (k) = qlz (k) + qrz (k) + q_sol (k) = qiz (k) + qsz (k) + qgz (k) + cvm (k) = c_air + qvz (k) * c_vap + q_liq (k) * c_liq + q_sol (k) * c_ice + te_beg (i, k) = cvm (k) * tz (k) + lv00 * c_air * qvz (k) - li00 * c_air * q_sol (k) + if (hydrostatic) then + te_beg (i, k) = te_beg (i, k) + 0.5 * (u1 (k) ** 2 + v1 (k) ** 2) + else + te_beg (i, k) = te_beg (i, k) + 0.5 * (u1 (k) ** 2 + v1 (k) ** 2 + w1 (k) ** 2) + endif + te_beg (i, k) = rgrav * te_beg (i, k) * dp1 (k) * gsize (i) ** 2.0 + tw_beg (i, k) = rgrav * (qvz (k) + q_liq (k) + q_sol (k)) * dp1 (k) * gsize (i) ** 2.0 + enddo + te_b_beg (i) = (dte (i) - li00 * c_air * (ice (i) + snow (i) + graupel (i)) * dt_in / 86400) * gsize (i) ** 2.0 + tw_b_beg (i) = (rain (i) + ice (i) + snow (i) + graupel (i)) * dt_in / 86400 * gsize (i) ** 2.0 + endif + ! ----------------------------------------------------------------------- ! calculate cloud condensation nuclei (ccn) ! the following is based on klein eq. 15 @@ -581,23 +686,19 @@ subroutine mpdrv (hydrostatic, ua, va, w, delp, pt, qv, ql, qr, qi, qs, & if (prog_ccn) then do k = ks, ke - ! convert # / cc to # / m^3 - ccn (k) = qn (i, k) * 1.e6 + ! convert # / cm^3 to # / m^3 + ccn (k) = max (10.0, qnl (i, k)) * 1.e6 + cin (k) = max (10.0, qni (i, k)) * 1.e6 + ccn (k) = ccn (k) / den (k) c_praut (k) = cpaut * (ccn (k) * rhor) ** (- 1. / 3.) enddo - use_ccn = .false. else - ccn0 = (ccn_l * min (1., abs (hs (i)) / (10. * grav)) + ccn_o * (1. - min (1., abs (hs (i)) / (10. * grav)))) * 1.e6 - if (use_ccn) then - ! ----------------------------------------------------------------------- - ! ccn is formulted as ccn = ccn_surface * (den / den_surface) - ! ----------------------------------------------------------------------- - ccn0 = ccn0 * rdgas * tz (ke) / p1 (ke) - endif - tmp = cpaut * (ccn0 * rhor) ** (- 1. / 3.) + ! convert # / cm^3 to # / m^3 + ccn0 = (ccn_l * min (1., abs (hs (i)) / (10. * grav)) + & + ccn_o * (1. - min (1., abs (hs (i)) / (10. * grav)))) * 1.e6 do k = ks, ke - c_praut (k) = tmp - ccn (k) = ccn0 + ccn (k) = ccn0 / den (k) + c_praut (k) = cpaut * (ccn (k) * rhor) ** (- 1. / 3.) enddo endif @@ -619,14 +720,16 @@ subroutine mpdrv (hydrostatic, ua, va, w, delp, pt, qv, ql, qr, qi, qs, & ! ----------------------------------------------------------------------- rh_adj = 1. - h_var - rh_inc - rh_rain = max (0.6, rh_adj - rh_inr) ! rh_inr = 0.2 + rh_rain = max (0.35, rh_adj - rh_inr) ! rh_inr = 0.25 ! ----------------------------------------------------------------------- ! fix all negative water species ! ----------------------------------------------------------------------- if (fix_negative) & - call neg_adj (ks, ke, tz, dp1, qvz, qlz, qrz, qiz, qsz, qgz) + call neg_adj (ks, ke, tz, dp1, qvz, qlz, qrz, qiz, qsz, qgz, cond) + + condensation (i) = condensation (i) + cond * convt * ntimes m2_rain (i, :) = 0. m2_sol (i, :) = 0. @@ -638,8 +741,9 @@ subroutine mpdrv (hydrostatic, ua, va, w, delp, pt, qv, ql, qr, qi, qs, & ! ----------------------------------------------------------------------- call warm_rain (dt_rain, ks, ke, dp1, dz1, tz, qvz, qlz, qrz, qiz, qsz, & - qgz, den, denfac, ccn, c_praut, rh_rain, vtrz, r1, m1_rain, w1, h_var) + qgz, den, denfac, ccn, c_praut, rh_rain, vtrz, r1, m1_rain, w1, h_var, reevap, dte (i)) + evaporation (i) = evaporation (i) + reevap * convt rain (i) = rain (i) + r1 * convt do k = ks, ke @@ -654,28 +758,53 @@ subroutine mpdrv (hydrostatic, ua, va, w, delp, pt, qv, ql, qr, qi, qs, & call fall_speed (ks, ke, den, qsz, qiz, qgz, qlz, tz, vtsz, vtiz, vtgz) call terminal_fall (dts, ks, ke, tz, qvz, qlz, qrz, qgz, qsz, qiz, & - dz1, dp1, den, vtgz, vtsz, vtiz, r1, g1, s1, i1, m1_sol, w1) + dz1, dp1, den, vtgz, vtsz, vtiz, r1, g1, s1, i1, m1_sol, w1, dte (i)) rain (i) = rain (i) + r1 * convt ! from melted snow & ice that reached the ground snow (i) = snow (i) + s1 * convt graupel (i) = graupel (i) + g1 * convt ice (i) = ice (i) + i1 * convt + ! ----------------------------------------------------------------------- + ! energy loss during sedimentation heating + ! ----------------------------------------------------------------------- + + if (consv_checker) then + do k = ks, ke + te1 (k) = one_r8 + qvz (k) * c1_vap + (qlz (k) + qrz (k)) * c1_liq + (qiz (k) + qsz (k) + qgz (k)) * c1_ice + te1 (k) = rgrav * te1 (k) * c_air * tz (k) * dp1 (k) + enddo + endif + ! ----------------------------------------------------------------------- ! heat transportation during sedimentation ! ----------------------------------------------------------------------- - if (do_sedi_heat) & + if (do_sedi_heat) then call sedi_heat (ks, ke, dp1, m1_sol, dz1, tz, qvz, qlz, qrz, qiz, & - qsz, qgz, c_ice) + qsz, qgz, c_ice) + endif + + ! ----------------------------------------------------------------------- + ! energy loss during sedimentation heating + ! ----------------------------------------------------------------------- + + if (consv_checker) then + do k = ks, ke + te2 (k) = one_r8 + qvz (k) * c1_vap + (qlz (k) + qrz (k)) * c1_liq + (qiz (k) + qsz (k) + qgz (k)) * c1_ice + te2 (k) = rgrav * te2 (k) * c_air * tz (k) * dp1 (k) + enddo + dte (i) = dte (i) + sum (te1) - sum (te2) + endif ! ----------------------------------------------------------------------- ! time - split warm rain processes: 2nd pass ! ----------------------------------------------------------------------- call warm_rain (dt_rain, ks, ke, dp1, dz1, tz, qvz, qlz, qrz, qiz, qsz, & - qgz, den, denfac, ccn, c_praut, rh_rain, vtrz, r1, m1_rain, w1, h_var) + qgz, den, denfac, ccn, c_praut, rh_rain, vtrz, r1, m1_rain, w1, h_var, reevap, dte (i)) + evaporation (i) = evaporation (i) + reevap * convt rain (i) = rain (i) + r1 * convt do k = ks, ke @@ -688,8 +817,14 @@ subroutine mpdrv (hydrostatic, ua, va, w, delp, pt, qv, ql, qr, qi, qs, & ! ice - phase microphysics ! ----------------------------------------------------------------------- - call icloud (ks, ke, tz, p1, qvz, qlz, qrz, qiz, qsz, qgz, dp1, den, & - denfac, vtsz, vtgz, vtrz, qaz, rh_adj, rh_rain, dts, h_var, last_step) + call icloud (ks, ke, tz, p1, qvz, qlz, qrz, qiz, qsz, qgz, dp1, den, ccn, & + cin, denfac, vtsz, vtgz, vtrz, qaz, rh_adj, rh_rain, dts, h_var, gsize (i), & + cond, dep, reevap, sub, last_step) + + condensation (i) = condensation (i) + cond * convt + deposition (i) = deposition (i) + dep * convt + evaporation (i) = evaporation (i) + reevap * convt + sublimation (i) = sublimation (i) + sub * convt enddo @@ -726,9 +861,9 @@ subroutine mpdrv (hydrostatic, ua, va, w, delp, pt, qv, ql, qr, qi, qs, & do k = ks, ke #ifdef MOIST_CAPPA c8 = c_air + qvz (k) * c_vap + (qrz (k) + qlz (k)) * c_liq + (qiz (k) + qsz (k) + qgz (k)) * c_ice - tz (k) = tz (k) + 0.5 * (w (i, k) ** 2 - w1 (k) * w1 (k)) / c8 + tz (k) = tz (k) + 0.5 * (w (i, k) ** 2 - w1 (k) ** 2) / c8 #else - tz (k) = tz (k) + 0.5 * (w (i, k) ** 2 - w1 (k) * w1 (k)) / c_air + tz (k) = tz (k) + 0.5 * (w (i, k) ** 2 - w1 (k) ** 2) / c_air #endif enddo endif @@ -738,6 +873,30 @@ subroutine mpdrv (hydrostatic, ua, va, w, delp, pt, qv, ql, qr, qi, qs, & enddo endif + ! ----------------------------------------------------------------------- + ! total energy checker + ! ----------------------------------------------------------------------- + + if (consv_checker) then + do k = ks, ke + q_liq (k) = qlz (k) + qrz (k) + q_sol (k) = qiz (k) + qsz (k) + qgz (k) + cvm (k) = c_air + qvz (k) * c_vap + q_liq (k) * c_liq + q_sol (k) * c_ice + te_end (i, k) = cvm (k) * tz (k) + lv00 * c_air * qvz (k) - li00 * c_air * q_sol (k) + if (hydrostatic) then + te_end (i, k) = te_end (i, k) + 0.5 * (u1 (k) ** 2 + v1 (k) ** 2) + else + te_end (i, k) = te_end (i, k) + 0.5 * (u1 (k) ** 2 + v1 (k) ** 2 + w1 (k) ** 2) + endif + te_end (i, k) = rgrav * te_end (i, k) * dp1 (k) * gsize (i) ** 2.0 + tw_end (i, k) = rgrav * (qvz (k) + q_liq (k) + q_sol (k)) * dp1 (k) * gsize (i) ** 2.0 + enddo + te_b_end (i) = (dte (i) - li00 * c_air * (ice (i) + snow (i) + graupel (i)) * dt_in / 86400) * gsize (i) ** 2.0 + tw_b_end (i) = (rain (i) + ice (i) + snow (i) + graupel (i)) * dt_in / 86400 * gsize (i) ** 2.0 + ! total energy loss due to sedimentation and its heating + te_loss (i) = dte (i) * gsize (i) ** 2.0 + endif + ! ----------------------------------------------------------------------- ! update moist air mass (actually hydrostatic pressure) ! convert to dry mixing ratios @@ -764,17 +923,43 @@ subroutine mpdrv (hydrostatic, ua, va, w, delp, pt, qv, ql, qr, qi, qs, & qg (i, k) = qgz (k) q_liq (k) = qlz (k) + qrz (k) q_sol (k) = qiz (k) + qsz (k) + qgz (k) - q_con (i, k) = q_liq (k) + q_sol (k) - cvm (k) = (one_r8 - (qvz (k) + q_con (i, k))) * c_air + qvz (k) * c_vap + q_liq (k) * c_liq + q_sol (k) * c_ice + q_cond = q_liq (k) + q_sol (k) + cvm (k) = (one_r8 - (qvz (k) + q_cond)) * c_air + qvz (k) * c_vap + q_liq (k) * c_liq + q_sol (k) * c_ice +#ifdef MOIST_CAPPA + q_con (i, k) = q_cond tmp = rdgas * (1. + zvir * qvz (k)) cappa (i, k) = tmp / (tmp + cvm (k)) +#endif + if (do_inline_mp) then #ifdef MOIST_CAPPA - pt (i, k) = tz (k) * (1. + zvir * qvz (k)) * (1. - q_con (i, k)) + pt (i, k) = tz (k) * (1. + zvir * qvz (k)) * (1. - q_cond) #else - pt (i, k) = tz (k) * (1. + zvir * qvz (k)) + pt (i, k) = tz (k) * (1. + zvir * qvz (k)) #endif + else + pt (i, k) = pt (i, k) + (tz (k) - pt (i, k)) * cvm (k) / cp_air + endif enddo + ! ----------------------------------------------------------------------- + ! total energy checker + ! ----------------------------------------------------------------------- + + if (consv_checker) then + do k = ks, ke + q_liq (k) = ql (i, k) + qr (i, k) + q_sol (k) = qi (i, k) + qs (i, k) + qg (i, k) + cvm (k) = c_air * (1.0 - qv (i, k) - q_liq (k) - q_sol (k)) + & + qv (i, k) * c_vap + q_liq (k) * c_liq + q_sol (k) * c_ice + te_end_0 (i, k) = cvm (k) * tz (k) + lv00 * c_air * qv (i, k) - li00 * c_air * q_sol (k) + te_end_0 (i, k) = te_end_0 (i, k) + 0.5 * (ua (i, k) ** 2 + va (i, k) ** 2 + w (i, k) ** 2) + te_end_0 (i, k) = rgrav * te_end_0 (i, k) * delp (i, k) * gsize (i) ** 2.0 + tw_end_0 (i, k) = rgrav * (qv (i, k) + q_liq (k) + q_sol (k)) * delp (i, k) * gsize (i) ** 2.0 + enddo + te_b_end_0 (i) = (dte (i) - li00 * c_air * (ice (i) + snow (i) + graupel (i)) * dt_in / 86400) * gsize (i) ** 2.0 + tw_b_end_0 (i) = (rain (i) + ice (i) + snow (i) + graupel (i)) * dt_in / 86400 * gsize (i) ** 2.0 + endif + ! ----------------------------------------------------------------------- ! fix energy conservation ! ----------------------------------------------------------------------- @@ -805,6 +990,24 @@ subroutine mpdrv (hydrostatic, ua, va, w, delp, pt, qv, ql, qr, qi, qs, & enddo + ! ----------------------------------------------------------------------- + ! total energy checker + ! ----------------------------------------------------------------------- + + if (consv_checker) then + if (abs (sum (te_end) + sum (te_b_end) - sum (te_beg) - sum (te_b_beg)) / (sum (te_beg) + sum (te_b_beg)) .gt. te_err) then + print *, "gfdl_mp te: ", sum (te_beg) / sum (gsize ** 2) + sum (te_b_beg) / sum (gsize ** 2), & + sum (te_end) / sum (gsize ** 2) + sum (te_b_end) / sum (gsize ** 2), & + (sum (te_end) + sum (te_b_end) - sum (te_beg) - sum (te_b_beg)) / (sum (te_beg) + sum (te_b_beg)) + endif + if (abs (sum (tw_end) + sum (tw_b_end) - sum (tw_beg) - sum (tw_b_beg)) / (sum (tw_beg) + sum (tw_b_beg)) .gt. te_err) then + print *, "gfdl_mp tw: ", sum (tw_beg) / sum (gsize ** 2) + sum (tw_b_beg) / sum (gsize ** 2), & + sum (tw_end) / sum (gsize ** 2) + sum (tw_b_end) / sum (gsize ** 2), & + (sum (tw_end) + sum (tw_b_end) - sum (tw_beg) - sum (tw_b_beg)) / (sum (tw_beg) + sum (tw_b_beg)) + endif + ! print *, "gfdl_mp te loss (%) : ", sum (te_loss) / (sum (te_beg) + sum (te_b_beg)) * 100.0 + endif + end subroutine mpdrv ! ----------------------------------------------------------------------- @@ -847,7 +1050,7 @@ end subroutine sedi_heat ! ----------------------------------------------------------------------- subroutine warm_rain (dt, ks, ke, dp, dz, tz, qv, ql, qr, qi, qs, qg, & - den, denfac, ccn, c_praut, rh_rain, vtr, r1, m1_rain, w1, h_var) + den, denfac, ccn, c_praut, rh_rain, vtr, r1, m1_rain, w1, h_var, reevap, dte) implicit none @@ -859,7 +1062,9 @@ subroutine warm_rain (dt, ks, ke, dp, dz, tz, qv, ql, qr, qi, qs, qg, & real (kind = r_grid), intent (inout), dimension (ks:ke) :: tz real, intent (inout), dimension (ks:ke) :: vtr, qv, ql, qr, qi, qs, qg, m1_rain, w1 + real (kind = r_grid), intent (inout) :: dte real, intent (out) :: r1 + real, intent (out) :: reevap real, parameter :: so3 = 7. / 3. ! fall velocity constants: real, parameter :: vconr = 2503.23638966667 @@ -867,8 +1072,9 @@ subroutine warm_rain (dt, ks, ke, dp, dz, tz, qv, ql, qr, qi, qs, qg, & real, parameter :: thr = 1.e-8 real, dimension (ks:ke) :: dl, dm + real (kind = r_grid), dimension (ks:ke) :: te1, te2 real, dimension (ks:ke + 1) :: ze, zt - real :: sink, dq, qc0, qc + real :: sink, dq, qc real :: qden real :: zs = 0. real :: dt5 @@ -886,6 +1092,8 @@ subroutine warm_rain (dt, ks, ke, dp, dz, tz, qv, ql, qr, qi, qs, qg, & call check_column (ks, ke, qr, no_fall) + reevap = 0 + if (no_fall) then vtr (:) = vf_min r1 = 0. @@ -919,7 +1127,7 @@ subroutine warm_rain (dt, ks, ke, dp, dz, tz, qv, ql, qr, qi, qs, qg, & ! evaporation and accretion of rain for the first 1 / 2 time step ! ----------------------------------------------------------------------- - call revap_racc (ks, ke, dt5, tz, qv, ql, qr, qi, qs, qg, den, denfac, rh_rain, h_var) + call revap_racc (ks, ke, dt5, tz, qv, ql, qr, qi, qs, qg, den, denfac, rh_rain, h_var, dp, reevap) if (do_sedi_w) then do k = ks, ke @@ -927,6 +1135,17 @@ subroutine warm_rain (dt, ks, ke, dp, dz, tz, qv, ql, qr, qi, qs, qg, & enddo endif + ! ----------------------------------------------------------------------- + ! energy loss during sedimentation + ! ----------------------------------------------------------------------- + + if (consv_checker) then + do k = ks, ke + te1 (k) = one_r8 + qv (k) * c1_vap + (ql (k) + qr (k)) * c1_liq + (qi (k) + qs (k) + qg (k)) * c1_ice + te1 (k) = rgrav * te1 (k) * c_air * tz (k) * dp (k) + enddo + endif + ! ----------------------------------------------------------------------- ! mass flux induced by falling rain ! ----------------------------------------------------------------------- @@ -946,6 +1165,18 @@ subroutine warm_rain (dt, ks, ke, dp, dz, tz, qv, ql, qr, qi, qs, qg, & call implicit_fall (dt, ks, ke, ze, vtr, dp, qr, r1, m1_rain) endif + ! ----------------------------------------------------------------------- + ! energy loss during sedimentation + ! ----------------------------------------------------------------------- + + if (consv_checker) then + do k = ks, ke + te2 (k) = one_r8 + qv (k) * c1_vap + (ql (k) + qr (k)) * c1_liq + (qi (k) + qs (k) + qg (k)) * c1_ice + te2 (k) = rgrav * te2 (k) * c_air * tz (k) * dp (k) + enddo + dte = dte + sum (te1) - sum (te2) + endif + ! ----------------------------------------------------------------------- ! vertical velocity transportation during sedimentation ! ----------------------------------------------------------------------- @@ -959,18 +1190,43 @@ subroutine warm_rain (dt, ks, ke, dp, dz, tz, qv, ql, qr, qi, qs, qg, & enddo endif + ! ----------------------------------------------------------------------- + ! energy loss during sedimentation heating + ! ----------------------------------------------------------------------- + + if (consv_checker) then + do k = ks, ke + te1 (k) = one_r8 + qv (k) * c1_vap + (ql (k) + qr (k)) * c1_liq + (qi (k) + qs (k) + qg (k)) * c1_ice + te1 (k) = rgrav * te1 (k) * c_air * tz (k) * dp (k) + enddo + endif + ! ----------------------------------------------------------------------- ! heat exchanges during sedimentation ! ----------------------------------------------------------------------- - if (do_sedi_heat) & + if (do_sedi_heat) then call sedi_heat (ks, ke, dp, m1_rain, dz, tz, qv, ql, qr, qi, qs, qg, c_liq) + endif + + ! ----------------------------------------------------------------------- + ! energy loss during sedimentation heating + ! ----------------------------------------------------------------------- + + if (consv_checker) then + do k = ks, ke + te2 (k) = one_r8 + qv (k) * c1_vap + (ql (k) + qr (k)) * c1_liq + (qi (k) + qs (k) + qg (k)) * c1_ice + te2 (k) = rgrav * te2 (k) * c_air * tz (k) * dp (k) + enddo + dte = dte + sum (te1) - sum (te2) + endif + ! ----------------------------------------------------------------------- ! evaporation and accretion of rain for the remaing 1 / 2 time step ! ----------------------------------------------------------------------- - call revap_racc (ks, ke, dt5, tz, qv, ql, qr, qi, qs, qg, den, denfac, rh_rain, h_var) + call revap_racc (ks, ke, dt5, tz, qv, ql, qr, qi, qs, qg, den, denfac, rh_rain, h_var, dp, reevap) endif @@ -987,16 +1243,8 @@ subroutine warm_rain (dt, ks, ke, dp, dz, tz, qv, ql, qr, qi, qs, qg, & ! ----------------------------------------------------------------------- do k = ks, ke - qc0 = fac_rc * ccn (k) + qc = fac_rc * ccn (k) if (tz (k) > t_wfr) then - if (use_ccn) then - ! ----------------------------------------------------------------------- - ! ccn is formulted as ccn = ccn_surface * (den / den_surface) - ! ----------------------------------------------------------------------- - qc = qc0 - else - qc = qc0 / den (k) - endif dq = ql (k) - qc if (dq > 0.) then sink = min (dq, dt * c_praut (k) * den (k) * exp (so3 * log (ql (k)))) @@ -1015,20 +1263,12 @@ subroutine warm_rain (dt, ks, ke, dp, dz, tz, qv, ql, qr, qi, qs, qg, & call linear_prof (ke - ks + 1, ql (ks), dl (ks), z_slope_liq, h_var) do k = ks, ke - qc0 = fac_rc * ccn (k) + qc = fac_rc * ccn (k) if (tz (k) > t_wfr + dt_fr) then dl (k) = min (max (1.e-6, dl (k)), 0.5 * ql (k)) ! -------------------------------------------------------------------- ! as in klein's gfdl am2 stratiform scheme (with subgrid variations) ! -------------------------------------------------------------------- - if (use_ccn) then - ! -------------------------------------------------------------------- - ! ccn is formulted as ccn = ccn_surface * (den / den_surface) - ! -------------------------------------------------------------------- - qc = qc0 - else - qc = qc0 / den (k) - endif dq = 0.5 * (ql (k) + dl (k) - qc) ! -------------------------------------------------------------------- ! dq = dl if qc == q_minus = ql - dl @@ -1052,24 +1292,32 @@ end subroutine warm_rain ! evaporation of rain ! ----------------------------------------------------------------------- -subroutine revap_racc (ks, ke, dt, tz, qv, ql, qr, qi, qs, qg, den, denfac, rh_rain, h_var) +subroutine revap_racc (ks, ke, dt, tz, qv, ql, qr, qi, qs, qg, den, denfac, rh_rain, h_var, dp, reevap) implicit none integer, intent (in) :: ks, ke real, intent (in) :: dt ! time step (s) real, intent (in) :: rh_rain, h_var - real, intent (in), dimension (ks:ke) :: den, denfac + real, intent (in), dimension (ks:ke) :: den, denfac, dp real (kind = r_grid), intent (inout), dimension (ks:ke) :: tz real, intent (inout), dimension (ks:ke) :: qv, qr, ql, qi, qs, qg + real, intent (out) :: reevap ! local: real (kind = r_grid), dimension (ks:ke) :: cvm real, dimension (ks:ke) :: q_liq, q_sol, lcpk real :: dqv, qsat, dqsdt, evap, t2, qden, q_plus, q_minus, sink real :: qpz, dq, dqh, tin + real :: fac_revp, rh_tem integer :: k + if (tau_revp .gt. 1.e-6) then + fac_revp = 1. - exp (- dt / tau_revp) + else + fac_revp = 1. + endif + do k = ks, ke if (tz (k) > t_wfr .and. qr (k) > qrmin) then @@ -1084,7 +1332,7 @@ subroutine revap_racc (ks, ke, dt, tz, qv, ql, qr, qi, qs, qg, den, denfac, rh_r cvm (k) = one_r8 + qv (k) * c1_vap + q_liq (k) * c1_liq + q_sol (k) * c1_ice lcpk (k) = (lv00 + d1_vap * tz (k)) / cvm (k) tin = (tz (k) * cvm (k) - lv00 * ql (k)) / (1. + (qv (k) + ql (k)) * c1_vap + qr (k) * c1_liq + q_sol (k) * c1_ice) - ! + qpz = qv (k) + ql (k) qsat = wqs2 (tin, den (k), dqsdt) dqh = max (ql (k), h_var * max (qpz, qcmin)) @@ -1102,7 +1350,9 @@ subroutine revap_racc (ks, ke, dt, tz, qv, ql, qr, qi, qs, qg, den, denfac, rh_r ! rain evaporation ! ----------------------------------------------------------------------- - if (dqv > 0. .and. qsat > q_minus) then + rh_tem = qpz / iqs1 (tin, den (k)) + + if (dqv > qvmin .and. qsat > q_minus) then if (qsat > q_plus) then dq = qsat - qpz else @@ -1114,14 +1364,24 @@ subroutine revap_racc (ks, ke, dt, tz, qv, ql, qr, qi, qs, qg, den, denfac, rh_r endif qden = qr (k) * den (k) t2 = tin * tin - evap = crevp (1) * t2 * dq * (crevp (2) * sqrt (qden) + crevp (3) * & - exp (0.725 * log (qden))) / (crevp (4) * t2 + crevp (5) * qsat * den (k)) - evap = min (qr (k), dt * evap, dqv / (1. + lcpk (k) * dqsdt)) + if (use_rhc_revap) then + evap = 0.0 + if (rh_tem < rhc_revap) then + evap = crevp (1) * t2 * dq * (crevp (2) * sqrt (qden) + crevp (3) * & + exp (0.725 * log (qden)) * sqrt (denfac (k))) / (crevp (4) * t2 + crevp (5) * qsat * den (k)) + evap = min (qr (k), dt * fac_revp * evap, dqv / (1. + lcpk (k) * dqsdt)) + endif + else + evap = crevp (1) * t2 * dq * (crevp (2) * sqrt (qden) + crevp (3) * & + exp (0.725 * log (qden))) / (crevp (4) * t2 + crevp (5) * qsat * den (k)) + evap = min (qr (k), dt * fac_revp * evap, dqv / (1. + lcpk (k) * dqsdt)) + endif + reevap = reevap + evap * dp (k) + ! ----------------------------------------------------------------------- ! alternative minimum evap in dry environmental air - ! sjl 20180831: - sink = min (qr (k), dim (rh_rain * qsat, qv (k)) / (1. + lcpk (k) * dqsdt)) - evap = max (evap, sink) + ! sink = min (qr (k), dim (rh_rain * qsat, qv (k)) / (1. + lcpk (k) * dqsdt)) + ! evap = max (evap, sink) ! ----------------------------------------------------------------------- qr (k) = qr (k) - evap qv (k) = qv (k) + evap @@ -1134,7 +1394,7 @@ subroutine revap_racc (ks, ke, dt, tz, qv, ql, qr, qi, qs, qg, den, denfac, rh_r ! ----------------------------------------------------------------------- ! if (qr (k) > qrmin .and. ql (k) > 1.e-7 .and. qsat < q_plus) then - if (qr (k) > 1.e-6 .and. ql (k) > 2.e-6 .and. qsat < q_minus) then + if (qr (k) > qrmin .and. ql (k) > 1.e-6 .and. qsat < q_minus) then sink = dt * denfac (k) * cracw * exp (0.95 * log (qr (k) * den (k))) sink = sink / (1. + sink) * ql (k) ql (k) = ql (k) - sink @@ -1209,19 +1469,22 @@ end subroutine linear_prof ! author: shian - jiann lin, gfdl ! ======================================================================= -subroutine icloud (ks, ke, tzk, p1, qvk, qlk, qrk, qik, qsk, qgk, dp1, & - den, denfac, vts, vtg, vtr, qak, rh_adj, rh_rain, dts, h_var, last_step) +subroutine icloud (ks, ke, tzk, p1, qvk, qlk, qrk, qik, qsk, qgk, dp1, den, & + ccn, cin, denfac, vts, vtg, vtr, qak, rh_adj, rh_rain, dts, h_var, & + gsize, cond, dep, reevap, sub, last_step) implicit none logical, intent (in) :: last_step integer, intent (in) :: ks, ke - real, intent (in), dimension (ks:ke) :: p1, dp1, den, denfac, vts, vtg, vtr + real, intent (in), dimension (ks:ke) :: p1, dp1, den, denfac, vts, vtg, vtr, ccn real (kind = r_grid), intent (inout), dimension (ks:ke) :: tzk real, intent (inout), dimension (ks:ke) :: qvk, qlk, qrk, qik, qsk, qgk, qak - real, intent (in) :: rh_adj, rh_rain, dts, h_var + real, intent (inout), dimension (ks:ke) :: cin + real, intent (in) :: rh_adj, rh_rain, dts, h_var, gsize + real, intent (out) :: cond, dep, reevap, sub ! local: - real, dimension (ks:ke) :: icpk, di + real, dimension (ks:ke) :: icpk, di, qim real, dimension (ks:ke) :: q_liq, q_sol real (kind = r_grid), dimension (ks:ke) :: cvm, te8 real (kind = r_grid) :: tz @@ -1229,7 +1492,7 @@ subroutine icloud (ks, ke, tzk, p1, qvk, qlk, qrk, qik, qsk, qgk, dp1, & real :: qv, ql, qr, qi, qs, qg, melt real :: pracs, psacw, pgacw, psacr, pgacr, pgaci, praci, psaci real :: pgmlt, psmlt, pgfr, psaut - real :: tc, dqs0, qden, qim, qsm + real :: tc, dqs0, qden, qsm real :: dt5, factor, sink, qi_crt real :: tmp, qsw, qsi, dqsdt, dq real :: dtmp, qc, q_plus, q_minus @@ -1260,415 +1523,406 @@ subroutine icloud (ks, ke, tzk, p1, qvk, qlk, qrk, qik, qsk, qgk, dp1, & enddo ! ----------------------------------------------------------------------- - ! sources of cloud ice: pihom, cold rain, and the sat_adj - ! (initiation plus deposition) - ! sources of snow: cold rain, auto conversion + accretion (from cloud ice) - ! sat_adj (deposition; requires pre - existing snow) ; initial snow comes from auto conversion + ! similar to lfo 1983: eq. 21 solved implicitly + ! threshold from wsm6 scheme, hong et al 2004, eq (13) : qi0_crt ~0.8e-4 ! ----------------------------------------------------------------------- do k = ks, ke - if (tzk (k) > tice .and. qik (k) > qcmin) then - - ! ----------------------------------------------------------------------- - ! pimlt: instant melting of cloud ice - ! ----------------------------------------------------------------------- - - melt = min (qik (k), fac_imlt * (tzk (k) - tice) / icpk (k)) - tmp = min (melt, dim (ql_mlt, qlk (k))) ! max ql amount - qlk (k) = qlk (k) + tmp - qrk (k) = qrk (k) + melt - tmp - qik (k) = qik (k) - melt - q_liq (k) = q_liq (k) + melt - q_sol (k) = q_sol (k) - melt - elseif (tzk (k) < t_wfr .and. qlk (k) > qcmin) then - - ! ----------------------------------------------------------------------- - ! pihom: homogeneous freezing of cloud water into cloud ice - ! ----------------------------------------------------------------------- - - dtmp = t_wfr - tzk (k) - factor = min (1., dtmp / dt_fr) - sink = min (qlk (k) * factor, dtmp / icpk (k)) - qi_crt = qi_gen * min (qi_lim, 0.1 * (tice - tzk (k))) / den (k) - tmp = min (sink, dim (qi_crt, qik (k))) - qlk (k) = qlk (k) - sink - qsk (k) = qsk (k) + sink - tmp - qik (k) = qik (k) + tmp - q_liq (k) = q_liq (k) - sink - q_sol (k) = q_sol (k) + sink + if (qi0_crt < 0.) then + qim (k) = - qi0_crt + else + qim (k) = qi0_crt / den (k) endif enddo - ! ----------------------------------------------------------------------- - ! vertical subgrid variability - ! ----------------------------------------------------------------------- - - call linear_prof (ke - ks + 1, qik (ks), di (ks), z_slope_ice, h_var) - - ! ----------------------------------------------------------------------- - ! update capacity heat and latend heat coefficient - ! ----------------------------------------------------------------------- - - do k = ks, ke - cvm (k) = one_r8 + qvk (k) * c1_vap + q_liq (k) * c1_liq + q_sol (k) * c1_ice - tzk (k) = (te8 (k) - lv00 * qvk (k) + li00 * q_sol (k)) / cvm (k) - icpk (k) = (li00 + d1_ice * tzk (k)) / cvm (k) - enddo - - do k = ks, ke + if (.not. do_warm_rain_mp) then ! ----------------------------------------------------------------------- - ! do nothing above p_min + ! sources of cloud ice: pihom, cold rain, and the sat_adj + ! (initiation plus deposition) + ! sources of snow: cold rain, auto conversion + accretion (from cloud ice) + ! sat_adj (deposition; requires pre - existing snow) ; initial snow comes from auto conversion ! ----------------------------------------------------------------------- - if (p1 (k) < p_min) cycle - - tz = tzk (k) - qv = qvk (k) - ql = qlk (k) - qi = qik (k) - qr = qrk (k) - qs = qsk (k) - qg = qgk (k) - - pgacr = 0. - pgacw = 0. - tc = tz - tice - - if (tc .ge. 0.) then - - ! ----------------------------------------------------------------------- - ! melting of snow - ! ----------------------------------------------------------------------- - - dqs0 = ces0 / p1 (k) - qv ! not sure if this is correct; check again - - if (qs > qcmin) then + do k = ks, ke + if (tzk (k) > tice_mlt .and. qik (k) > qcmin) then ! ----------------------------------------------------------------------- - ! psacw: accretion of cloud water by snow - ! only rate is used (for snow melt) since tc > 0. + ! pimlt: instant melting of cloud ice ! ----------------------------------------------------------------------- - if (ql > qrmin) then - factor = denfac (k) * csacw * exp (0.8125 * log (qs * den (k))) - psacw = factor / (1. + dts * factor) * ql ! rate - else - psacw = 0. - endif + melt = min (qik (k), fac_imlt * (tzk (k) - tice_mlt) / icpk (k)) + tmp = min (melt, dim (ql_mlt, qlk (k))) ! max ql amount + qlk (k) = qlk (k) + tmp + qrk (k) = qrk (k) + melt - tmp + qik (k) = qik (k) - melt + q_liq (k) = q_liq (k) + melt + q_sol (k) = q_sol (k) - melt + elseif (tzk (k) < t_wfr .and. qlk (k) > qcmin) then ! ----------------------------------------------------------------------- - ! psacr: accretion of rain by melted snow - ! pracs: accretion of snow by rain + ! pihom: homogeneous freezing of cloud water into cloud ice ! ----------------------------------------------------------------------- - if (qr > qrmin) then - psacr = min (acr3d (vts (k), vtr (k), qr, qs, csacr, acco (1, 2), & - den (k)), qr * rdts) - pracs = acr3d (vtr (k), vts (k), qs, qr, cracs, acco (1, 1), den (k)) - else - psacr = 0. - pracs = 0. - endif - - ! ----------------------------------------------------------------------- - ! total snow sink: - ! psmlt: snow melt (due to rain accretion) - ! ----------------------------------------------------------------------- + dtmp = t_wfr - tzk (k) + factor = min (1., dtmp / dt_fr) + sink = min (qlk (k) * factor, dtmp / icpk (k)) + tmp = min (sink, dim (qim (k), qik (k))) + qlk (k) = qlk (k) - sink + qsk (k) = qsk (k) + sink - tmp + qik (k) = qik (k) + tmp + q_liq (k) = q_liq (k) - sink + q_sol (k) = q_sol (k) + sink + endif + enddo - psmlt = max (0., smlt (tc, dqs0, qs * den (k), psacw, psacr, csmlt, & - den (k), denfac (k))) - sink = min (qs, dts * (psmlt + pracs), tc / icpk (k)) - qs = qs - sink + ! ----------------------------------------------------------------------- + ! vertical subgrid variability + ! ----------------------------------------------------------------------- - ! melt all snow if t > 12 c - if (qs > qcmin .and. tz > tice + 12.) then - sink = sink + qs - qs = 0. - endif + call linear_prof (ke - ks + 1, qik (ks), di (ks), z_slope_ice, h_var) - tmp = min (sink, dim (qs_mlt, ql)) ! max ql due to snow melt - ql = ql + tmp - qr = qr + sink - tmp - q_liq (k) = q_liq (k) + sink - q_sol (k) = q_sol (k) - sink + ! ----------------------------------------------------------------------- + ! update capacity heat and latend heat coefficient + ! ----------------------------------------------------------------------- - cvm (k) = one_r8 + qv * c1_vap + q_liq (k) * c1_liq + q_sol (k) * c1_ice - tz = (te8 (k) - lv00 * qv + li00 * q_sol (k)) / cvm (k) - tc = tz - tice - icpk (k) = (li00 + d1_ice * tz) / cvm (k) + do k = ks, ke + cvm (k) = one_r8 + qvk (k) * c1_vap + q_liq (k) * c1_liq + q_sol (k) * c1_ice + tzk (k) = (te8 (k) - lv00 * qvk (k) + li00 * q_sol (k)) / cvm (k) + icpk (k) = (li00 + d1_ice * tzk (k)) / cvm (k) + enddo - endif + do k = ks, ke ! ----------------------------------------------------------------------- - ! update capacity heat and latend heat coefficient + ! do nothing above p_min ! ----------------------------------------------------------------------- + if (p1 (k) < p_min) cycle - ! ----------------------------------------------------------------------- - ! melting of graupel - ! ----------------------------------------------------------------------- + tz = tzk (k) + qv = qvk (k) + ql = qlk (k) + qi = qik (k) + qr = qrk (k) + qs = qsk (k) + qg = qgk (k) - if (qg > qcmin .and. tc > 0.) then - - ! ----------------------------------------------------------------------- - ! pgacr: accretion of rain by graupel - ! ----------------------------------------------------------------------- + pgacr = 0. + pgacw = 0. + tc = tz - tice - if (qr > qrmin) & - pgacr = min (acr3d (vtg (k), vtr (k), qr, qg, cgacr, acco (1, 3), & - den (k)), rdts * qr) + if (tc .ge. 0.) then ! ----------------------------------------------------------------------- - ! pgacw: accretion of cloud water by graupel + ! melting of snow ! ----------------------------------------------------------------------- - qden = qg * den (k) - if (ql > qrmin) then - factor = cgacw * qden / sqrt (den (k) * sqrt (sqrt (qden))) - pgacw = factor / (1. + dts * factor) * ql ! rate - endif + dqs0 = ces0 / p1 (k) - qv ! not sure if this is correct; check again - ! ----------------------------------------------------------------------- - ! pgmlt: graupel melt - ! ----------------------------------------------------------------------- + if (qs > qcmin) then - pgmlt = dts * gmlt (tc, dqs0, qden, pgacw, pgacr, cgmlt, den (k)) - pgmlt = min (max (0., pgmlt), qg, tc / icpk (k)) - qg = qg - pgmlt - qr = qr + pgmlt - q_liq (k) = q_liq (k) + pgmlt - q_sol (k) = q_sol (k) - pgmlt - cvm (k) = one_r8 + qv * c1_vap + q_liq (k) * c1_liq + q_sol (k) * c1_ice - tz = (te8 (k) - lv00 * qv + li00 * q_sol (k)) / cvm (k) - endif + ! ----------------------------------------------------------------------- + ! psacw: accretion of cloud water by snow + ! only rate is used (for snow melt) since tc > 0. + ! ----------------------------------------------------------------------- - else + if (ql > qrmin) then + factor = denfac (k) * csacw * exp (0.8125 * log (qs * den (k))) + psacw = factor / (1. + dts * factor) * ql ! rate + else + psacw = 0. + endif - ! ----------------------------------------------------------------------- - ! cloud ice proc: - ! ----------------------------------------------------------------------- + ! ----------------------------------------------------------------------- + ! psacr: accretion of rain by melted snow + ! pracs: accretion of snow by rain + ! ----------------------------------------------------------------------- - ! ----------------------------------------------------------------------- - ! psaci: accretion of cloud ice by snow - ! ----------------------------------------------------------------------- + if (qr > qrmin) then + psacr = min (acr3d (vts (k), vtr (k), qr, qs, csacr, acco (1, 2), & + den (k)), qr * rdts) + pracs = acr3d (vtr (k), vts (k), qs, qr, cracs, acco (1, 1), den (k)) + else + psacr = 0. + pracs = 0. + endif - if (qi > 1.e-6) then ! cloud ice sink terms - if (qs > 1.e-6) then ! ----------------------------------------------------------------------- - ! sjl added (following lin eq. 23) the temperature dependency - ! to reduce accretion, use esi = exp (0.05 * tc) as in hong et al 2004 + ! total snow sink: + ! psmlt: snow melt (due to rain accretion) ! ----------------------------------------------------------------------- - factor = dts * denfac (k) * csaci * exp (0.05 * tc + 0.8125 * log (qs * den (k))) - psaci = factor / (1. + factor) * qi - else - psaci = 0. + + psmlt = max (0., smlt (tc, dqs0, qs * den (k), psacw, psacr, csmlt, & + den (k), denfac (k))) + sink = min (qs, dts * (psmlt + pracs), tc / icpk (k)) + qs = qs - sink + tmp = min (sink, dim (qs_mlt, ql)) ! max ql due to snow melt + ql = ql + tmp + qr = qr + sink - tmp + q_liq (k) = q_liq (k) + sink + q_sol (k) = q_sol (k) - sink + + cvm (k) = one_r8 + qv * c1_vap + q_liq (k) * c1_liq + q_sol (k) * c1_ice + tz = (te8 (k) - lv00 * qv + li00 * q_sol (k)) / cvm (k) + tc = tz - tice + icpk (k) = (li00 + d1_ice * tz) / cvm (k) + endif ! ----------------------------------------------------------------------- - ! pasut: autoconversion: cloud ice -- > snow + ! melting of graupel ! ----------------------------------------------------------------------- - ! ----------------------------------------------------------------------- - ! similar to lfo 1983: eq. 21 solved implicitly - ! threshold from wsm6 scheme, hong et al 2004, eq (13) : qi0_crt ~0.8e-4 - ! ----------------------------------------------------------------------- + if (qg > qcmin .and. tc > 0.) then - if (qi0_crt < 0.) then - qim = - qi0_crt - else - qim = qi0_crt / den (k) - endif + ! ----------------------------------------------------------------------- + ! pgacr: accretion of rain by graupel + ! ----------------------------------------------------------------------- - ! ----------------------------------------------------------------------- - ! assuming linear subgrid vertical distribution of cloud ice - ! the mismatch computation following lin et al. 1994, mwr - ! ----------------------------------------------------------------------- + if (qr > qrmin) & + pgacr = min (acr3d (vtg (k), vtr (k), qr, qg, cgacr, acco (1, 3), & + den (k)), rdts * qr) - if (const_vi) then - tmp = fac_i2s - else - tmp = fac_i2s * exp (0.025 * tc) - endif + ! ----------------------------------------------------------------------- + ! pgacw: accretion of cloud water by graupel + ! ----------------------------------------------------------------------- - di (k) = max (di (k), qrmin) - q_plus = qi + di (k) - if (q_plus > (qim + qrmin)) then - if (qim > (qi - di (k))) then - dq = (0.25 * (q_plus - qim) ** 2) / di (k) - else - dq = qi - qim + qden = qg * den (k) + if (ql > qrmin) then + factor = cgacw * qden / sqrt (den (k) * sqrt (sqrt (qden))) + pgacw = factor / (1. + dts * factor) * ql ! rate endif - psaut = tmp * dq - else - psaut = 0. + + ! ----------------------------------------------------------------------- + ! pgmlt: graupel melt + ! ----------------------------------------------------------------------- + + pgmlt = dts * gmlt (tc, dqs0, qden, pgacw, pgacr, cgmlt, den (k)) + pgmlt = min (max (0., pgmlt), qg, tc / icpk (k)) + qg = qg - pgmlt + qr = qr + pgmlt + q_liq (k) = q_liq (k) + pgmlt + q_sol (k) = q_sol (k) - pgmlt + cvm (k) = one_r8 + qv * c1_vap + q_liq (k) * c1_liq + q_sol (k) * c1_ice + tz = (te8 (k) - lv00 * qv + li00 * q_sol (k)) / cvm (k) endif + + else + ! ----------------------------------------------------------------------- - ! sink is no greater than 75% of qi + ! cloud ice proc: ! ----------------------------------------------------------------------- - sink = min (0.75 * qi, psaci + psaut) - qi = qi - sink - qs = qs + sink ! ----------------------------------------------------------------------- - ! pgaci: accretion of cloud ice by graupel + ! psaci: accretion of cloud ice by snow ! ----------------------------------------------------------------------- - if (qg > 3.e-6) then + if (qi > 3.e-7) then ! cloud ice sink terms + + if (qs > 1.e-7) then + ! ----------------------------------------------------------------------- + ! sjl added (following lin eq. 23) the temperature dependency + ! to reduce accretion, use esi = exp (0.05 * tc) as in hong et al 2004 + ! ----------------------------------------------------------------------- + factor = dts * denfac (k) * csaci * exp (0.05 * tc + 0.8125 * log (qs * den (k))) + psaci = factor / (1. + factor) * qi + else + psaci = 0. + endif + ! ----------------------------------------------------------------------- - ! factor = dts * cgaci / sqrt (den (k)) * exp (0.05 * tc + 0.875 * log (qg * den (k))) - ! simplified form: remove temp dependency & set the exponent "0.875" -- > 1 + ! assuming linear subgrid vertical distribution of cloud ice + ! the mismatch computation following lin et al. 1994, mwr ! ----------------------------------------------------------------------- - factor = dts * cgaci * sqrt (den (k)) * qg - pgaci = factor / (1. + factor) * qi - qi = qi - pgaci - qg = qg + pgaci - endif - endif + if (const_vi) then + tmp = fac_i2s + else + tmp = fac_i2s * exp (0.025 * tc) + endif - ! ----------------------------------------------------------------------- - ! cold - rain proc: - ! ----------------------------------------------------------------------- + di (k) = max (di (k), qrmin) + q_plus = qi + di (k) + if (q_plus > (qim (k) + qrmin)) then + if (qim (k) > (qi - di (k))) then + dq = (0.25 * (q_plus - qim (k)) ** 2) / di (k) + else + dq = qi - qim (k) + endif + psaut = tmp * dq + else + psaut = 0. + endif + ! ----------------------------------------------------------------------- + ! sink is no greater than 75% of qi + ! ----------------------------------------------------------------------- + sink = min (0.75 * qi, psaci + psaut) + qi = qi - sink + qs = qs + sink - ! ----------------------------------------------------------------------- - ! rain to ice, snow, graupel processes: - ! ----------------------------------------------------------------------- + ! ----------------------------------------------------------------------- + ! pgaci: accretion of cloud ice by graupel + ! ----------------------------------------------------------------------- - tc = tz - tice + if (qg > 1.e-6) then + ! ----------------------------------------------------------------------- + ! factor = dts * cgaci / sqrt (den (k)) * exp (0.05 * tc + 0.875 * log (qg * den (k))) + ! simplified form: remove temp dependency & set the exponent "0.875" -- > 1 + ! ----------------------------------------------------------------------- + factor = dts * cgaci / sqrt (den (k)) * exp (0.875 * log (qg * den (k))) + pgaci = factor / (1. + factor) * qi + qi = qi - pgaci + qg = qg + pgaci + endif - if (qr > 1.e-6 .and. tc < 0.) then + endif ! ----------------------------------------------------------------------- - ! * sink * terms to qr: psacr + pgfr - ! source terms to qs: psacr - ! source terms to qg: pgfr + ! cold - rain proc: ! ----------------------------------------------------------------------- ! ----------------------------------------------------------------------- - ! psacr accretion of rain by snow + ! rain to ice, snow, graupel processes: ! ----------------------------------------------------------------------- - if (qs > 1.e-6) then ! if snow exists - psacr = dts * acr3d (vts (k), vtr (k), qr, qs, csacr, acco (1, 2), den (k)) - else - psacr = 0. - endif + tc = tz - tice - ! ----------------------------------------------------------------------- - ! pgfr: rain freezing -- > graupel - ! ----------------------------------------------------------------------- + if (qr > 1.e-7 .and. tc < 0.) then - pgfr = dts * cgfr (1) / den (k) * (exp (- cgfr (2) * tc) - 1.) * & - exp (1.75 * log (qr * den (k))) + ! ----------------------------------------------------------------------- + ! * sink * terms to qr: psacr + pgfr + ! source terms to qs: psacr + ! source terms to qg: pgfr + ! ----------------------------------------------------------------------- - ! ----------------------------------------------------------------------- - ! total sink to qr - ! ----------------------------------------------------------------------- + ! ----------------------------------------------------------------------- + ! psacr accretion of rain by snow + ! ----------------------------------------------------------------------- - sink = psacr + pgfr - factor = min (sink, qr, - tc / icpk (k)) / max (sink, qrmin) + if (qs > 1.e-7) then ! if snow exists + psacr = dts * acr3d (vts (k), vtr (k), qr, qs, csacr, acco (1, 2), den (k)) + else + psacr = 0. + endif - psacr = factor * psacr - pgfr = factor * pgfr + ! ----------------------------------------------------------------------- + ! pgfr: rain freezing -- > graupel + ! ----------------------------------------------------------------------- - sink = psacr + pgfr - qr = qr - sink - qs = qs + psacr - qg = qg + pgfr - q_liq (k) = q_liq (k) - sink - q_sol (k) = q_sol (k) + sink + pgfr = dts * cgfr (1) / den (k) * (exp (- cgfr (2) * tc) - 1.) * & + exp (1.75 * log (qr * den (k))) - cvm (k) = one_r8 + qv * c1_vap + q_liq (k) * c1_liq + q_sol (k) * c1_ice - tz = (te8 (k) - lv00 * qv + li00 * q_sol (k)) / cvm (k) - icpk (k) = (li00 + d1_ice * tz) / cvm (k) - endif + ! ----------------------------------------------------------------------- + ! total sink to qr + ! ----------------------------------------------------------------------- - ! ----------------------------------------------------------------------- - ! graupel production terms: - ! ----------------------------------------------------------------------- + sink = psacr + pgfr + factor = min (sink, qr, - tc / icpk (k)) / max (sink, qrmin) - if (qs > 3.e-6) then + psacr = factor * psacr + pgfr = factor * pgfr - ! ----------------------------------------------------------------------- - ! accretion: snow -- > graupel - ! ----------------------------------------------------------------------- + sink = psacr + pgfr + qr = qr - sink + qs = qs + psacr + qg = qg + pgfr + q_liq (k) = q_liq (k) - sink + q_sol (k) = q_sol (k) + sink - if (qg > qrmin) then - sink = dts * acr3d (vtg (k), vts (k), qs, qg, cgacs, acco (1, 4), den (k)) - else - sink = 0. + cvm (k) = one_r8 + qv * c1_vap + q_liq (k) * c1_liq + q_sol (k) * c1_ice + tz = (te8 (k) - lv00 * qv + li00 * q_sol (k)) / cvm (k) + icpk (k) = (li00 + d1_ice * tz) / cvm (k) endif ! ----------------------------------------------------------------------- - ! autoconversion snow -- > graupel + ! graupel production terms: ! ----------------------------------------------------------------------- - qsm = qs0_crt / den (k) - if (qs > qsm) then - factor = dts * 1.e-3 * exp (0.09 * (tz - tice)) - sink = sink + factor / (1. + factor) * (qs - qsm) - endif - sink = min (qs, sink) - qs = qs - sink - qg = qg + sink + if (qs > 1.e-7) then - endif ! snow existed + ! ----------------------------------------------------------------------- + ! accretion: snow -- > graupel + ! ----------------------------------------------------------------------- - if (qg > 1.e-6 .and. tz < tice0) then + if (qg > qrmin) then + sink = dts * acr3d (vtg (k), vts (k), qs, qg, cgacs, acco (1, 4), den (k)) + else + sink = 0. + endif - ! ----------------------------------------------------------------------- - ! pgacw: accretion of cloud water by graupel - ! ----------------------------------------------------------------------- + ! ----------------------------------------------------------------------- + ! autoconversion snow -- > graupel + ! ----------------------------------------------------------------------- - if (ql > 1.e-6) then - qden = qg * den (k) - factor = dts * cgacw * qden / sqrt (den (k) * sqrt (sqrt (qden))) - pgacw = factor / (1. + factor) * ql - else - pgacw = 0. - endif + qsm = qs0_crt / den (k) + if (qs > qsm) then + factor = dts * 1.e-3 * exp (0.09 * (tz - tice)) + sink = sink + factor / (1. + factor) * (qs - qsm) + endif + sink = min (qs, sink) + qs = qs - sink + qg = qg + sink - ! ----------------------------------------------------------------------- - ! pgacr: accretion of rain by graupel - ! ----------------------------------------------------------------------- + endif ! snow existed - if (qr > 1.e-6) then - pgacr = min (dts * acr3d (vtg (k), vtr (k), qr, qg, cgacr, acco (1, 3), & - den (k)), qr) - else - pgacr = 0. - endif + if (qg > 1.e-7 .and. tz < tice) then + + ! ----------------------------------------------------------------------- + ! pgacw: accretion of cloud water by graupel + ! ----------------------------------------------------------------------- - sink = pgacr + pgacw - factor = min (sink, dim (tice, tz) / icpk (k)) / max (sink, qrmin) - pgacr = factor * pgacr - pgacw = factor * pgacw + if (ql > 1.e-6) then + qden = qg * den (k) + factor = dts * cgacw * qden / sqrt (den (k) * sqrt (sqrt (qden))) + pgacw = factor / (1. + factor) * ql + else + pgacw = 0. + endif - sink = pgacr + pgacw - qg = qg + sink - qr = qr - pgacr - ql = ql - pgacw + ! ----------------------------------------------------------------------- + ! pgacr: accretion of rain by graupel + ! ----------------------------------------------------------------------- + + if (qr > 1.e-6) then + pgacr = min (dts * acr3d (vtg (k), vtr (k), qr, qg, cgacr, acco (1, 3), & + den (k)), qr) + else + pgacr = 0. + endif + + sink = pgacr + pgacw + factor = min (sink, dim (tice, tz) / icpk (k)) / max (sink, qrmin) + pgacr = factor * pgacr + pgacw = factor * pgacw + + sink = pgacr + pgacw + qg = qg + sink + qr = qr - pgacr + ql = ql - pgacw + + q_liq (k) = q_liq (k) - sink + q_sol (k) = q_sol (k) + sink + tz = (te8 (k) - lv00 * qv + li00 * q_sol (k)) / (one_r8 + qv * c1_vap + q_liq (k) * c1_liq + q_sol (k) * c1_ice) + endif - q_liq (k) = q_liq (k) - sink - q_sol (k) = q_sol (k) + sink - tz = (te8 (k) - lv00 * qv + li00 * q_sol (k)) / (one_r8 + qv * c1_vap + q_liq (k) * c1_liq + q_sol (k) * c1_ice) endif - endif + tzk (k) = tz + qvk (k) = qv + qlk (k) = ql + qik (k) = qi + qrk (k) = qr + qsk (k) = qs + qgk (k) = qg - tzk (k) = tz - qvk (k) = qv - qlk (k) = ql - qik (k) = qi - qrk (k) = qr - qsk (k) = qs - qgk (k) = qg + enddo - enddo + endif - call subgrid_z_proc (ks, ke, p1, den, denfac, dts, rh_adj, tzk, qvk, & - qlk, qrk, qik, qsk, qgk, qak, h_var, rh_rain, te8, last_step) + call subgrid_z_proc (ks, ke, p1, den, denfac, dts, rh_adj, tzk, qvk, qlk, & + qrk, qik, qsk, qgk, qak, dp1, h_var, rh_rain, te8, ccn, cin, gsize, & + cond, dep, reevap, sub, last_step) end subroutine icloud @@ -1676,41 +1930,50 @@ end subroutine icloud ! temperature sentive high vertical resolution processes ! ======================================================================= -subroutine subgrid_z_proc (ks, ke, p1, den, denfac, dts, rh_adj, tz, qv, & - ql, qr, qi, qs, qg, qa, h_var, rh_rain, te8, last_step) +subroutine subgrid_z_proc (ks, ke, p1, den, denfac, dts, rh_adj, tz, qv, ql, qr, & + qi, qs, qg, qa, dp1, h_var, rh_rain, te8, ccn, cin, gsize, cond, dep, reevap, sub, last_step) implicit none integer, intent (in) :: ks, ke - real, intent (in) :: dts, rh_adj, h_var, rh_rain - real, intent (in), dimension (ks:ke) :: p1, den, denfac + real, intent (in) :: dts, rh_adj, h_var, rh_rain, gsize + real, intent (in), dimension (ks:ke) :: p1, den, denfac, ccn, dp1 real (kind = r_grid), intent (in), dimension (ks:ke) :: te8 real (kind = r_grid), intent (inout), dimension (ks:ke) :: tz real, intent (inout), dimension (ks:ke) :: qv, ql, qr, qi, qs, qg, qa + real, intent (inout), dimension (ks:ke) :: cin logical, intent (in) :: last_step + real, intent (out) :: cond, dep, reevap, sub ! local: real, dimension (ks:ke) :: lcpk, icpk, tcpk, tcp3 real, dimension (ks:ke) :: q_liq, q_sol, q_cond real (kind = r_grid), dimension (ks:ke) :: cvm real :: pidep, qi_crt + real :: sigma, gam ! ----------------------------------------------------------------------- ! qstar over water may be accurate only down to - 80 deg c with ~10% uncertainty ! must not be too large to allow psc ! ----------------------------------------------------------------------- - real :: rh, rqi, tin, qsw, qsi, qpz, qstar + real :: rh, rqi, tin, qsw, qsi, qpz, qstar, rh_tem real :: dqsdt, dwsdt, dq, dq0, factor, tmp, liq, ice - real :: q_plus, q_minus - real :: evap, sink, tc, dtmp + real :: q_plus, q_minus, dt_evap, dt_pisub + real :: evap, sink, tc, dtmp, qa10, qa100 real :: pssub, pgsub, tsq, qden real :: fac_l2v, fac_v2l, fac_g2v, fac_v2g integer :: k + if (do_sat_adj) then + dt_evap = 0.5 * dts + else + dt_evap = dts + endif + ! ----------------------------------------------------------------------- ! define conversion scalar / factor ! ----------------------------------------------------------------------- - fac_l2v = 1. - exp (- dts / tau_l2v) - fac_v2l = 1. - exp (- dts / tau_v2l) + fac_l2v = 1. - exp (- dt_evap / tau_l2v) + fac_v2l = 1. - exp (- dt_evap / tau_v2l) fac_g2v = 1. - exp (- dts / tau_g2v) fac_v2g = 1. - exp (- dts / tau_v2g) @@ -1727,40 +1990,53 @@ subroutine subgrid_z_proc (ks, ke, p1, den, denfac, dts, rh_adj, tz, qv, & tcp3 (k) = lcpk (k) + icpk (k) * min (1., dim (tice, tz (k)) / (tice - t_wfr)) enddo + cond = 0 + dep = 0 + reevap = 0 + sub = 0 + do k = ks, ke if (p1 (k) < p_min) cycle - ! ----------------------------------------------------------------------- - ! instant deposit all water vapor to cloud ice when temperature is super low - ! ----------------------------------------------------------------------- + if (.not. do_warm_rain_mp) then - if (tz (k) < t_min) then - sink = dim (qv (k), 1.e-7) - qv (k) = qv (k) - sink - qi (k) = qi (k) + sink - q_sol (k) = q_sol (k) + sink - tz (k) = (te8 (k) - lv00 * qv (k) + li00 * q_sol (k)) / (one_r8 + qv (k) * c1_vap + q_liq (k) * c1_liq + q_sol (k) * c1_ice) - if (do_qa) qa (k) = 1. ! air fully saturated; 100 % cloud cover - cycle - endif + ! ----------------------------------------------------------------------- + ! instant deposit all water vapor to cloud ice when temperature is super low + ! ----------------------------------------------------------------------- - ! ----------------------------------------------------------------------- - ! instant evaporation / sublimation of all clouds if rh < rh_adj -- > cloud free - ! ----------------------------------------------------------------------- - ! rain water is handled in warm - rain process. - qpz = qv (k) + ql (k) + qi (k) + qs (k) - tin = (te8 (k) - lv00 * qpz + li00 * qg (k)) / (one_r8 + qpz * c1_vap + qr (k) * c1_liq + qg (k) * c1_ice) - if (tin > t_sub + 6.) then - rh = qpz / iqs1 (tin, den (k)) - if (rh < rh_adj) then ! qpz / rh_adj < qs - tz (k) = tin - qv (k) = qpz - ql (k) = 0. - qi (k) = 0. - qs (k) = 0. - cycle ! cloud free + if (tz (k) < t_min) then + sink = dim (qv (k), 1.e-7) + dep = dep + sink * dp1 (k) + qv (k) = qv (k) - sink + qi (k) = qi (k) + sink + q_sol (k) = q_sol (k) + sink + tz (k) = (te8 (k) - lv00 * qv (k) + li00 * q_sol (k)) / & + (one_r8 + qv (k) * c1_vap + q_liq (k) * c1_liq + q_sol (k) * c1_ice) + if (do_qa) qa (k) = 1. ! air fully saturated; 100 % cloud cover + cycle + endif + + ! ----------------------------------------------------------------------- + ! instant evaporation / sublimation of all clouds if rh < rh_adj -- > cloud free + ! ----------------------------------------------------------------------- + ! rain water is handled in warm - rain process. + qpz = qv (k) + ql (k) + qi (k) + tin = (te8 (k) - lv00 * qpz + li00 * (qs (k) + qg (k))) / & + (one_r8 + qpz * c1_vap + qr (k) * c1_liq + (qs (k) + qg (k)) * c1_ice) + if (tin > t_sub + 6.) then + rh = qpz / iqs1 (tin, den (k)) + if (rh < rh_adj) then ! qpz / rh_adj < qs + reevap = reevap + ql (k) * dp1 (k) + sub = sub + qi (k) * dp1 (k) + tz (k) = tin + qv (k) = qpz + ql (k) = 0. + qi (k) = 0. + cycle ! cloud free + endif endif + endif ! ----------------------------------------------------------------------- @@ -1768,16 +2044,38 @@ subroutine subgrid_z_proc (ks, ke, p1, den, denfac, dts, rh_adj, tz, qv, & ! ----------------------------------------------------------------------- tin = tz (k) + rh_tem = qpz / iqs1 (tin, den (k)) qsw = wqs2 (tin, den (k), dwsdt) dq0 = qsw - qv (k) - if (dq0 > 0.) then ! evaporation - factor = min (1., fac_l2v * (10. * dq0 / qsw)) ! the rh dependent factor = 1 at 90% - evap = min (ql (k), factor * dq0 / (1. + tcp3 (k) * dwsdt)) - elseif (do_cond_timescale) then - factor = min ( 1., fac_v2l * ( 10. * (-dq0) / qsw )) - evap = - min ( qv (k), factor * (-dq0) / (1. + tcp3 (k) * dwsdt)) - else ! condensate all excess vapor into cloud water - evap = dq0 / (1. + tcp3 (k) * dwsdt) + if (use_rhc_cevap) then + evap = 0. + if (rh_tem .lt. rhc_cevap) then + if (dq0 > 0.) then ! evaporation + factor = min (1., fac_l2v * (10. * dq0 / qsw)) ! the rh dependent factor = 1 at 90% + evap = min (ql (k), factor * dq0 / (1. + tcp3 (k) * dwsdt)) + reevap = reevap + evap * dp1 (k) + elseif (do_cond_timescale) then + factor = min (1., fac_v2l * (10. * (- dq0) / qsw)) + evap = - min (qv (k), factor * (- dq0) / (1. + tcp3 (k) * dwsdt)) + cond = cond - evap * dp1 (k) + else ! condensate all excess vapor into cloud water + evap = dq0 / (1. + tcp3 (k) * dwsdt) + cond = cond - evap * dp1 (k) + endif + endif + else + if (dq0 > 0.) then ! evaporation + factor = min (1., fac_l2v * (10. * dq0 / qsw)) ! the rh dependent factor = 1 at 90% + evap = min (ql (k), factor * dq0 / (1. + tcp3 (k) * dwsdt)) + reevap = reevap + evap * dp1 (k) + elseif (do_cond_timescale) then + factor = min (1., fac_v2l * (10. * (- dq0) / qsw)) + evap = - min (qv (k), factor * (- dq0) / (1. + tcp3 (k) * dwsdt)) + cond = cond - evap * dp1 (k) + else ! condensate all excess vapor into cloud water + evap = dq0 / (1. + tcp3 (k) * dwsdt) + cond = cond - evap * dp1 (k) + endif endif ! sjl on jan 23 2018: reversible evap / condensation: qv (k) = qv (k) + evap @@ -1793,153 +2091,174 @@ subroutine subgrid_z_proc (ks, ke, p1, den, denfac, dts, rh_adj, tz, qv, & icpk (k) = (li00 + d1_ice * tz (k)) / cvm (k) - ! ----------------------------------------------------------------------- - ! enforce complete freezing below - 48 c - ! ----------------------------------------------------------------------- - - dtmp = t_wfr - tz (k) ! [ - 40, - 48] - if (dtmp > 0. .and. ql (k) > qcmin) then - sink = min (ql (k), ql (k) * dtmp * 0.125, dtmp / icpk (k)) - ql (k) = ql (k) - sink - qi (k) = qi (k) + sink - q_liq (k) = q_liq (k) - sink - q_sol (k) = q_sol (k) + sink - cvm (k) = one_r8 + qv (k) * c1_vap + q_liq (k) * c1_liq + q_sol (k) * c1_ice - tz (k) = (te8 (k) - lv00 * qv (k) + li00 * q_sol (k)) / cvm (k) - icpk (k) = (li00 + d1_ice * tz (k)) / cvm (k) - endif - - ! ----------------------------------------------------------------------- - ! bigg mechanism - ! ----------------------------------------------------------------------- - - tc = tice - tz (k) - if (ql (k) > qrmin .and. tc > 0.1) then - sink = 3.3333e-10 * dts * (exp (0.66 * tc) - 1.) * den (k) * ql (k) * ql (k) - sink = min (ql (k), tc / icpk (k), sink) - ql (k) = ql (k) - sink - qi (k) = qi (k) + sink - q_liq (k) = q_liq (k) - sink - q_sol (k) = q_sol (k) + sink - cvm (k) = one_r8 + qv (k) * c1_vap + q_liq (k) * c1_liq + q_sol (k) * c1_ice - tz (k) = (te8 (k) - lv00 * qv (k) + li00 * q_sol (k)) / cvm (k) - endif ! significant ql existed + if (.not. do_warm_rain_mp) then - ! ----------------------------------------------------------------------- - ! update capacity heat and latend heat coefficient - ! ----------------------------------------------------------------------- + ! ----------------------------------------------------------------------- + ! enforce complete freezing below - 48 c + ! ----------------------------------------------------------------------- - tcpk (k) = (li20 + (d1_vap + d1_ice) * tz (k)) / cvm (k) + dtmp = t_wfr - tz (k) ! [ - 40, - 48] + if (dtmp > 0. .and. ql (k) > qcmin) then + sink = min (ql (k), ql (k) * dtmp * 0.125, dtmp / icpk (k)) + ql (k) = ql (k) - sink + qi (k) = qi (k) + sink + q_liq (k) = q_liq (k) - sink + q_sol (k) = q_sol (k) + sink + cvm (k) = one_r8 + qv (k) * c1_vap + q_liq (k) * c1_liq + q_sol (k) * c1_ice + tz (k) = (te8 (k) - lv00 * qv (k) + li00 * q_sol (k)) / cvm (k) + icpk (k) = (li00 + d1_ice * tz (k)) / cvm (k) + endif - ! ----------------------------------------------------------------------- - ! sublimation / deposition of ice - ! ----------------------------------------------------------------------- + ! ----------------------------------------------------------------------- + ! bigg mechanism + ! ----------------------------------------------------------------------- - if (tz (k) < tice) then - qsi = iqs2 (tz (k), den (k), dqsdt) - dq = qv (k) - qsi - sink = dq / (1. + tcpk (k) * dqsdt) - if (qi (k) > qrmin) then - ! eq 9, hong et al. 2004, mwr - ! for a and b, see dudhia 1989: page 3103 eq (b7) and (b8) - pidep = dts * dq * 349138.78 * exp (0.875 * log (qi (k) * den (k))) & - / (qsi * den (k) * lat2 / (0.0243 * rvgas * tz (k) ** 2) + 4.42478e4) + if (do_sat_adj) then + dt_pisub = 0.5 * dts else - pidep = 0. - endif - if (dq > 0.) then ! vapor - > ice - tmp = tice - tz (k) - ! 20160912: the following should produce more ice at higher altitude - ! qi_crt = 4.92e-11 * exp (1.33 * log (1.e3 * exp (0.1 * tmp))) / den (k) - qi_crt = qi_gen * min (qi_lim, 0.1 * tmp) / den (k) - sink = min (sink, max (qi_crt - qi (k), pidep), tmp / tcpk (k)) - else ! ice -- > vapor - pidep = pidep * min (1., dim (tz (k), t_sub) * 0.2) - sink = max (pidep, sink, - qi (k)) + dt_pisub = dts + tc = tice - tz (k) + if (ql (k) > qrmin .and. tc > 0.1) then + sink = 100. / (rhow * ccn (k)) * dts * (exp (0.66 * tc) - 1.) * ql (k) ** 2 + sink = min (ql (k), tc / icpk (k), sink) + ql (k) = ql (k) - sink + qi (k) = qi (k) + sink + q_liq (k) = q_liq (k) - sink + q_sol (k) = q_sol (k) + sink + cvm (k) = one_r8 + qv (k) * c1_vap + q_liq (k) * c1_liq + q_sol (k) * c1_ice + tz (k) = (te8 (k) - lv00 * qv (k) + li00 * q_sol (k)) / cvm (k) + endif ! significant ql existed endif - qv (k) = qv (k) - sink - qi (k) = qi (k) + sink - q_sol (k) = q_sol (k) + sink - cvm (k) = one_r8 + qv (k) * c1_vap + q_liq (k) * c1_liq + q_sol (k) * c1_ice - tz (k) = (te8 (k) - lv00 * qv (k) + li00 * q_sol (k)) / cvm (k) - endif - ! ----------------------------------------------------------------------- - ! update capacity heat and latend heat coefficient - ! ----------------------------------------------------------------------- + ! ----------------------------------------------------------------------- + ! update capacity heat and latend heat coefficient + ! ----------------------------------------------------------------------- - tcpk (k) = (li20 + (d1_vap + d1_ice) * tz (k)) / cvm (k) + tcpk (k) = (li20 + (d1_vap + d1_ice) * tz (k)) / cvm (k) - ! ----------------------------------------------------------------------- - ! sublimation / deposition of snow - ! this process happens for all temp rage - ! ----------------------------------------------------------------------- + ! ----------------------------------------------------------------------- + ! sublimation / deposition of ice + ! ----------------------------------------------------------------------- - if (qs (k) > qrmin) then - qsi = iqs2 (tz (k), den (k), dqsdt) - qden = qs (k) * den (k) - tmp = exp (0.65625 * log (qden)) - tsq = tz (k) * tz (k) - dq = (qsi - qv (k)) / (1. + tcpk (k) * dqsdt) - pssub = cssub (1) * tsq * (cssub (2) * sqrt (qden) + cssub (3) * tmp * & - sqrt (denfac (k))) / (cssub (4) * tsq + cssub (5) * qsi * den (k)) - pssub = (qsi - qv (k)) * dts * pssub - if (pssub > 0.) then ! qs -- > qv, sublimation - pssub = min (pssub * min (1., dim (tz (k), t_sub) * 0.2), qs (k)) - else - if (tz (k) > tice) then - pssub = 0. ! no deposition + if (tz (k) < tice) then + qsi = iqs2 (tz (k), den (k), dqsdt) + dq = qv (k) - qsi + sink = dq / (1. + tcpk (k) * dqsdt) + if (qi (k) > qrmin) then + if (.not. prog_ccn) then + if (inflag .eq. 1) & + ! hong et al., 2004 + cin (k) = 5.38e7 * exp (0.75 * log (qi (k) * den (k))) + if (inflag .eq. 2) & + ! meyers et al., 1992 + cin (k) = exp (-2.80 + 0.262 * (tice - tz (k))) * 1000.0 ! convert from L^-1 to m^-3 + if (inflag .eq. 3) & + ! meyers et al., 1992 + cin (k) = exp (-0.639 + 12.96 * (qv (k) / qsi - 1.0)) * 1000.0 ! convert from L^-1 to m^-3 + if (inflag .eq. 4) & + ! cooper, 1986 + cin (k) = 5.e-3 * exp (0.304 * (tice - tz (k))) * 1000.0 ! convert from L^-1 to m^-3 + if (inflag .eq. 5) & + ! flecther, 1962 + cin (k) = 1.e-5 * exp (0.5 * (tice - tz (k))) * 1000.0 ! convert from L^-1 to m^-3 + endif + pidep = dt_pisub * dq * 4.0 * 11.9 * exp (0.5 * log (qi (k) * den (k) * cin (k))) & + / (qsi * den (k) * lat2 / (0.0243 * rvgas * tz (k) ** 2) + 4.42478e4) else - pssub = max (pssub, dq, (tz (k) - tice) / tcpk (k)) + pidep = 0. endif + if (dq > 0.) then ! vapor - > ice + tmp = tice - tz (k) + ! 20160912: the following should produce more ice at higher altitude + ! qi_crt = 4.92e-11 * exp (1.33 * log (1.e3 * exp (0.1 * tmp))) / den (k) + qi_crt = qi_gen * min (qi_lim, 0.1 * tmp) / den (k) + sink = min (sink, max (qi_crt - qi (k), pidep), tmp / tcpk (k)) + dep = dep + sink * dp1 (k) + else ! ice -- > vapor + pidep = pidep * min (1., dim (tz (k), t_sub) * 0.2) + sink = max (pidep, sink, - qi (k)) + sub = sub - sink * dp1 (k) + endif + qv (k) = qv (k) - sink + qi (k) = qi (k) + sink + q_sol (k) = q_sol (k) + sink + cvm (k) = one_r8 + qv (k) * c1_vap + q_liq (k) * c1_liq + q_sol (k) * c1_ice + tz (k) = (te8 (k) - lv00 * qv (k) + li00 * q_sol (k)) / cvm (k) endif - ! ******************************* - ! evap all snow if tz (k) > 12. c - !s ****************************** - if (tz (k) > tice + 12.) then - tmp = qs (k) - pssub - if (tmp > 0.) pssub = pssub + tmp - endif + ! ----------------------------------------------------------------------- + ! update capacity heat and latend heat coefficient + ! ----------------------------------------------------------------------- - qs (k) = qs (k) - pssub - qv (k) = qv (k) + pssub - q_sol (k) = q_sol (k) - pssub - cvm (k) = one_r8 + qv (k) * c1_vap + q_liq (k) * c1_liq + q_sol (k) * c1_ice - tz (k) = (te8 (k) - lv00 * qv (k) + li00 * q_sol (k)) / cvm (k) tcpk (k) = (li20 + (d1_vap + d1_ice) * tz (k)) / cvm (k) - endif - ! ----------------------------------------------------------------------- - ! simplified 2 - way grapuel sublimation - deposition mechanism - ! ----------------------------------------------------------------------- - if (qg (k) > qrmin) then - qsi = iqs2 (tz (k), den (k), dqsdt) - dq = (qv (k) - qsi) / (1. + tcpk (k) * dqsdt) - pgsub = (qv (k) / qsi - 1.) * qg (k) - if (pgsub > 0.) then ! deposition - if (tz (k) > tice .or. qg (k) < 1.e-6) then - pgsub = 0. ! no deposition + ! ----------------------------------------------------------------------- + ! sublimation / deposition of snow + ! this process happens for all temp rage + ! ----------------------------------------------------------------------- + + if (qs (k) > qrmin) then + qsi = iqs2 (tz (k), den (k), dqsdt) + qden = qs (k) * den (k) + tmp = exp (0.65625 * log (qden)) + tsq = tz (k) * tz (k) + dq = (qsi - qv (k)) / (1. + tcpk (k) * dqsdt) + pssub = cssub (1) * tsq * (cssub (2) * sqrt (qden) + cssub (3) * tmp * & + sqrt (denfac (k))) / (cssub (4) * tsq + cssub (5) * qsi * den (k)) + pssub = (qsi - qv (k)) * dts * pssub + if (pssub > 0.) then ! qs -- > qv, sublimation + pssub = min (pssub * min (1., dim (tz (k), t_sub) * 0.2), qs (k)) + sub = sub + pssub * dp1 (k) else - pgsub = min (fac_v2g * pgsub, 0.2 * dq, ql (k) + qr (k), & - (tice - tz (k)) / tcpk (k)) + if (tz (k) > tice) then + pssub = 0. ! no deposition + else + pssub = max (pssub, dq, (tz (k) - tice) / tcpk (k)) + endif + dep = dep - pssub * dp1 (k) endif - else ! submilation - pgsub = max (fac_g2v * pgsub, dq) * min (1., dim (tz (k), t_sub) * 0.1) + qs (k) = qs (k) - pssub + qv (k) = qv (k) + pssub + q_sol (k) = q_sol (k) - pssub + cvm (k) = one_r8 + qv (k) * c1_vap + q_liq (k) * c1_liq + q_sol (k) * c1_ice + tz (k) = (te8 (k) - lv00 * qv (k) + li00 * q_sol (k)) / cvm (k) + tcpk (k) = (li20 + (d1_vap + d1_ice) * tz (k)) / cvm (k) endif - qg (k) = qg (k) + pgsub - qv (k) = qv (k) - pgsub - q_sol (k) = q_sol (k) + pgsub - cvm (k) = one_r8 + qv (k) * c1_vap + q_liq (k) * c1_liq + q_sol (k) * c1_ice - tz (k) = (te8 (k) - lv00 * qv (k) + li00 * q_sol (k)) / cvm (k) - endif - ! ----------------------------------------------------------------------- - ! update capacity heat and latend heat coefficient - ! ----------------------------------------------------------------------- + ! ----------------------------------------------------------------------- + ! sublimation / deposition of graupel + ! this process happens for all temp rage + ! ----------------------------------------------------------------------- + + if (qg (k) > qrmin) then + qsi = iqs2 (tz (k), den (k), dqsdt) + qden = qg (k) * den (k) + tmp = exp (0.6875 * log (qden)) + tsq = tz (k) * tz (k) + dq = (qsi - qv (k)) / (1. + tcpk (k) * dqsdt) + pgsub = cgsub (1) * tsq * (cgsub (2) * sqrt (qden) + cgsub (3) * tmp / & + sqrt (sqrt (den (k)))) / (cgsub (4) * tsq + cgsub (5) * qsi * den (k)) + pgsub = (qsi - qv (k)) * dts * pgsub + if (pgsub > 0.) then ! qs -- > qv, sublimation + pgsub = min (pgsub * min (1., dim (tz (k), t_sub) * 0.2), qg (k)) + sub = sub + pgsub * dp1 (k) + else + if (tz (k) > tice) then + pgsub = 0. ! no deposition + else + pgsub = max (pgsub, dq, (tz (k) - tice) / tcpk (k)) + endif + dep = dep - pgsub * dp1 (k) + endif + qg (k) = qg (k) - pgsub + qv (k) = qv (k) + pgsub + q_sol (k) = q_sol (k) - pgsub + cvm (k) = one_r8 + qv (k) * c1_vap + q_liq (k) * c1_liq + q_sol (k) * c1_ice + tz (k) = (te8 (k) - lv00 * qv (k) + li00 * q_sol (k)) / cvm (k) + tcpk (k) = (li20 + (d1_vap + d1_ice) * tz (k)) / cvm (k) + endif - ! lcpk (k) = (lv00 + d1_vap * tz (k)) / cvm (k) - ! icpk (k) = (li00 + d1_ice * tz (k)) / cvm (k) + endif ! ----------------------------------------------------------------------- ! compute cloud fraction @@ -2010,7 +2329,6 @@ subroutine subgrid_z_proc (ks, ke, p1, den, denfac, dts, rh_adj, tz, qv, & ! binary cloud scheme ! ----------------------------------------------------------------------- - ! ----------------------------------------------------------------------- ! partial cloudiness by pdf: ! assuming subgrid linear distribution in horizontal; this is effectively a smoother for the @@ -2024,42 +2342,104 @@ subroutine subgrid_z_proc (ks, ke, p1, den, denfac, dts, rh_adj, tz, qv, & ! icloud_f = 0: bug - fixed ! icloud_f = 1: old fvgfs gfdl) mp implementation ! icloud_f = 2: binary cloud scheme (0 / 1) + ! icloud_f = 3: revision of icloud = 0 ! ----------------------------------------------------------------------- - if (rh > 0.80 .and. qpz > 1.e-6) then - - dq = h_var * qpz - q_plus = qpz + dq - q_minus = qpz - dq + if (use_xr_cloud) then ! xu and randall cloud scheme (1996) + if (rh >= 1.0) then + qa (k) = 1.0 + elseif (rh > rh_thres .and. q_cond (k) > 1.e-6) then + qa (k) = rh ** xr_a * (1.0 - exp (- xr_b * max (0.0, q_cond (k)) / & + max (1.e-5, (max (1.e-10, 1.0 - rh) * qstar) ** xr_c))) + qa (k) = max (0.0, min (1., qa (k))) + else + qa (k) = 0.0 + endif + elseif (use_park_cloud) then ! park et al. 2016 (mon. wea. review) + if (q_cond (k) > 1.e-6) then + qa (k) = 1. / 50. * (5.77 * (100. - gsize / 1000.) * max (0.0, q_cond (k) * 1000.) ** 1.07 + & + 4.82 * (gsize / 1000. - 50.) * max (0.0, q_cond (k) * 1000.) ** 0.94) + qa (k) = qa (k) * (0.92 / 0.96 * q_liq (k) / q_cond (k) + 1.0 / 0.96 * q_sol (k) / q_cond (k)) + qa (k) = max (0.0, min (1., qa (k))) + else + qa (k) = 0.0 + endif + elseif (use_gi_cloud) then ! gultepe and isaac (2007) + sigma = 0.28 + max (0.0, q_cond (k) * 1000.) ** 0.49 + gam = max (0.0, q_cond (k) * 1000.) / sigma + if (gam < 0.18) then + qa10 = 0. + elseif (gam > 2.0) then + qa10 = 1.0 + else + qa10 = - 0.1754 + 0.9811 * gam - 0.2223 * gam ** 2 + 0.0104 * gam ** 3 + qa10 = max (0.0, min (1., qa10)) + endif + if (gam < 0.12) then + qa100 = 0. + elseif (gam > 1.85) then + qa100 = 1.0 + else + qa100 = - 0.0913 + 0.7213 * gam + 0.1060 * gam ** 2 - 0.0946 * gam ** 3 + qa100 = max (0.0, min (1., qa100)) + endif + qa (k) = qa10 + (log10 (gsize / 1000.) - 1) * (qa100 - qa10) + qa (k) = max (0.0, min (1., qa (k))) + else + if (rh > rh_thres .and. qpz > 1.e-6) then - if (icloud_f == 2) then - if (qstar < qpz) then - qa (k) = 1. + dq = h_var * qpz + if (do_cld_adj) then + q_plus = qpz + dq * f_dq_p * min(1.0, max(0.0, (p1 (k) - 200.e2) / (1000.e2 - 200.e2))) else - qa (k) = 0. + q_plus = qpz + dq * f_dq_p endif - else - if (qstar < q_minus) then - qa (k) = 1. - else - if (qstar < q_plus) then - if (icloud_f == 0) then - qa (k) = (q_plus - qstar) / (dq + dq) - else - qa (k) = (q_plus - qstar) / (2. * dq * (1. - q_cond (k))) - endif + q_minus = qpz - dq * f_dq_m + + if (icloud_f .eq. 2) then + if (qstar < qpz) then + qa (k) = 1. else qa (k) = 0. endif - ! impose minimum cloudiness if substantial q_cond (k) exist - if (q_cond (k) > 1.e-6) then - qa (k) = max (cld_min, qa (k)) + elseif (icloud_f .eq. 3) then + if (qstar < qpz) then + qa (k) = 1. + else + if (qstar < q_plus) then + qa (k) = (q_plus - qstar) / (dq * f_dq_p) + else + qa (k) = 0. + endif + ! impose minimum cloudiness if substantial q_cond (k) exist + if (q_cond (k) > 1.e-6) then + qa (k) = max (cld_min, qa (k)) + endif + qa (k) = min (1., qa (k)) + endif + else + if (qstar < q_minus) then + qa (k) = 1. + else + if (qstar < q_plus) then + if (icloud_f .eq. 0) then + qa (k) = (q_plus - qstar) / (dq * f_dq_p + dq * f_dq_m) + else + qa (k) = (q_plus - qstar) / ((dq * f_dq_p + dq * f_dq_m) * (1. - q_cond (k))) + endif + else + qa (k) = 0. + endif + ! impose minimum cloudiness if substantial q_cond (k) exist + if (q_cond (k) > 1.e-6) then + qa (k) = max (cld_min, qa (k)) + endif + qa (k) = min (1., qa (k)) endif - qa (k) = min (1., qa (k)) endif + else + qa (k) = 0. endif - else - qa (k) = 0. endif enddo @@ -2067,28 +2447,123 @@ subroutine subgrid_z_proc (ks, ke, p1, den, denfac, dts, rh_adj, tz, qv, & end subroutine subgrid_z_proc ! ======================================================================= -! compute terminal fall speed -! consider cloud ice, snow, and graupel's melting during fall +! rain evaporation ! ======================================================================= -subroutine terminal_fall (dtm, ks, ke, tz, qv, ql, qr, qg, qs, qi, dz, dp, & - den, vtg, vts, vti, r1, g1, s1, i1, m1_sol, w1) +subroutine revap_rac1 (hydrostatic, is, ie, dt, tz, qv, ql, qr, qi, qs, qg, den, hvar) implicit none - integer, intent (in) :: ks, ke - real, intent (in) :: dtm ! time step (s) - real, intent (in), dimension (ks:ke) :: vtg, vts, vti, den, dp, dz - real (kind = r_grid), intent (inout), dimension (ks:ke) :: tz - real, intent (inout), dimension (ks:ke) :: qv, ql, qr, qg, qs, qi, m1_sol, w1 - real, intent (out) :: r1, g1, s1, i1 - ! local: - real, dimension (ks:ke + 1) :: ze, zt - real :: qsat, dqsdt, dt5, evap, dtime - real :: factor, frac + logical, intent (in) :: hydrostatic + + integer, intent (in) :: is, ie + + real, intent (in) :: dt ! time step (s) + + real, intent (in), dimension (is:ie) :: den, hvar, qi, qs, qg + + real, intent (inout), dimension (is:ie) :: tz, qv, qr, ql + + real, dimension (is:ie) :: lcp2, denfac, q_liq, q_sol, cvm, lhl + + real :: dqv, qsat, dqsdt, evap, qden, q_plus, q_minus, sink + real :: tin, t2, qpz, dq, dqh + + integer :: i + + ! ----------------------------------------------------------------------- + ! define latend heat coefficient + ! ----------------------------------------------------------------------- + + do i = is, ie + lhl (i) = lv00 + d0_vap * tz (i) + q_liq (i) = ql (i) + qr (i) + q_sol (i) = qi (i) + qs (i) + qg (i) + cvm (i) = c_air + qv (i) * c_vap + q_liq (i) * c_liq + q_sol (i) * c_ice + lcp2 (i) = lhl (i) / cvm (i) + ! denfac (i) = sqrt (sfcrho / den (i)) + enddo + + do i = is, ie + if (qr (i) > qrmin .and. tz (i) > t_wfr) then + qpz = qv (i) + ql (i) + tin = tz (i) - lcp2 (i) * ql (i) ! presence of clouds suppresses the rain evap + qsat = wqs2 (tin, den (i), dqsdt) + dqh = max (ql (i), hvar (i) * max (qpz, qcmin)) + dqv = qsat - qv (i) + q_minus = qpz - dqh + q_plus = qpz + dqh + + ! ----------------------------------------------------------------------- + ! qsat must be > q_minus to activate evaporation + ! qsat must be < q_plus to activate accretion + ! ----------------------------------------------------------------------- + + ! ----------------------------------------------------------------------- + ! rain evaporation + ! ----------------------------------------------------------------------- + + if (dqv > qvmin .and. qsat > q_minus) then + if (qsat > q_plus) then + dq = qsat - qpz + else + ! q_minus < qsat < q_plus + ! dq == dqh if qsat == q_minus + dq = 0.25 * (q_minus - qsat) ** 2 / dqh + endif + qden = qr (i) * den (i) + t2 = tin * tin + evap = crevp (1) * t2 * dq * (crevp (2) * sqrt (qden) + crevp (3) * exp (0.725 * log (qden))) & + / (crevp (4) * t2 + crevp (5) * qsat * den (i)) + evap = min (qr (i), dt * evap, dqv / (1. + lcp2 (i) * dqsdt)) + qr (i) = qr (i) - evap + qv (i) = qv (i) + evap + q_liq (i) = q_liq (i) - evap + cvm (i) = c_air + qv (i) * c_vap + q_liq (i) * c_liq + q_sol (i) * c_ice + tz (i) = tz (i) - evap * lhl (i) / cvm (i) + endif + + ! ----------------------------------------------------------------------- + ! accretion: pracc + ! ----------------------------------------------------------------------- + + if (qr (i) > qrmin .and. ql (i) > 1.e-8 .and. qsat < q_plus) then + denfac (i) = sqrt (sfcrho / den (i)) + sink = dt * denfac (i) * cracw * exp (0.95 * log (qr (i) * den (i))) + sink = sink / (1. + sink) * ql (i) + ql (i) = ql (i) - sink + qr (i) = qr (i) + sink + endif + endif + enddo + +end subroutine revap_rac1 + +! ======================================================================= +! compute terminal fall speed +! consider cloud ice, snow, and graupel's melting during fall +! ======================================================================= + +subroutine terminal_fall (dtm, ks, ke, tz, qv, ql, qr, qg, qs, qi, dz, dp, & + den, vtg, vts, vti, r1, g1, s1, i1, m1_sol, w1, dte) + + implicit none + + integer, intent (in) :: ks, ke + real, intent (in) :: dtm ! time step (s) + real, intent (in), dimension (ks:ke) :: vtg, vts, vti, den, dp, dz + real (kind = r_grid), intent (inout), dimension (ks:ke) :: tz + real, intent (inout), dimension (ks:ke) :: qv, ql, qr, qg, qs, qi, m1_sol, w1 + real (kind = r_grid), intent (inout) :: dte + real, intent (out) :: r1, g1, s1, i1 + ! local: + real, dimension (ks:ke + 1) :: ze, zt + real :: qsat, dqsdt, dt5, evap, dtime + real :: factor, frac real :: tmp, precip, tc, sink real, dimension (ks:ke) :: lcpk, icpk, cvm, q_liq, q_sol real, dimension (ks:ke) :: m1, dm + real (kind = r_grid), dimension (ks:ke) :: te1, te2 real :: zs = 0. real :: fac_imlt @@ -2169,7 +2644,7 @@ subroutine terminal_fall (dtm, ks, ke, tz, qv, ql, qr, qg, qs, qi, dz, dp, & enddo ! ----------------------------------------------------------------------- - ! melting of falling cloud ice into rain + ! melting of falling cloud ice into cloud water and rain ! ----------------------------------------------------------------------- call check_column (ks, ke, qi, no_fall) @@ -2213,12 +2688,35 @@ subroutine terminal_fall (dtm, ks, ke, tz, qv, ql, qr, qg, qs, qi, dz, dp, & enddo endif + ! ----------------------------------------------------------------------- + ! energy loss during sedimentation + ! ----------------------------------------------------------------------- + + if (consv_checker) then + do k = ks, ke + te1 (k) = one_r8 + qv (k) * c1_vap + (ql (k) + qr (k)) * c1_liq + (qi (k) + qs (k) + qg (k)) * c1_ice + te1 (k) = rgrav * te1 (k) * c_air * tz (k) * dp (k) + enddo + endif + if (use_ppm_ice) then call lagrangian_fall_ppm (ks, ke, zs, ze, zt, dp, qi, i1, m1_sol, mono_prof) else call implicit_fall (dtm, ks, ke, ze, vti, dp, qi, i1, m1_sol) endif + ! ----------------------------------------------------------------------- + ! energy loss during sedimentation + ! ----------------------------------------------------------------------- + + if (consv_checker) then + do k = ks, ke + te2 (k) = one_r8 + qv (k) * c1_vap + (ql (k) + qr (k)) * c1_liq + (qi (k) + qs (k) + qg (k)) * c1_ice + te2 (k) = rgrav * te2 (k) * c_air * tz (k) * dp (k) + enddo + dte = dte + sum (te1) - sum (te2) + endif + if (do_sedi_w) then w1 (ks) = w1 (ks) + m1_sol (ks) * vti (ks) / dm (ks) do k = ks + 1, ke @@ -2280,12 +2778,35 @@ subroutine terminal_fall (dtm, ks, ke, tz, qv, ql, qr, qg, qs, qi, dz, dp, & enddo endif + ! ----------------------------------------------------------------------- + ! energy loss during sedimentation + ! ----------------------------------------------------------------------- + + if (consv_checker) then + do k = ks, ke + te1 (k) = one_r8 + qv (k) * c1_vap + (ql (k) + qr (k)) * c1_liq + (qi (k) + qs (k) + qg (k)) * c1_ice + te1 (k) = rgrav * te1 (k) * c_air * tz (k) * dp (k) + enddo + endif + if (use_ppm) then call lagrangian_fall_ppm (ks, ke, zs, ze, zt, dp, qs, s1, m1, mono_prof) else call implicit_fall (dtm, ks, ke, ze, vts, dp, qs, s1, m1) endif + ! ----------------------------------------------------------------------- + ! energy loss during sedimentation + ! ----------------------------------------------------------------------- + + if (consv_checker) then + do k = ks, ke + te2 (k) = one_r8 + qv (k) * c1_vap + (ql (k) + qr (k)) * c1_liq + (qi (k) + qs (k) + qg (k)) * c1_ice + te2 (k) = rgrav * te2 (k) * c_air * tz (k) * dp (k) + enddo + dte = dte + sum (te1) - sum (te2) + endif + do k = ks, ke m1_sol (k) = m1_sol (k) + m1 (k) enddo @@ -2348,12 +2869,35 @@ subroutine terminal_fall (dtm, ks, ke, tz, qv, ql, qr, qg, qs, qi, dz, dp, & enddo endif + ! ----------------------------------------------------------------------- + ! energy loss during sedimentation + ! ----------------------------------------------------------------------- + + if (consv_checker) then + do k = ks, ke + te1 (k) = one_r8 + qv (k) * c1_vap + (ql (k) + qr (k)) * c1_liq + (qi (k) + qs (k) + qg (k)) * c1_ice + te1 (k) = rgrav * te1 (k) * c_air * tz (k) * dp (k) + enddo + endif + if (use_ppm) then call lagrangian_fall_ppm (ks, ke, zs, ze, zt, dp, qg, g1, m1, mono_prof) else call implicit_fall (dtm, ks, ke, ze, vtg, dp, qg, g1, m1) endif + ! ----------------------------------------------------------------------- + ! energy loss during sedimentation + ! ----------------------------------------------------------------------- + + if (consv_checker) then + do k = ks, ke + te2 (k) = one_r8 + qv (k) * c1_vap + (ql (k) + qr (k)) * c1_liq + (qi (k) + qs (k) + qg (k)) * c1_ice + te2 (k) = rgrav * te2 (k) * c_air * tz (k) * dp (k) + enddo + dte = dte + sum (te1) - sum (te2) + endif + do k = ks, ke m1_sol (k) = m1_sol (k) + m1 (k) enddo @@ -2451,7 +2995,7 @@ subroutine implicit_fall (dt, ks, ke, ze, vt, dp, q, precip, m1) ! ----------------------------------------------------------------------- do k = ks, ke - q (k) = qm (k) / dp (k) + q (k) = qm (k) / dp (k) !dry dp used inside MP enddo end subroutine implicit_fall @@ -2829,8 +3373,14 @@ subroutine fall_speed (ks, ke, den, qs, qi, qg, ql, tk, vts, vti, vtg) vti (k) = vf_min else tc (k) = tk (k) - tice - vti (k) = (3. + log10 (qi (k) * den (k))) * (tc (k) * (aa * tc (k) + bb) + cc) + dd * tc (k) + ee - vti (k) = vi0 * exp (log_10 * vti (k)) + if (hd_icefall) then + ! heymsfield and donner, 1990, jas + vti (k) = vi_fac * 3.29 * (qi (k) * den (k)) ** 0.16 + else + ! deng and mace, 2008, grl + vti (k) = (3. + log10 (qi (k) * den (k))) * (tc (k) * (aa * tc (k) + bb) + cc) + dd * tc (k) + ee + vti (k) = vi0 * exp (log_10 * vti (k)) + endif vti (k) = min (vi_max, max (vf_min, vti (k))) endif enddo @@ -2927,11 +3477,11 @@ subroutine setupm tcond = 2.36e-2 visk = 1.259e-5 - hlts = 2.8336e6 - hltc = 2.5e6 - hltf = 3.336e5 + hlts = hlv + hlf + hltc = hlv + hltf = hlf - ch2o = 4.1855e3 + ch2o = c_liq ri50 = 1.e-4 pisq = pie * pie @@ -3038,7 +3588,7 @@ subroutine setupm cgmlt (4) = cgsub (3) cgmlt (5) = ch2o / hltf - es0 = 6.107799961e2 ! ~6.1 mb + es0 = e00 ces0 = eps * es0 end subroutine setupm @@ -3047,71 +3597,21 @@ end subroutine setupm ! initialization of gfdl cloud microphysics ! ======================================================================= -!subroutine gfdl_mp_init (id, jd, kd, axes, time) -subroutine gfdl_mp_init (me, master, nlunit, input_nml_file, logunit, fn_nml) +subroutine gfdl_mp_init (input_nml_file, logunit) implicit none - integer, intent (in) :: me - integer, intent (in) :: master - integer, intent (in) :: nlunit - integer, intent (in) :: logunit - - character (len = 64), intent (in) :: fn_nml character (len = *), intent (in) :: input_nml_file (:) + integer, intent (in) :: logunit - integer :: ios logical :: exists - ! integer, intent (in) :: id, jd, kd - ! integer, intent (in) :: axes (4) - ! type (time_type), intent (in) :: time - - ! integer :: unit, io, ierr, k, logunit - ! logical :: flag - ! real :: tmp, q1, q2 - - ! master = (mpp_pe () .eq.mpp_root_pe ()) - - !#ifdef internal_file_nml - ! read (input_nml_file, nml = gfdl_mp_nml, iostat = io) - ! ierr = check_nml_error (io, 'gfdl_mp_nml') - !#else - ! if (file_exist ('input.nml')) then - ! unit = open_namelist_file () - ! io = 1 - ! do while (io .ne. 0) - ! read (unit, nml = gfdl_mp_nml, iostat = io, end = 10) - ! ierr = check_nml_error (io, 'gfdl_mp_nml') - ! enddo - !10 call close_file (unit) - ! endif - !#endif - ! call write_version_number ('gfdl_mp_mod', version) - ! logunit = stdlog () - -#ifdef INTERNAL_FILE_NML read (input_nml_file, nml = gfdl_mp_nml) -#else - inquire (file = trim (fn_nml), exist = exists) - if (.not. exists) then - write (6, *) 'gfdl - mp :: namelist file: ', trim (fn_nml), ' does not exist' - stop - else - open (unit = nlunit, file = fn_nml, readonly, status = 'old', iostat = ios) - endif - rewind (nlunit) - read (nlunit, nml = gfdl_mp_nml) - close (nlunit) -#endif ! write version number and namelist to log file - - if (me == master) then - write (logunit, *) " ================================================================== " - write (logunit, *) "gfdl_mp_mod" - write (logunit, nml = gfdl_mp_nml) - endif + write (logunit, *) " ================================================================== " + write (logunit, *) "gfdl_mp_mod" + write (logunit, nml = gfdl_mp_nml) if (do_setup) then call setup_con @@ -3122,31 +3622,11 @@ subroutine gfdl_mp_init (me, master, nlunit, input_nml_file, logunit, fn_nml) g2 = 0.5 * grav log_10 = log (10.) - tice0 = tice - 0.01 - t_wfr = tice - 40.0 ! supercooled water can exist down to - 48 c, which is the "absolute" - - ! if (master) write (logunit, nml = gfdl_mp_nml) - - ! if (master) write (*, *) 'prec_lin diagnostics initialized.', id_prec - - ! call qsmith_init - - ! testing the water vapor tables - - ! if (mp_debug .and. master) then - ! write (*, *) 'testing water vapor tables in gfdl_mp' - ! tmp = tice - 90. - ! do k = 1, 25 - ! q1 = wqsat_moist (tmp, 0., 1.e5) - ! q2 = qs1d_m (tmp, 0., 1.e5) - ! write (*, *) nint (tmp - tice), q1, q2, 'dq = ', q1 - q2 - ! tmp = tmp + 5. - ! enddo - ! endif - - ! if (master) write (*, *) 'gfdl_cloud_micrphys diagnostics initialized.' - - ! gfdl_mp_clock = mpp_clock_id ('gfdl_mp', grain = clock_routine) + if (do_warm_rain_mp) then + t_wfr = t_min + else + t_wfr = t_ice - 40.0 + endif module_is_initialized = .true. @@ -3183,150 +3663,436 @@ subroutine setup_con ! master = (mpp_pe () .eq.mpp_root_pe ()) - rgrav = 1. / grav - if (.not. qsmith_tables_initialized) call qsmith_init qsmith_tables_initialized = .true. -end subroutine setup_con +end subroutine setup_con + +! ======================================================================= +! accretion function (lin et al. 1983) +! ======================================================================= + +real function acr3d (v1, v2, q1, q2, c, cac, rho) + + implicit none + + real, intent (in) :: v1, v2, c, rho + real, intent (in) :: q1, q2 ! mixing ratio!!! + real, intent (in) :: cac (3) + + real :: t1, s1, s2 + + ! integer :: k + ! + ! real :: a + ! + ! a = 0.0 + ! do k = 1, 3 + ! a = a + cac (k) * ((q1 * rho) ** ((7 - k) * 0.25) * (q2 * rho) ** (k * 0.25)) + ! enddo + ! acr3d = c * abs (v1 - v2) * a / rho + + ! optimized + + t1 = sqrt (q1 * rho) + s1 = sqrt (q2 * rho) + s2 = sqrt (s1) ! s1 = s2 ** 2 + acr3d = c * abs (v1 - v2) * q1 * s2 * (cac (1) * t1 + cac (2) * sqrt (t1) * s2 + cac (3) * s1) + +end function acr3d + +! ======================================================================= +! melting of snow function (lin et al. 1983) +! note: psacw and psacr must be calc before smlt is called +! ======================================================================= + +real function smlt (tc, dqs, qsrho, psacw, psacr, c, rho, rhofac) + + implicit none + + real, intent (in) :: tc, dqs, qsrho, psacw, psacr, c (5), rho, rhofac + + smlt = (c (1) * tc / rho - c (2) * dqs) * (c (3) * sqrt (qsrho) + & + c (4) * qsrho ** 0.65625 * sqrt (rhofac)) + c (5) * tc * (psacw + psacr) + +end function smlt + +! ======================================================================= +! melting of graupel function (lin et al. 1983) +! note: pgacw and pgacr must be calc before gmlt is called +! ======================================================================= + +real function gmlt (tc, dqs, qgrho, pgacw, pgacr, c, rho) + + implicit none + + real, intent (in) :: tc, dqs, qgrho, pgacw, pgacr, c (5), rho + + gmlt = (c (1) * tc / rho - c (2) * dqs) * (c (3) * sqrt (qgrho) + & + c (4) * qgrho ** 0.6875 / rho ** 0.25) + c (5) * tc * (pgacw + pgacr) + +end function gmlt + +! ======================================================================= +! initialization +! prepare saturation water vapor pressure tables +! ======================================================================= + +subroutine qsmith_init + + implicit none + + integer, parameter :: length = 2621 + + integer :: i + + if (.not. tables_are_initialized) then + + allocate (table (length)) + allocate (table2 (length)) + allocate (table3 (length)) + allocate (tablew (length)) + allocate (des (length)) + allocate (des2 (length)) + allocate (des3 (length)) + allocate (desw (length)) + + call qs_table (length) + call qs_table2 (length) + call qs_table3 (length) + call qs_tablew (length) + + do i = 1, length - 1 + des (i) = max (0., table (i + 1) - table (i)) + des2 (i) = max (0., table2 (i + 1) - table2 (i)) + des3 (i) = max (0., table3 (i + 1) - table3 (i)) + desw (i) = max (0., tablew (i + 1) - tablew (i)) + enddo + des (length) = des (length - 1) + des2 (length) = des2 (length - 1) + des3 (length) = des3 (length - 1) + desw (length) = desw (length - 1) + + tables_are_initialized = .true. + + if (is_master()) print*, ' QS lookup tables initialized' + + endif + +end subroutine qsmith_init + +! ======================================================================= +! compute the saturated specific humidity for table ii +! ======================================================================= + +real function wqs1 (ta, den) + + implicit none + + ! pure water phase; universal dry / moist formular using air density + ! input "den" can be either dry or moist air density + + real, intent (in) :: ta, den + + real :: es, ap1, tmin + + integer :: it + + tmin = table_ice - 160. + ap1 = 10. * dim (ta, tmin) + 1. + ap1 = min (2621., ap1) + it = ap1 + es = tablew (it) + (ap1 - it) * desw (it) + wqs1 = es / (rvgas * ta * den) + +end function wqs1 + +! ======================================================================= +! compute the gradient of saturated specific humidity for table ii +! ======================================================================= + +real function wqs2 (ta, den, dqdt) + + implicit none + + ! pure water phase; universal dry / moist formular using air density + ! input "den" can be either dry or moist air density + + real, intent (in) :: ta, den + real, intent (out) :: dqdt + real :: es, ap1, tmin + integer :: it + + tmin = table_ice - 160. + + if (.not. tables_are_initialized) call qsmith_init + + ap1 = 10. * dim (ta, tmin) + 1. + ap1 = min (2621., ap1) + it = ap1 + es = tablew (it) + (ap1 - it) * desw (it) + wqs2 = es / (rvgas * ta * den) + it = ap1 - 0.5 + ! finite diff, del_t = 0.1: + dqdt = 10. * (desw (it) + (ap1 - it) * (desw (it + 1) - desw (it))) / (rvgas * ta * den) + +end function wqs2 + +! ======================================================================= +! compute the gradient of saturated specific humidity for table ii +! it is the same as "wqs2", but written as vector function +! ======================================================================= + +subroutine wqs2_vect (is, ie, ta, den, wqsat, dqdt) + + implicit none + + ! pure water phase; universal dry / moist formular using air density + ! input "den" can be either dry or moist air density + + integer, intent (in) :: is, ie + + real, intent (in), dimension (is:ie) :: ta, den + + real, intent (out), dimension (is:ie) :: wqsat, dqdt + + real :: es, ap1, tmin + + integer :: i, it + + tmin = t_ice - 160. + + do i = is, ie + ap1 = 10. * dim (ta (i), tmin) + 1. + ap1 = min (2621., ap1) + it = ap1 + es = tablew (it) + (ap1 - it) * desw (it) + wqsat (i) = es / (rvgas * ta (i) * den (i)) + it = ap1 - 0.5 + ! finite diff, del_t = 0.1: + dqdt (i) = 10. * (desw (it) + (ap1 - it) * (desw (it + 1) - desw (it))) / (rvgas * ta (i) * den (i)) + enddo + +end subroutine wqs2_vect + +! ======================================================================= +! compute wet buld temperature +! ======================================================================= + +real function wet_bulb (q, t, den) + + implicit none + + real, intent (in) :: t, q, den + + real :: qs, tp, dqdt + + wet_bulb = t + qs = wqs2 (wet_bulb, den, dqdt) + tp = 0.5 * (qs - q) / (1. + lcp * dqdt) * lcp + wet_bulb = wet_bulb - tp + + ! tp is negative if super - saturated + if (tp > 0.01) then + qs = wqs2 (wet_bulb, den, dqdt) + tp = (qs - q) / (1. + lcp * dqdt) * lcp + wet_bulb = wet_bulb - tp + endif + +end function wet_bulb + +! ======================================================================= +! compute the saturated specific humidity for table iii +! ======================================================================= + +real function iqs1 (ta, den) + + implicit none + + ! water - ice phase; universal dry / moist formular using air density + ! input "den" can be either dry or moist air density + + real, intent (in) :: ta, den + + real :: es, ap1, tmin + + integer :: it + + tmin = table_ice - 160. + ap1 = 10. * dim (ta, tmin) + 1. + ap1 = min (2621., ap1) + it = ap1 + es = table2 (it) + (ap1 - it) * des2 (it) + iqs1 = es / (rvgas * ta * den) + +end function iqs1 + +! ======================================================================= +! compute the gradient of saturated specific humidity for table iii +! ======================================================================= + +real function iqs2 (ta, den, dqdt) + + implicit none + + ! water - ice phase; universal dry / moist formular using air density + ! input "den" can be either dry or moist air density + + real (kind = r_grid), intent (in) :: ta + real, intent (in) :: den + real, intent (out) :: dqdt + real (kind = r_grid) :: tmin, es, ap1 + integer :: it + + tmin = table_ice - 160. + ap1 = 10. * dim (ta, tmin) + 1. + ap1 = min (2621., ap1) + it = ap1 + es = table2 (it) + (ap1 - it) * des2 (it) + iqs2 = es / (rvgas * ta * den) + it = ap1 - 0.5 + dqdt = 10. * (des2 (it) + (ap1 - it) * (des2 (it + 1) - des2 (it))) / (rvgas * ta * den) + +end function iqs2 + +! ======================================================================= +! compute the gradient of saturated specific humidity for table iii +! ======================================================================= + +real function qs1d_moist (ta, qv, pa, dqdt) + + implicit none + + real, intent (in) :: ta, pa, qv + + real, intent (out) :: dqdt + + real :: es, ap1, tmin, eps10 + + integer :: it + + tmin = table_ice - 160. + eps10 = 10. * eps + ap1 = 10. * dim (ta, tmin) + 1. + ap1 = min (2621., ap1) + it = ap1 + es = table2 (it) + (ap1 - it) * des2 (it) + qs1d_moist = eps * es * (1. + zvir * qv) / pa + it = ap1 - 0.5 + dqdt = eps10 * (des2 (it) + (ap1 - it) * (des2 (it + 1) - des2 (it))) * (1. + zvir * qv) / pa + +end function qs1d_moist ! ======================================================================= -! accretion function (lin et al. 1983) +! compute the gradient of saturated specific humidity for table ii ! ======================================================================= -real function acr3d (v1, v2, q1, q2, c, cac, rho) +real function wqsat2_moist (ta, qv, pa, dqdt) implicit none - real, intent (in) :: v1, v2, c, rho - real, intent (in) :: q1, q2 ! mixing ratio!!! - real, intent (in) :: cac (3) + real, intent (in) :: ta, pa, qv - real :: t1, s1, s2 + real, intent (out) :: dqdt - ! integer :: k - ! - ! real :: a - ! - ! a = 0.0 - ! do k = 1, 3 - ! a = a + cac (k) * ((q1 * rho) ** ((7 - k) * 0.25) * (q2 * rho) ** (k * 0.25)) - ! enddo - ! acr3d = c * abs (v1 - v2) * a / rho + real :: es, ap1, tmin, eps10 - ! optimized + integer :: it - t1 = sqrt (q1 * rho) - s1 = sqrt (q2 * rho) - s2 = sqrt (s1) ! s1 = s2 ** 2 - acr3d = c * abs (v1 - v2) * q1 * s2 * (cac (1) * t1 + cac (2) * sqrt (t1) * s2 + cac (3) * s1) + tmin = table_ice - 160. + eps10 = 10. * eps + ap1 = 10. * dim (ta, tmin) + 1. + ap1 = min (2621., ap1) + it = ap1 + es = tablew (it) + (ap1 - it) * desw (it) + wqsat2_moist = eps * es * (1. + zvir * qv) / pa + it = ap1 - 0.5 + dqdt = eps10 * (desw (it) + (ap1 - it) * (desw (it + 1) - desw (it))) * (1. + zvir * qv) / pa -end function acr3d +end function wqsat2_moist ! ======================================================================= -! melting of snow function (lin et al. 1983) -! note: psacw and psacr must be calc before smlt is called +! compute the saturated specific humidity for table ii ! ======================================================================= -real function smlt (tc, dqs, qsrho, psacw, psacr, c, rho, rhofac) +real function wqsat_moist (ta, qv, pa) implicit none - real, intent (in) :: tc, dqs, qsrho, psacw, psacr, c (5), rho, rhofac - - smlt = (c (1) * tc / rho - c (2) * dqs) * (c (3) * sqrt (qsrho) + & - c (4) * qsrho ** 0.65625 * sqrt (rhofac)) + c (5) * tc * (psacw + psacr) - -end function smlt - -! ======================================================================= -! melting of graupel function (lin et al. 1983) -! note: pgacw and pgacr must be calc before gmlt is called -! ======================================================================= - -real function gmlt (tc, dqs, qgrho, pgacw, pgacr, c, rho) + real, intent (in) :: ta, pa, qv - implicit none + real :: es, ap1, tmin - real, intent (in) :: tc, dqs, qgrho, pgacw, pgacr, c (5), rho + integer :: it - gmlt = (c (1) * tc / rho - c (2) * dqs) * (c (3) * sqrt (qgrho) + & - c (4) * qgrho ** 0.6875 / rho ** 0.25) + c (5) * tc * (pgacw + pgacr) + tmin = table_ice - 160. + ap1 = 10. * dim (ta, tmin) + 1. + ap1 = min (2621., ap1) + it = ap1 + es = tablew (it) + (ap1 - it) * desw (it) + wqsat_moist = eps * es * (1. + zvir * qv) / pa -end function gmlt +end function wqsat_moist ! ======================================================================= -! initialization -! prepare saturation water vapor pressure tables +! compute the saturated specific humidity for table iii ! ======================================================================= -subroutine qsmith_init +real function qs1d_m (ta, qv, pa) implicit none - integer, parameter :: length = 2621 + real, intent (in) :: ta, pa, qv - integer :: i + real :: es, ap1, tmin - if (.not. tables_are_initialized) then + integer :: it - ! master = (mpp_pe () .eq. mpp_root_pe ()) - ! if (master) print *, ' gfdl mp: initializing qs tables' + tmin = table_ice - 160. + ap1 = 10. * dim (ta, tmin) + 1. + ap1 = min (2621., ap1) + it = ap1 + es = table2 (it) + (ap1 - it) * des2 (it) + qs1d_m = eps * es * (1. + zvir * qv) / pa - ! debug code - ! print *, mpp_pe (), allocated (table), allocated (table2), & - ! allocated (table3), allocated (tablew), allocated (des), & - ! allocated (des2), allocated (des3), allocated (desw) - ! end debug code +end function qs1d_m - ! generate es table (dt = 0.1 deg. c) +! ======================================================================= +! computes the difference in saturation vapor * density * between water and ice +! ======================================================================= - allocate (table (length)) - allocate (table2 (length)) - allocate (table3 (length)) - allocate (tablew (length)) - allocate (des (length)) - allocate (des2 (length)) - allocate (des3 (length)) - allocate (desw (length)) +real function d_sat (ta, den) - call qs_table (length) - call qs_table2 (length) - call qs_table3 (length) - call qs_tablew (length) + implicit none - do i = 1, length - 1 - des (i) = max (0., table (i + 1) - table (i)) - des2 (i) = max (0., table2 (i + 1) - table2 (i)) - des3 (i) = max (0., table3 (i + 1) - table3 (i)) - desw (i) = max (0., tablew (i + 1) - tablew (i)) - enddo - des (length) = des (length - 1) - des2 (length) = des2 (length - 1) - des3 (length) = des3 (length - 1) - desw (length) = desw (length - 1) + real, intent (in) :: ta, den - tables_are_initialized = .true. + real :: es_w, es_i, ap1, tmin - endif + integer :: it -end subroutine qsmith_init + tmin = table_ice - 160. + ap1 = 10. * dim (ta, tmin) + 1. + ap1 = min (2621., ap1) + it = ap1 + es_w = tablew (it) + (ap1 - it) * desw (it) + es_i = table2 (it) + (ap1 - it) * des2 (it) + d_sat = dim (es_w, es_i) / (rvgas * ta * den) ! take positive difference + +end function d_sat ! ======================================================================= -! compute the saturated specific humidity for table ii +! compute the saturated water vapor pressure for table ii ! ======================================================================= -real function wqs1 (ta, den) +real function esw_table (ta) implicit none - ! pure water phase; universal dry / moist formular using air density - ! input "den" can be either dry or moist air density - - real, intent (in) :: ta, den + real, intent (in) :: ta - real :: es, ap1, tmin + real :: ap1, tmin integer :: it @@ -3334,130 +4100,118 @@ real function wqs1 (ta, den) ap1 = 10. * dim (ta, tmin) + 1. ap1 = min (2621., ap1) it = ap1 - !NOTE: a crash here usually means NaN - !if (it < 1 .or. it > 2621) then - ! write(*,*), 'WQS1: table range violation', it, ta, tmin, den - !endif - es = tablew (it) + (ap1 - it) * desw (it) - wqs1 = es / (rvgas * ta * den) + esw_table = tablew (it) + (ap1 - it) * desw (it) -end function wqs1 +end function esw_table ! ======================================================================= -! compute the gradient of saturated specific humidity for table ii +! compute the saturated water vapor pressure for table iii ! ======================================================================= -real function wqs2 (ta, den, dqdt) +real function es2_table (ta) implicit none - ! pure water phase; universal dry / moist formular using air density - ! input "den" can be either dry or moist air density + real, intent (in) :: ta + + real :: ap1, tmin - real, intent (in) :: ta, den - real, intent (out) :: dqdt - real :: es, ap1, tmin integer :: it tmin = table_ice - 160. - - if (.not. tables_are_initialized) call qsmith_init - ap1 = 10. * dim (ta, tmin) + 1. ap1 = min (2621., ap1) it = ap1 - !NOTE: a crash here usually means NaN - !if (it < 1 .or. it > 2621) then - ! write(*,*), 'WQS2: table range violation', it, ta, tmin, den - !endif - es = tablew (it) + (ap1 - it) * desw (it) - wqs2 = es / (rvgas * ta * den) - it = ap1 - 0.5 - ! finite diff, del_t = 0.1: - dqdt = 10. * (desw (it) + (ap1 - it) * (desw (it + 1) - desw (it))) / (rvgas * ta * den) + es2_table = table2 (it) + (ap1 - it) * des2 (it) -end function wqs2 +end function es2_table ! ======================================================================= -! compute wet buld temperature +! compute the saturated water vapor pressure for table ii ! ======================================================================= -real function wet_bulb (q, t, den) +subroutine esw_table1d (ta, es, n) implicit none - real, intent (in) :: t, q, den + integer, intent (in) :: n - real :: qs, tp, dqdt + real, intent (in) :: ta (n) - wet_bulb = t - qs = wqs2 (wet_bulb, den, dqdt) - tp = 0.5 * (qs - q) / (1. + lcp * dqdt) * lcp - wet_bulb = wet_bulb - tp + real, intent (out) :: es (n) - ! tp is negative if super - saturated - if (tp > 0.01) then - qs = wqs2 (wet_bulb, den, dqdt) - tp = (qs - q) / (1. + lcp * dqdt) * lcp - wet_bulb = wet_bulb - tp - endif + real :: ap1, tmin -end function wet_bulb + integer :: i, it + + tmin = table_ice - 160. + + do i = 1, n + ap1 = 10. * dim (ta (i), tmin) + 1. + ap1 = min (2621., ap1) + it = ap1 + es (i) = tablew (it) + (ap1 - it) * desw (it) + enddo + +end subroutine esw_table1d ! ======================================================================= -! compute the saturated specific humidity for table iii +! compute the saturated water vapor pressure for table iii ! ======================================================================= -real function iqs1 (ta, den) +subroutine es2_table1d (ta, es, n) implicit none - ! water - ice phase; universal dry / moist formular using air density - ! input "den" can be either dry or moist air density + integer, intent (in) :: n - real, intent (in) :: ta, den + real, intent (in) :: ta (n) - real :: es, ap1, tmin + real, intent (out) :: es (n) - integer :: it + real :: ap1, tmin + + integer :: i, it tmin = table_ice - 160. - ap1 = 10. * dim (ta, tmin) + 1. - ap1 = min (2621., ap1) - it = ap1 - es = table2 (it) + (ap1 - it) * des2 (it) - iqs1 = es / (rvgas * ta * den) -end function iqs1 + do i = 1, n + ap1 = 10. * dim (ta (i), tmin) + 1. + ap1 = min (2621., ap1) + it = ap1 + es (i) = table2 (it) + (ap1 - it) * des2 (it) + enddo + +end subroutine es2_table1d ! ======================================================================= -! compute the gradient of saturated specific humidity for table iii +! compute the saturated water vapor pressure for table iv ! ======================================================================= -real function iqs2 (ta, den, dqdt) +subroutine es3_table1d (ta, es, n) implicit none - ! water - ice phase; universal dry / moist formular using air density - ! input "den" can be either dry or moist air density + integer, intent (in) :: n - real (kind = r_grid), intent (in) :: ta - real, intent (in) :: den - real, intent (out) :: dqdt - real (kind = r_grid) :: tmin, es, ap1 - integer :: it + real, intent (in) :: ta (n) + + real, intent (out) :: es (n) + + real :: ap1, tmin + + integer :: i, it tmin = table_ice - 160. - ap1 = 10. * dim (ta, tmin) + 1. - ap1 = min (2621., ap1) - it = ap1 - es = table2 (it) + (ap1 - it) * des2 (it) - iqs2 = es / (rvgas * ta * den) - it = ap1 - 0.5 - dqdt = 10. * (des2 (it) + (ap1 - it) * (des2 (it + 1) - des2 (it))) / (rvgas * ta * den) -end function iqs2 + do i = 1, n + ap1 = 10. * dim (ta (i), tmin) + 1. + ap1 = min (2621., ap1) + it = ap1 + es (i) = table3 (it) + (ap1 - it) * des3 (it) + enddo +end subroutine es3_table1d ! ======================================================================= ! saturation water vapor pressure table ii @@ -3603,6 +4357,29 @@ subroutine qs_table3 (n) end subroutine qs_table3 +! ======================================================================= +! compute the saturated specific humidity for table +! note: this routine is based on "moist" mixing ratio +! ======================================================================= + +real function qs_blend (t, p, q) + + implicit none + + real, intent (in) :: t, p, q + + real :: es, ap1, tmin + + integer :: it + + tmin = table_ice - 160. + ap1 = 10. * dim (t, tmin) + 1. + ap1 = min (2621., ap1) + it = ap1 + es = table (it) + (ap1 - it) * des (it) + qs_blend = eps * es * (1. + zvir * q) / p + +end function qs_blend ! ======================================================================= ! saturation water vapor pressure table i @@ -3666,13 +4443,65 @@ subroutine qs_table (n) end subroutine qs_table +! ======================================================================= +! compute the saturated specific humidity and the gradient of saturated specific humidity +! input t in deg k, p in pa; p = rho rdry tv, moist pressure +! ======================================================================= + +subroutine qsmith (im, km, ks, t, p, q, qs, dqdt) + + implicit none + + integer, intent (in) :: im, km, ks + + real, intent (in), dimension (im, km) :: t, p, q + + real, intent (out), dimension (im, km) :: qs + + real, intent (out), dimension (im, km), optional :: dqdt + + real :: eps10, ap1, tmin + + real, dimension (im, km) :: es + + integer :: i, k, it + + tmin = table_ice - 160. + eps10 = 10. * eps + + if (.not. tables_are_initialized) then + call qsmith_init + endif + + do k = ks, km + do i = 1, im + ap1 = 10. * dim (t (i, k), tmin) + 1. + ap1 = min (2621., ap1) + it = ap1 + es (i, k) = table (it) + (ap1 - it) * des (it) + qs (i, k) = eps * es (i, k) * (1. + zvir * q (i, k)) / p (i, k) + enddo + enddo + + if (present (dqdt)) then + do k = ks, km + do i = 1, im + ap1 = 10. * dim (t (i, k), tmin) + 1. + ap1 = min (2621., ap1) - 0.5 + it = ap1 + dqdt (i, k) = eps10 * (des (it) + (ap1 - it) * (des (it + 1) - des (it))) * (1. + zvir * q (i, k)) / p (i, k) + enddo + enddo + endif + +end subroutine qsmith ! ======================================================================= ! fix negative water species ! this is designed for 6 - class micro - physics schemes ! ======================================================================= -subroutine neg_adj (ks, ke, pt, dp, qv, ql, qr, qi, qs, qg) +subroutine neg_adj (ks, ke, pt, dp, qv, ql, qr, qi, qs, qg, cond) implicit none @@ -3680,6 +4509,7 @@ subroutine neg_adj (ks, ke, pt, dp, qv, ql, qr, qi, qs, qg) real, intent (in), dimension (ks:ke) :: dp real (kind = r_grid), intent (inout), dimension (ks:ke) :: pt real, intent (inout), dimension (ks:ke) :: qv, ql, qr, qi, qs, qg + real, intent (out) :: cond real, dimension (ks:ke) :: lcpk, icpk @@ -3697,6 +4527,8 @@ subroutine neg_adj (ks, ke, pt, dp, qv, ql, qr, qi, qs, qg) icpk (k) = (li00 + d1_ice * pt (k)) / cvm enddo + cond = 0 + do k = ks, ke ! ----------------------------------------------------------------------- @@ -3714,13 +4546,11 @@ subroutine neg_adj (ks, ke, pt, dp, qv, ql, qr, qi, qs, qg) qs (k) = 0. endif ! if graupel < 0, borrow from rain -#ifdef HIGH_NEG_HT if (qg (k) < 0.) then qr (k) = qr (k) + qg (k) pt (k) = pt (k) - qg (k) * icpk (k) ! heating qg (k) = 0. endif -#endif ! ----------------------------------------------------------------------- ! liquid phase: @@ -3731,55 +4561,37 @@ subroutine neg_adj (ks, ke, pt, dp, qv, ql, qr, qi, qs, qg) ql (k) = ql (k) + qr (k) qr (k) = 0. endif + ! if cloud water < 0, borrow from water vapor + if (ql (k) < 0.) then + cond = cond - ql (k) * dp (k) + qv (k) = qv (k) + ql (k) + pt (k) = pt (k) - ql (k) * lcpk (k) ! heating + ql (k) = 0. + endif enddo -end subroutine neg_adj + ! ----------------------------------------------------------------------- + ! fix water vapor; borrow from below + ! ----------------------------------------------------------------------- -! ======================================================================= -! compute global sum -! quick local sum algorithm -! ======================================================================= - -!real function g_sum (p, ifirst, ilast, jfirst, jlast, area, mode) -! -! use mpp_mod, only: mpp_sum -! -! implicit none -! -! integer, intent (in) :: ifirst, ilast, jfirst, jlast -! integer, intent (in) :: mode ! if == 1 divided by area -! -! real, intent (in), dimension (ifirst:ilast, jfirst:jlast) :: p, area -! -! integer :: i, j -! -! real :: gsum -! -! if (global_area < 0.) then -! global_area = 0. -! do j = jfirst, jlast -! do i = ifirst, ilast -! global_area = global_area + area (i, j) -! enddo -! enddo -! call mpp_sum (global_area) -! endif -! -! gsum = 0. -! do j = jfirst, jlast -! do i = ifirst, ilast -! gsum = gsum + p (i, j) * area (i, j) -! enddo -! enddo -! call mpp_sum (gsum) -! -! if (mode == 1) then -! g_sum = gsum / global_area -! else -! g_sum = gsum -! endif -! -!end function g_sum + do k = ks, ke - 1 + if (qv (k) < 0.) then + qv (k + 1) = qv (k + 1) + qv (k) * dp (k) / dp (k + 1) + qv (k) = 0. + endif + enddo + + ! ----------------------------------------------------------------------- + ! bottom layer; borrow from above + ! ----------------------------------------------------------------------- + + if (qv (ke) < 0. .and. qv (ke - 1) > 0.) then + dq = min (- qv (ke) * dp (ke), qv (ke - 1) * dp (ke - 1)) + qv (ke - 1) = qv (ke - 1) - dq / dp (ke - 1) + qv (ke) = qv (ke) + dq / dp (ke) + endif + +end subroutine neg_adj end module gfdl_mp_mod diff --git a/model/nh_core.F90 b/model/nh_core.F90 index 9dcd7a302..00055a928 100644 --- a/model/nh_core.F90 +++ b/model/nh_core.F90 @@ -10,7 +10,7 @@ !* (at your option) any later version. !* !* The FV3 dynamical core is distributed in the hope that it will be -!* useful, but WITHOUT ANYWARRANTY; without even the implied warranty +!* useful, but WITHOUT ANY WARRANTY; without even the implied warranty !* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. !* See the GNU General Public License for more details. !* @@ -18,6 +18,7 @@ !* License along with the FV3 dynamical core. !* If not, see . !*********************************************************************** + module nh_core_mod ! Developer: S.-J. Lin, NOAA/GFDL ! To do list: diff --git a/model/nh_utils.F90 b/model/nh_utils.F90 index 0921b1a02..adea41188 100644 --- a/model/nh_utils.F90 +++ b/model/nh_utils.F90 @@ -10,7 +10,7 @@ !* (at your option) any later version. !* !* The FV3 dynamical core is distributed in the hope that it will be -!* useful, but WITHOUT ANYWARRANTY; without even the implied warranty +!* useful, but WITHOUT ANY WARRANTY; without even the implied warranty !* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. !* See the GNU General Public License for more details. !* @@ -18,6 +18,7 @@ !* License along with the FV3 dynamical core. !* If not, see . !*********************************************************************** + module nh_utils_mod ! Developer: S.-J. Lin, NOAA/GFDL ! To do list: @@ -34,9 +35,13 @@ module nh_utils_mod public update_dz_c, update_dz_d, nh_bc public sim_solver, sim1_solver, sim3_solver public sim3p0_solver, rim_2d - public Riem_Solver_c + public Riem_Solver_c, edge_scalar +#ifdef DZ_MIN_6 + real, parameter:: dz_min = 6. +#else real, parameter:: dz_min = 2. +#endif real, parameter:: r3 = 1./3. CONTAINS @@ -173,6 +178,11 @@ subroutine update_dz_c(is, ie, js, je, km, ng, dt, dp0, zs, area, ut, vt, gz, ws enddo do k=km, 1, -1 do i=is1, ie1 +#ifdef DZ_MIN_6 + if (gz(i,j,k) < gz(i,j,k+1) + dz_min) then + write(*,'(A, 3I4, 2F)') 'UPDATE_DZ_C: dz limiter applied', i, j, k, gz(i,j,k), gz(i,j,k+1) + endif +#endif gz(i,j,k) = max( gz(i,j,k), gz(i,j,k+1) + dz_min ) enddo enddo @@ -288,6 +298,11 @@ subroutine update_dz_d(ndif, damp, hord, is, ie, js, je, km, ng, npx, npy, area, do k=km, 1, -1 do i=is, ie ! Enforce monotonicity of height to prevent blowup +#ifdef DZ_MIN_6 + if (zh(i,j,k) < zh(i,j,k+1) + dz_min) then + write(*,'(A, 3I4, 2F)') 'UPDATE_DZ_D: dz limiter applied', i, j, k, zh(i,j,k), zh(i,j,k+1) + endif +#endif zh(i,j,k) = max( zh(i,j,k), zh(i,j,k+1) + dz_min ) enddo enddo @@ -1625,7 +1640,6 @@ subroutine edge_profile(q1, q2, q1e, q2e, i1, i2, j1, j2, j, km, dp0, uniform_gr end subroutine edge_profile -!TODO LMH 25may18: do not need delz defined on full compute domain; pass appropriate BCs instead subroutine nh_bc(ptop, grav, kappa, cp, delp, delzBC, pt, phis, & #ifdef USE_COND q_con, & diff --git a/model/sw_core.F90 b/model/sw_core.F90 index d69708975..69f0c02e1 100644 --- a/model/sw_core.F90 +++ b/model/sw_core.F90 @@ -10,7 +10,7 @@ !* (at your option) any later version. !* !* The FV3 dynamical core is distributed in the hope that it will be -!* useful, but WITHOUT ANYWARRANTY; without even the implied warranty +!* useful, but WITHOUT ANY WARRANTY; without even the implied warranty !* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. !* See the GNU General Public License for more details. !* @@ -18,7 +18,8 @@ !* License along with the FV3 dynamical core. !* If not, see . !*********************************************************************** - module sw_core_mod + +module sw_core_mod use tp_core_mod, only: fv_tp_2d, pert_ppm, copy_corners use fv_mp_mod, only: fill_corners, XDir, YDir @@ -492,7 +493,7 @@ end subroutine c_sw subroutine d_sw(delpc, delp, ptc, pt, u, v, w, uc,vc, & ua, va, divg_d, xflux, yflux, cx, cy, & crx_adv, cry_adv, xfx_adv, yfx_adv, q_con, z_rat, kgb, heat_source, & - zvir, sphum, nq, q, k, km, inline_q, & + diss_est, zvir, sphum, nq, q, k, km, inline_q, & dt, hord_tr, hord_mt, hord_vt, hord_tm, hord_dp, nord, & nord_v, nord_w, nord_t, dddmp, d2_bg, d4_bg, damp_v, damp_w, & damp_t, d_con, hydrostatic, gridstruct, flagstruct, bd) @@ -516,6 +517,7 @@ subroutine d_sw(delpc, delp, ptc, pt, u, v, w, uc,vc, & real, intent(INOUT):: q(bd%isd:bd%ied,bd%jsd:bd%jed,km,nq) real, intent(OUT), dimension(bd%isd:bd%ied, bd%jsd:bd%jed) :: delpc, ptc real, intent(OUT), dimension(bd%is:bd%ie,bd%js:bd%je):: heat_source + real, intent(OUT), dimension(bd%is:bd%ie,bd%js:bd%je):: diss_est ! The flux capacitors: real, intent(INOUT):: xflux(bd%is:bd%ie+1,bd%js:bd%je ) real, intent(INOUT):: yflux(bd%is:bd%ie ,bd%js:bd%je+1) @@ -934,6 +936,7 @@ subroutine d_sw(delpc, delp, ptc, pt, u, v, w, uc,vc, & do j=js,je do i=is,ie heat_source(i,j) = 0. + diss_est(i,j) = 0. enddo enddo @@ -948,6 +951,9 @@ subroutine d_sw(delpc, delp, ptc, pt, u, v, w, uc,vc, & ! 0.5 * [ (w+dw)**2 - w**2 ] = w*dw + 0.5*dw*dw ! heat_source(i,j) = -d_con*dw(i,j)*(w(i,j)+0.5*dw(i,j)) heat_source(i,j) = dd8 - dw(i,j)*(w(i,j)+0.5*dw(i,j)) + if ( flagstruct%do_diss_est ) then + diss_est(i,j) = heat_source(i,j) + endif enddo enddo endif @@ -977,12 +983,15 @@ subroutine d_sw(delpc, delp, ptc, pt, u, v, w, uc,vc, & ! enddo ! enddo ! endif +#if defined(GFS_PHYS) || defined(DCMIP) call fv_tp_2d(pt, crx_adv,cry_adv, npx, npy, hord_tm, gx, gy, & xfx_adv,yfx_adv, gridstruct, bd, ra_x, ra_y, flagstruct%lim_fac, & -! This is a difference from the publicly released version in github master -! and is provided to ensure reproducibility with AM4/CM4 models from GFDL -! mfx=fx, mfy=fy, mass=delp, nord=nord_v, damp_c=damp_v) - mfx=fx, mfy=fy, mass=delp, nord=nord_t, damp_c=damp_t) + mfx=fx, mfy=fy, mass=delp, nord=nord_v, damp_c=damp_v) !SHiELD +#else + call fv_tp_2d(pt, crx_adv,cry_adv, npx, npy, hord_tm, gx, gy, & + xfx_adv,yfx_adv, gridstruct, bd, ra_x, ra_y, flagstruct%lim_fac, & + mfx=fx, mfy=fy, mass=delp, nord=nord_t, damp_c=damp_t) !AM4 +#endif #endif if ( inline_q ) then @@ -1483,7 +1492,7 @@ subroutine d_sw(delpc, delp, ptc, pt, u, v, w, uc,vc, & call del6_vt_flux(nord_v, npx, npy, damp4, wk, vort, ut, vt, gridstruct, bd) endif - if ( d_con > 1.e-5 ) then + if ( d_con > 1.e-5 .or. flagstruct%do_diss_est ) then do j=js,je+1 do i=is,ie ub(i,j) = (ub(i,j) + vt(i,j))*rdx(i,j) @@ -1514,6 +1523,12 @@ subroutine d_sw(delpc, delp, ptc, pt, u, v, w, uc,vc, & (ub(i,j)**2 + ub(i,j+1)**2 + vb(i,j)**2 + vb(i+1,j)**2) & + 2.*(gy(i,j)+gy(i,j+1)+gx(i,j)+gx(i+1,j)) & - cosa_s(i,j)*(u2*dv2 + v2*du2 + du2*dv2)) ) + if (flagstruct%do_diss_est) then + diss_est(i,j) = diss_est(i,j)-rsin2(i,j)*( & + (ub(i,j)**2 + ub(i,j+1)**2 + vb(i,j)**2 + vb(i+1,j)**2) & + + 2.*(gy(i,j)+gy(i,j+1)+gx(i,j)+gx(i+1,j)) & + - cosa_s(i,j)*(u2*dv2 + v2*du2 + du2*dv2)) + endif enddo enddo endif @@ -1546,6 +1561,8 @@ subroutine del6_vt_flux(nord, npx, npy, damp, q, d2, fx2, fy2, gridstruct, bd) ! nord = 1: del-4 ! nord = 2: del-6 !------------------ +!This does the same operation as tp_core::deln_flux except that it does not +!add diffusive fluxes into the regular fluxes integer, intent(in):: nord, npx, npy real, intent(in):: damp type(fv_grid_bounds_type), intent(IN) :: bd diff --git a/model/tp_core.F90 b/model/tp_core.F90 index a8e83caa6..89d2b14e8 100644 --- a/model/tp_core.F90 +++ b/model/tp_core.F90 @@ -10,7 +10,7 @@ !* (at your option) any later version. !* !* The FV3 dynamical core is distributed in the hope that it will be -!* useful, but WITHOUT ANYWARRANTY; without even the implied warranty +!* useful, but WITHOUT ANY WARRANTY; without even the implied warranty !* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. !* See the GNU General Public License for more details. !* @@ -18,6 +18,7 @@ !* License along with the FV3 dynamical core. !* If not, see . !*********************************************************************** + module tp_core_mod !BOP ! diff --git a/tools/coarse_grained_diagnostics.F90 b/tools/coarse_grained_diagnostics.F90 index 8f910abdd..55e4393b6 100644 --- a/tools/coarse_grained_diagnostics.F90 +++ b/tools/coarse_grained_diagnostics.F90 @@ -1,17 +1,40 @@ +!*********************************************************************** +!* GNU Lesser General Public License +!* +!* This file is part of the FV3 dynamical core. +!* +!* The FV3 dynamical core is free software: you can redistribute it +!* and/or modify it under the terms of the +!* GNU Lesser General Public License as published by the +!* Free Software Foundation, either version 3 of the License, or +!* (at your option) any later version. +!* +!* The FV3 dynamical core is distributed in the hope that it will be +!* useful, but WITHOUT ANY WARRANTY; without even the implied warranty +!* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. +!* See the GNU General Public License for more details. +!* +!* You should have received a copy of the GNU Lesser General Public +!* License along with the FV3 dynamical core. +!* If not, see . +!*********************************************************************** + module coarse_grained_diagnostics_mod use constants_mod, only: rdgas, grav, pi=>pi_8 use diag_manager_mod, only: diag_axis_init, register_diag_field, register_static_field, send_data use field_manager_mod, only: MODEL_ATMOS use fv_arrays_mod, only: fv_atmos_type, fv_coarse_graining_type - use fv_diagnostics_mod, only: cs3_interpolator, get_height_given_pressure + use fv_diagnostics_mod, only: cs3_interpolator, get_height_given_pressure, get_vorticity, interpolate_vertical use fv_mapz_mod, only: moist_cp, moist_cv use mpp_domains_mod, only: domain2d, EAST, NORTH use mpp_mod, only: FATAL, mpp_error use coarse_graining_mod, only: block_sum, get_fine_array_bounds, get_coarse_array_bounds, MODEL_LEVEL, & weighted_block_average, PRESSURE_LEVEL, vertically_remap_field, & vertical_remapping_requirements, mask_area_weights, mask_mass_weights, & - block_edge_sum_x, block_edge_sum_y + block_edge_sum_x, block_edge_sum_y,& + eddy_covariance_2d_weights, eddy_covariance_3d_weights + use time_manager_mod, only: time_type use tracer_manager_mod, only: get_tracer_index, get_tracer_names @@ -36,19 +59,20 @@ module coarse_grained_diagnostics_mod logical :: always_model_level_coarse_grain = .false. integer :: pressure_level = -1 ! If greater than 0, interpolate to this pressure level (in hPa) integer :: iv = 0 ! Controls type of pressure-level interpolation performed (-1, 0, or 1) - character(len=64) :: special_case ! E.g. height is computed differently on pressure surfaces + character(len=64) :: special_case = '' ! E.g. height is computed differently on pressure surfaces type(data_subtype) :: data end type coarse_diag_type public :: fv_coarse_diag_init, fv_coarse_diag integer :: tile_count = 1 ! Following fv_diagnostics.F90 - integer :: DIAG_SIZE = 512 - type(coarse_diag_type), dimension(512) :: coarse_diagnostics + integer :: DIAG_SIZE = 1024 + type(coarse_diag_type), dimension(1024) :: coarse_diagnostics ! Reduction methods character(len=11) :: AREA_WEIGHTED = 'area_weighted' character(len=11) :: MASS_WEIGHTED = 'mass_weighted' + character(len=15) :: EDDY_COVARIANCE = 'eddy_covariance' character(len=5) :: pressure_level_label contains @@ -59,6 +83,7 @@ subroutine populate_coarse_diag_type(Atm, coarse_diagnostics) integer :: is, ie, js, je, npz, n_tracers, n_prognostic, t, p, n_pressure_levels integer :: index = 1 + integer :: sphum, liq_wat, ice_wat, rainwat, snowwat, graupel character(len=128) :: tracer_name character(len=256) :: tracer_long_name, tracer_units character(len=8) :: DYNAMICS = 'dynamics' @@ -69,6 +94,12 @@ subroutine populate_coarse_diag_type(Atm, coarse_diagnostics) npz = Atm(tile_count)%npz n_prognostic = size(Atm(tile_count)%q, 4) n_tracers = Atm(tile_count)%ncnst + sphum = get_tracer_index (MODEL_ATMOS, 'sphum') + liq_wat = get_tracer_index (MODEL_ATMOS, 'liq_wat') + ice_wat = get_tracer_index (MODEL_ATMOS, 'ice_wat') + rainwat = get_tracer_index (MODEL_ATMOS, 'rainwat') + snowwat = get_tracer_index (MODEL_ATMOS, 'snowwat') + graupel = get_tracer_index (MODEL_ATMOS, 'graupel') call get_fine_array_bounds(is, ie, js, je) coarse_diagnostics(index)%axes = 3 @@ -164,6 +195,69 @@ subroutine populate_coarse_diag_type(Atm, coarse_diagnostics) ! Defer pointer association for these diagnostics in case their arrays have ! not been allocated yet. + index = index + 1 + coarse_diagnostics(index)%axes = 3 + coarse_diagnostics(index)%module_name = DYNAMICS + coarse_diagnostics(index)%name = 'vertical_eddy_flux_of_temperature_coarse' + coarse_diagnostics(index)%description = 'vertical eddy flux of temperature' + coarse_diagnostics(index)%units = 'K Pa/s' + coarse_diagnostics(index)%reduction_method = EDDY_COVARIANCE + coarse_diagnostics(index)%data%var3 => Atm(tile_count)%pt(is:ie,js:je,1:npz) + + index = index + 1 + coarse_diagnostics(index)%axes = 3 + coarse_diagnostics(index)%module_name = DYNAMICS + coarse_diagnostics(index)%name = 'vertical_eddy_flux_of_specific_humidity_coarse' + coarse_diagnostics(index)%description = 'vertical eddy flux of specific humidity' + coarse_diagnostics(index)%units = 'kg/kg Pa/s' + coarse_diagnostics(index)%reduction_method = EDDY_COVARIANCE + coarse_diagnostics(index)%data%var3 => Atm(tile_count)%q(is:ie,js:je,1:npz,sphum) + + index = index + 1 + coarse_diagnostics(index)%axes = 3 + coarse_diagnostics(index)%module_name = DYNAMICS + coarse_diagnostics(index)%name = 'vertical_eddy_flux_of_liquid_water_coarse' + coarse_diagnostics(index)%description = 'vertical eddy flux of liquid water' + coarse_diagnostics(index)%units = 'kg/kg Pa/s' + coarse_diagnostics(index)%reduction_method = EDDY_COVARIANCE + coarse_diagnostics(index)%data%var3 => Atm(tile_count)%q(is:ie,js:je,1:npz,liq_wat) + + index = index + 1 + coarse_diagnostics(index)%axes = 3 + coarse_diagnostics(index)%module_name = DYNAMICS + coarse_diagnostics(index)%name = 'vertical_eddy_flux_of_ice_water_coarse' + coarse_diagnostics(index)%description = 'vertical eddy flux of ice water' + coarse_diagnostics(index)%units = 'kg/kg Pa/s' + coarse_diagnostics(index)%reduction_method = EDDY_COVARIANCE + coarse_diagnostics(index)%data%var3 => Atm(tile_count)%q(is:ie,js:je,1:npz,ice_wat) + + index = index + 1 + coarse_diagnostics(index)%axes = 3 + coarse_diagnostics(index)%module_name = DYNAMICS + coarse_diagnostics(index)%name = 'vertical_eddy_flux_of_rain_water_coarse' + coarse_diagnostics(index)%description = 'vertical eddy flux of rain water' + coarse_diagnostics(index)%units = 'kg/kg Pa/s' + coarse_diagnostics(index)%reduction_method = EDDY_COVARIANCE + coarse_diagnostics(index)%data%var3 => Atm(tile_count)%q(is:ie,js:je,1:npz,rainwat) + + index = index + 1 + coarse_diagnostics(index)%axes = 3 + coarse_diagnostics(index)%module_name = DYNAMICS + coarse_diagnostics(index)%name = 'vertical_eddy_flux_of_snow_water_coarse' + coarse_diagnostics(index)%description = 'vertical eddy flux of snow water' + coarse_diagnostics(index)%units = 'kg/kg Pa/s' + coarse_diagnostics(index)%reduction_method = EDDY_COVARIANCE + coarse_diagnostics(index)%data%var3 => Atm(tile_count)%q(is:ie,js:je,1:npz,snowwat) + + index = index + 1 + coarse_diagnostics(index)%axes = 3 + coarse_diagnostics(index)%module_name = DYNAMICS + coarse_diagnostics(index)%name = 'vertical_eddy_flux_of_graupel_water_coarse' + coarse_diagnostics(index)%description = 'vertical eddy flux of graupel water' + coarse_diagnostics(index)%units = 'kg/kg Pa/s' + coarse_diagnostics(index)%reduction_method = EDDY_COVARIANCE + coarse_diagnostics(index)%data%var3 => Atm(tile_count)%q(is:ie,js:je,1:npz,graupel) + index = index + 1 coarse_diagnostics(index)%axes = 3 coarse_diagnostics(index)%module_name = DYNAMICS @@ -293,6 +387,126 @@ subroutine populate_coarse_diag_type(Atm, coarse_diagnostics) coarse_diagnostics(index)%units = 'm/s/s' coarse_diagnostics(index)%reduction_method = MASS_WEIGHTED + index = index + 1 + coarse_diagnostics(index)%axes = 3 + coarse_diagnostics(index)%module_name = DYNAMICS + coarse_diagnostics(index)%name = 'qv_dt_gfdlmp_coarse' + coarse_diagnostics(index)%description = 'coarse-grained specific humidity tendency from GFDL MP' + coarse_diagnostics(index)%units = 'kg/kg/s' + coarse_diagnostics(index)%reduction_method = MASS_WEIGHTED + + index = index + 1 + coarse_diagnostics(index)%axes = 3 + coarse_diagnostics(index)%module_name = DYNAMICS + coarse_diagnostics(index)%name = 'ql_dt_gfdlmp_coarse' + coarse_diagnostics(index)%description = 'coarse-grained total liquid water tendency from GFDL MP' + coarse_diagnostics(index)%units = 'kg/kg/s' + coarse_diagnostics(index)%reduction_method = MASS_WEIGHTED + + index = index + 1 + coarse_diagnostics(index)%axes = 3 + coarse_diagnostics(index)%module_name = DYNAMICS + coarse_diagnostics(index)%name = 'qi_dt_gfdlmp_coarse' + coarse_diagnostics(index)%description = 'coarse-grained total ice water tendency from GFDL MP' + coarse_diagnostics(index)%units = 'kg/kg/s' + coarse_diagnostics(index)%reduction_method = MASS_WEIGHTED + + index = index + 1 + coarse_diagnostics(index)%axes = 3 + coarse_diagnostics(index)%module_name = DYNAMICS + coarse_diagnostics(index)%name = 'liq_wat_dt_gfdlmp_coarse' + coarse_diagnostics(index)%description = 'coarse-grained liquid water tendency from GFDL MP' + coarse_diagnostics(index)%units = 'kg/kg/s' + coarse_diagnostics(index)%reduction_method = MASS_WEIGHTED + + index = index + 1 + coarse_diagnostics(index)%axes = 3 + coarse_diagnostics(index)%module_name = DYNAMICS + coarse_diagnostics(index)%name = 'ice_wat_dt_gfdlmp_coarse' + coarse_diagnostics(index)%description = 'coarse-grained ice water tendency from GFDL MP' + coarse_diagnostics(index)%units = 'kg/kg/s' + coarse_diagnostics(index)%reduction_method = MASS_WEIGHTED + + index = index + 1 + coarse_diagnostics(index)%axes = 3 + coarse_diagnostics(index)%module_name = DYNAMICS + coarse_diagnostics(index)%name = 'qr_dt_gfdlmp_coarse' + coarse_diagnostics(index)%description = 'coarse-grained rain water tendency from GFDL MP' + coarse_diagnostics(index)%units = 'kg/kg/s' + coarse_diagnostics(index)%reduction_method = MASS_WEIGHTED + + index = index + 1 + coarse_diagnostics(index)%axes = 3 + coarse_diagnostics(index)%module_name = DYNAMICS + coarse_diagnostics(index)%name = 'qs_dt_gfdlmp_coarse' + coarse_diagnostics(index)%description = 'coarse-grained snow water tendency from GFDL MP' + coarse_diagnostics(index)%units = 'kg/kg/s' + coarse_diagnostics(index)%reduction_method = MASS_WEIGHTED + + index = index + 1 + coarse_diagnostics(index)%axes = 3 + coarse_diagnostics(index)%module_name = DYNAMICS + coarse_diagnostics(index)%name = 'qg_dt_gfdlmp_coarse' + coarse_diagnostics(index)%description = 'coarse-grained graupel water tendency from GFDL MP' + coarse_diagnostics(index)%units = 'kg/kg/s' + coarse_diagnostics(index)%reduction_method = MASS_WEIGHTED + + index = index + 1 + coarse_diagnostics(index)%axes = 3 + coarse_diagnostics(index)%module_name = DYNAMICS + coarse_diagnostics(index)%name = 't_dt_gfdlmp_coarse' + coarse_diagnostics(index)%description = 'coarse-grained temperature tendency from GFDL MP' + coarse_diagnostics(index)%units = 'K/s' + coarse_diagnostics(index)%reduction_method = MASS_WEIGHTED + + index = index + 1 + coarse_diagnostics(index)%axes = 3 + coarse_diagnostics(index)%module_name = DYNAMICS + coarse_diagnostics(index)%name = 'u_dt_gfdlmp_coarse' + coarse_diagnostics(index)%description = 'coarse-grained zonal wind tendency from GFDL MP' + coarse_diagnostics(index)%units = 'm/s/s' + coarse_diagnostics(index)%reduction_method = MASS_WEIGHTED + + index = index + 1 + coarse_diagnostics(index)%axes = 3 + coarse_diagnostics(index)%module_name = DYNAMICS + coarse_diagnostics(index)%name = 'v_dt_gfdlmp_coarse' + coarse_diagnostics(index)%description = 'coarse-grained meridional wind tendency from GFDL MP' + coarse_diagnostics(index)%units = 'm/s/s' + coarse_diagnostics(index)%reduction_method = MASS_WEIGHTED + + index = index + 1 + coarse_diagnostics(index)%axes = 3 + coarse_diagnostics(index)%module_name = DYNAMICS + coarse_diagnostics(index)%name = 't_dt_sg_coarse' + coarse_diagnostics(index)%description = 'coarse-grained temperature tendency from 2dz filter' + coarse_diagnostics(index)%units = 'K/s' + coarse_diagnostics(index)%reduction_method = MASS_WEIGHTED + + index = index + 1 + coarse_diagnostics(index)%axes = 3 + coarse_diagnostics(index)%module_name = DYNAMICS + coarse_diagnostics(index)%name = 'u_dt_sg_coarse' + coarse_diagnostics(index)%description = 'coarse-grained zonal wind tendency from 2dz filter' + coarse_diagnostics(index)%units = 'm/s**2' + coarse_diagnostics(index)%reduction_method = MASS_WEIGHTED + + index = index + 1 + coarse_diagnostics(index)%axes = 3 + coarse_diagnostics(index)%module_name = DYNAMICS + coarse_diagnostics(index)%name = 'v_dt_sg_coarse' + coarse_diagnostics(index)%description = 'coarse-grained meridional wind tendency from 2dz filter' + coarse_diagnostics(index)%units = 'm/s**2' + coarse_diagnostics(index)%reduction_method = MASS_WEIGHTED + + index = index + 1 + coarse_diagnostics(index)%axes = 3 + coarse_diagnostics(index)%module_name = DYNAMICS + coarse_diagnostics(index)%name = 'qv_dt_sg_coarse' + coarse_diagnostics(index)%description = 'coarse-grained specific humidity tendency from 2dz filter' + coarse_diagnostics(index)%units = 'kg/kg/s' + coarse_diagnostics(index)%reduction_method = MASS_WEIGHTED + ! Vertically integrated diagnostics index = index + 1 coarse_diagnostics(index)%axes = 2 @@ -420,6 +634,159 @@ subroutine populate_coarse_diag_type(Atm, coarse_diagnostics) coarse_diagnostics(index)%vertically_integrated = .true. coarse_diagnostics(index)%reduction_method = AREA_WEIGHTED + index = index + 1 + coarse_diagnostics(index)%axes = 2 + coarse_diagnostics(index)%module_name = DYNAMICS + coarse_diagnostics(index)%name = 'int_qv_dt_gfdlmp_coarse' + coarse_diagnostics(index)%description = 'coarse-grained vertically integrated water vapor specific humidity tendency from GFDL MP' + coarse_diagnostics(index)%units = 'kg/m**2/s' + coarse_diagnostics(index)%vertically_integrated = .true. + coarse_diagnostics(index)%reduction_method = AREA_WEIGHTED + + index = index + 1 + coarse_diagnostics(index)%axes = 2 + coarse_diagnostics(index)%module_name = DYNAMICS + coarse_diagnostics(index)%name = 'int_ql_dt_gfdlmp_coarse' + coarse_diagnostics(index)%description = 'coarse-grained vertically integrated total liquid water tendency from GFDL MP' + coarse_diagnostics(index)%units = 'kg/m**2/s' + coarse_diagnostics(index)%vertically_integrated = .true. + coarse_diagnostics(index)%reduction_method = AREA_WEIGHTED + + index = index + 1 + coarse_diagnostics(index)%axes = 2 + coarse_diagnostics(index)%module_name = DYNAMICS + coarse_diagnostics(index)%name = 'int_qi_dt_gfdlmp_coarse' + coarse_diagnostics(index)%description = 'coarse-grained vertically integrated total ice water tendency from GFDL MP' + coarse_diagnostics(index)%units = 'kg/m**2/s' + coarse_diagnostics(index)%vertically_integrated = .true. + coarse_diagnostics(index)%reduction_method = AREA_WEIGHTED + + index = index + 1 + coarse_diagnostics(index)%axes = 2 + coarse_diagnostics(index)%module_name = DYNAMICS + coarse_diagnostics(index)%name = 'int_liq_wat_dt_gfdlmp_coarse' + coarse_diagnostics(index)%description = 'coarse-grained vertically integrated liquid water tracer tendency from GFDL MP' + coarse_diagnostics(index)%units = 'kg/m**2/s' + coarse_diagnostics(index)%vertically_integrated = .true. + coarse_diagnostics(index)%reduction_method = AREA_WEIGHTED + + index = index + 1 + coarse_diagnostics(index)%axes = 2 + coarse_diagnostics(index)%module_name = DYNAMICS + coarse_diagnostics(index)%name = 'int_ice_wat_dt_gfdlmp_coarse' + coarse_diagnostics(index)%description = 'coarse-grained vertically integrated ice water tracer tendency from GFDL MP' + coarse_diagnostics(index)%units = 'kg/m**2/s' + coarse_diagnostics(index)%vertically_integrated = .true. + coarse_diagnostics(index)%reduction_method = AREA_WEIGHTED + + index = index + 1 + coarse_diagnostics(index)%axes = 2 + coarse_diagnostics(index)%module_name = DYNAMICS + coarse_diagnostics(index)%name = 'int_qr_dt_gfdlmp_coarse' + coarse_diagnostics(index)%description = 'coarse-grained vertically integrated rain water tracer tendency from GFDL MP' + coarse_diagnostics(index)%units = 'kg/m**2/s' + coarse_diagnostics(index)%vertically_integrated = .true. + coarse_diagnostics(index)%reduction_method = AREA_WEIGHTED + + index = index + 1 + coarse_diagnostics(index)%axes = 2 + coarse_diagnostics(index)%module_name = DYNAMICS + coarse_diagnostics(index)%name = 'int_qs_dt_gfdlmp_coarse' + coarse_diagnostics(index)%description = 'coarse-grained vertically integrated snow water tracer tendency from GFDL MP' + coarse_diagnostics(index)%units = 'kg/m**2/s' + coarse_diagnostics(index)%vertically_integrated = .true. + coarse_diagnostics(index)%reduction_method = AREA_WEIGHTED + + index = index + 1 + coarse_diagnostics(index)%axes = 2 + coarse_diagnostics(index)%module_name = DYNAMICS + coarse_diagnostics(index)%name = 'int_qg_dt_gfdlmp_coarse' + coarse_diagnostics(index)%description = 'coarse-grained vertically integrated graupel tracer tendency from GFDL MP' + coarse_diagnostics(index)%units = 'kg/m**2/s' + coarse_diagnostics(index)%vertically_integrated = .true. + coarse_diagnostics(index)%reduction_method = AREA_WEIGHTED + + index = index + 1 + coarse_diagnostics(index)%axes = 2 + coarse_diagnostics(index)%module_name = DYNAMICS + coarse_diagnostics(index)%name = 'int_t_dt_gfdlmp_coarse' + coarse_diagnostics(index)%description = 'coarse-grained vertically integrated temperature tendency from GFDL MP' + coarse_diagnostics(index)%units = 'W/m**2' + coarse_diagnostics(index)%scaled_by_specific_heat_and_vertically_integrated = .true. + coarse_diagnostics(index)%reduction_method = AREA_WEIGHTED + + index = index + 1 + coarse_diagnostics(index)%axes = 2 + coarse_diagnostics(index)%module_name = DYNAMICS + coarse_diagnostics(index)%name = 'int_u_dt_gfdlmp_coarse' + coarse_diagnostics(index)%description = 'coarse-grained vertically integrated zonal wind tendency from GFDL MP' + coarse_diagnostics(index)%units = 'kg/m s/s' + coarse_diagnostics(index)%vertically_integrated = .true. + coarse_diagnostics(index)%reduction_method = AREA_WEIGHTED + + index = index + 1 + coarse_diagnostics(index)%axes = 2 + coarse_diagnostics(index)%module_name = DYNAMICS + coarse_diagnostics(index)%name = 'int_v_dt_gfdlmp_coarse' + coarse_diagnostics(index)%description = 'coarse-grained vertically integrated meridional wind tendency from GFDL MP' + coarse_diagnostics(index)%units = 'kg/m s/s' + coarse_diagnostics(index)%vertically_integrated = .true. + coarse_diagnostics(index)%reduction_method = AREA_WEIGHTED + + index = index + 1 + coarse_diagnostics(index)%axes = 2 + coarse_diagnostics(index)%module_name = DYNAMICS + coarse_diagnostics(index)%name = 'tq_coarse' + coarse_diagnostics(index)%description = 'coarse-grained total water path' + coarse_diagnostics(index)%units = 'kg/m**2' + coarse_diagnostics(index)%special_case = 'tq' + coarse_diagnostics(index)%reduction_method = AREA_WEIGHTED + + index = index + 1 + coarse_diagnostics(index)%axes = 2 + coarse_diagnostics(index)%module_name = DYNAMICS + coarse_diagnostics(index)%name = 'lw_coarse' + coarse_diagnostics(index)%description = 'coarse-grained liquid water path' + coarse_diagnostics(index)%units = 'kg/m**2' + coarse_diagnostics(index)%special_case = 'lw' + coarse_diagnostics(index)%reduction_method = AREA_WEIGHTED + + index = index + 1 + coarse_diagnostics(index)%axes = 2 + coarse_diagnostics(index)%module_name = DYNAMICS + coarse_diagnostics(index)%name = 'iw_coarse' + coarse_diagnostics(index)%description = 'coarse-grained ice water path' + coarse_diagnostics(index)%units = 'kg/m**2' + coarse_diagnostics(index)%special_case = 'iw' + coarse_diagnostics(index)%reduction_method = AREA_WEIGHTED + + index = index + 1 + coarse_diagnostics(index)%axes = 2 + coarse_diagnostics(index)%module_name = DYNAMICS + coarse_diagnostics(index)%name = 'tb_coarse' + coarse_diagnostics(index)%description = 'coarse temperature in lowest model level' + coarse_diagnostics(index)%units = 'K' + coarse_diagnostics(index)%reduction_method = AREA_WEIGHTED + coarse_diagnostics(index)%data%var2 => Atm(tile_count)%pt(is:ie,js:je,npz) + + index = index + 1 + coarse_diagnostics(index)%axes = 2 + coarse_diagnostics(index)%module_name = DYNAMICS + coarse_diagnostics(index)%name = 'us_coarse' + coarse_diagnostics(index)%description = 'coarse zonal wind in lowest model level' + coarse_diagnostics(index)%units = 'm/s' + coarse_diagnostics(index)%reduction_method = AREA_WEIGHTED + coarse_diagnostics(index)%data%var2 => Atm(tile_count)%ua(is:ie,js:je,npz) + + index = index + 1 + coarse_diagnostics(index)%axes = 2 + coarse_diagnostics(index)%module_name = DYNAMICS + coarse_diagnostics(index)%name = 'vs_coarse' + coarse_diagnostics(index)%description = 'coarse meridional wind in lowest model level' + coarse_diagnostics(index)%units = 'm/s' + coarse_diagnostics(index)%reduction_method = AREA_WEIGHTED + coarse_diagnostics(index)%data%var2 => Atm(tile_count)%va(is:ie,js:je,npz) + ! iv =-1: winds ! iv = 0: positive definite scalars ! iv = 1: temperature @@ -482,6 +849,16 @@ subroutine populate_coarse_diag_type(Atm, coarse_diagnostics) coarse_diagnostics(index)%reduction_method = AREA_WEIGHTED coarse_diagnostics(index)%special_case = 'height' + index = index + 1 + coarse_diagnostics(index)%pressure_level = pressure_levels(p) + coarse_diagnostics(index)%axes = 2 + coarse_diagnostics(index)%module_name = DYNAMICS + coarse_diagnostics(index)%name = 'vort' // trim(adjustl(pressure_level_label)) // '_coarse' + coarse_diagnostics(index)%description = 'coarse-grained ' // trim(adjustl(pressure_level_label)) // '-mb vorticity' + coarse_diagnostics(index)%units = '1/s' + coarse_diagnostics(index)%reduction_method = AREA_WEIGHTED + coarse_diagnostics(index)%special_case = 'vorticity' + do t = 1, n_tracers call get_tracer_names(MODEL_ATMOS, t, tracer_name, tracer_long_name, tracer_units) index = index + 1 @@ -559,9 +936,13 @@ subroutine maybe_allocate_reference_array(Atm, coarse_diagnostic) type(fv_atmos_type), target, intent(inout) :: Atm(:) type(coarse_diag_type), intent(inout) :: coarse_diagnostic - integer :: is, ie, js, je, npz + integer :: is, ie, js, je, npz, isd, ied, jsd, jed call get_fine_array_bounds(is, ie, js, je) + isd = Atm(tile_count)%bd%isd + ied = Atm(tile_count)%bd%ied + jsd = Atm(tile_count)%bd%jsd + jed = Atm(tile_count)%bd%jed npz = Atm(tile_count)%npz ! It would be really nice if there were a cleaner way to do this; @@ -653,6 +1034,97 @@ subroutine maybe_allocate_reference_array(Atm, coarse_diagnostic) Atm(tile_count)%nudge_diag%nudge_v_dt(is:ie,js:je,1:npz) = 0.0 endif coarse_diagnostic%data%var3 => Atm(tile_count)%nudge_diag%nudge_v_dt(is:ie,js:je,1:npz) + elseif (ends_with(coarse_diagnostic%name, 'qv_dt_gfdlmp_coarse')) then + if (.not. allocated(Atm(tile_count)%inline_mp%qv_dt)) then + allocate(Atm(tile_count)%inline_mp%qv_dt(is:ie,js:je,1:npz)) + Atm(tile_count)%inline_mp%qv_dt(is:ie,js:je,1:npz) = 0.0 + endif + coarse_diagnostic%data%var3 => Atm(tile_count)%inline_mp%qv_dt(is:ie,js:je,1:npz) + elseif (ends_with(coarse_diagnostic%name, 'ql_dt_gfdlmp_coarse')) then + if (.not. allocated(Atm(tile_count)%inline_mp%ql_dt)) then + allocate(Atm(tile_count)%inline_mp%ql_dt(is:ie,js:je,1:npz)) + Atm(tile_count)%inline_mp%ql_dt(is:ie,js:je,1:npz) = 0.0 + endif + coarse_diagnostic%data%var3 => Atm(tile_count)%inline_mp%ql_dt(is:ie,js:je,1:npz) + elseif (ends_with(coarse_diagnostic%name, 'qi_dt_gfdlmp_coarse')) then + if (.not. allocated(Atm(tile_count)%inline_mp%qi_dt)) then + allocate(Atm(tile_count)%inline_mp%qi_dt(is:ie,js:je,1:npz)) + Atm(tile_count)%inline_mp%qi_dt(is:ie,js:je,1:npz) = 0.0 + endif + coarse_diagnostic%data%var3 => Atm(tile_count)%inline_mp%qi_dt(is:ie,js:je,1:npz) + elseif (ends_with(coarse_diagnostic%name, 'liq_wat_dt_gfdlmp_coarse')) then + if (.not. allocated(Atm(tile_count)%inline_mp%liq_wat_dt)) then + allocate(Atm(tile_count)%inline_mp%liq_wat_dt(is:ie,js:je,1:npz)) + Atm(tile_count)%inline_mp%liq_wat_dt(is:ie,js:je,1:npz) = 0.0 + endif + coarse_diagnostic%data%var3 => Atm(tile_count)%inline_mp%liq_wat_dt(is:ie,js:je,1:npz) + elseif (ends_with(coarse_diagnostic%name, 'ice_wat_dt_gfdlmp_coarse')) then + if (.not. allocated(Atm(tile_count)%inline_mp%ice_wat_dt)) then + allocate(Atm(tile_count)%inline_mp%ice_wat_dt(is:ie,js:je,1:npz)) + Atm(tile_count)%inline_mp%ice_wat_dt(is:ie,js:je,1:npz) = 0.0 + endif + coarse_diagnostic%data%var3 => Atm(tile_count)%inline_mp%ice_wat_dt(is:ie,js:je,1:npz) + elseif (ends_with(coarse_diagnostic%name, 'qr_dt_gfdlmp_coarse')) then + if (.not. allocated(Atm(tile_count)%inline_mp%qr_dt)) then + allocate(Atm(tile_count)%inline_mp%qr_dt(is:ie,js:je,1:npz)) + Atm(tile_count)%inline_mp%qr_dt(is:ie,js:je,1:npz) = 0.0 + endif + coarse_diagnostic%data%var3 => Atm(tile_count)%inline_mp%qr_dt(is:ie,js:je,1:npz) + elseif (ends_with(coarse_diagnostic%name, 'qs_dt_gfdlmp_coarse')) then + if (.not. allocated(Atm(tile_count)%inline_mp%qs_dt)) then + allocate(Atm(tile_count)%inline_mp%qs_dt(is:ie,js:je,1:npz)) + Atm(tile_count)%inline_mp%qs_dt(is:ie,js:je,1:npz) = 0.0 + endif + coarse_diagnostic%data%var3 => Atm(tile_count)%inline_mp%qs_dt(is:ie,js:je,1:npz) + elseif (ends_with(coarse_diagnostic%name, 'qg_dt_gfdlmp_coarse')) then + if (.not. allocated(Atm(tile_count)%inline_mp%qg_dt)) then + allocate(Atm(tile_count)%inline_mp%qg_dt(is:ie,js:je,1:npz)) + Atm(tile_count)%inline_mp%qg_dt(is:ie,js:je,1:npz) = 0.0 + endif + coarse_diagnostic%data%var3 => Atm(tile_count)%inline_mp%qg_dt(is:ie,js:je,1:npz) + elseif (ends_with(coarse_diagnostic%name, 't_dt_gfdlmp_coarse')) then + if (.not. allocated(Atm(tile_count)%inline_mp%t_dt)) then + allocate(Atm(tile_count)%inline_mp%t_dt(is:ie,js:je,1:npz)) + Atm(tile_count)%inline_mp%t_dt(is:ie,js:je,1:npz) = 0.0 + endif + coarse_diagnostic%data%var3 => Atm(tile_count)%inline_mp%t_dt(is:ie,js:je,1:npz) + elseif (ends_with(coarse_diagnostic%name, 'u_dt_gfdlmp_coarse')) then + if (.not. allocated(Atm(tile_count)%inline_mp%u_dt)) then + allocate(Atm(tile_count)%inline_mp%u_dt(is:ie,js:je,1:npz)) + Atm(tile_count)%inline_mp%u_dt(is:ie,js:je,1:npz) = 0.0 + endif + coarse_diagnostic%data%var3 => Atm(tile_count)%inline_mp%u_dt(is:ie,js:je,1:npz) + elseif (ends_with(coarse_diagnostic%name, 'v_dt_gfdlmp_coarse')) then + if (.not. allocated(Atm(tile_count)%inline_mp%v_dt)) then + allocate(Atm(tile_count)%inline_mp%v_dt(is:ie,js:je,1:npz)) + Atm(tile_count)%inline_mp%v_dt(is:ie,js:je,1:npz) = 0.0 + endif + coarse_diagnostic%data%var3 => Atm(tile_count)%inline_mp%v_dt(is:ie,js:je,1:npz) + elseif (coarse_diagnostic%name .eq. 't_dt_sg_coarse') then + if (.not. allocated(Atm(tile_count)%sg_diag%t_dt)) then + allocate(Atm(tile_count)%sg_diag%t_dt(is:ie,js:je,1:npz)) + Atm(tile_count)%sg_diag%t_dt(is:ie,js:je,1:npz) = 0.0 + endif + coarse_diagnostic%data%var3 => Atm(tile_count)%sg_diag%t_dt(is:ie,js:je,1:npz) + elseif (coarse_diagnostic%name .eq. 'u_dt_sg_coarse') then + if (.not. allocated(Atm(tile_count)%sg_diag%u_dt)) then + allocate(Atm(tile_count)%sg_diag%u_dt(is:ie,js:je,1:npz)) + Atm(tile_count)%sg_diag%u_dt(is:ie,js:je,1:npz) = 0.0 + endif + coarse_diagnostic%data%var3 => Atm(tile_count)%sg_diag%u_dt(is:ie,js:je,1:npz) + ! Note: don't use ends_with here, because qv_dt_sg_coarse also ends with v_dt_sg_coarse. + elseif (coarse_diagnostic%name .eq. 'v_dt_sg_coarse') then + if (.not. allocated(Atm(tile_count)%sg_diag%v_dt)) then + allocate(Atm(tile_count)%sg_diag%v_dt(is:ie,js:je,1:npz)) + Atm(tile_count)%sg_diag%v_dt(is:ie,js:je,1:npz) = 0.0 + endif + coarse_diagnostic%data%var3 => Atm(tile_count)%sg_diag%v_dt(is:ie,js:je,1:npz) + elseif (coarse_diagnostic%name .eq. 'qv_dt_sg_coarse') then + if (.not. allocated(Atm(tile_count)%sg_diag%qv_dt)) then + allocate(Atm(tile_count)%sg_diag%qv_dt(is:ie,js:je,1:npz)) + Atm(tile_count)%sg_diag%qv_dt(is:ie,js:je,1:npz) = 0.0 + endif + coarse_diagnostic%data%var3 => Atm(tile_count)%sg_diag%qv_dt(is:ie,js:je,1:npz) endif endif end subroutine maybe_allocate_reference_array @@ -714,16 +1186,21 @@ subroutine initialize_coarse_diagnostic_axes(coarse_domain, & Domain2=coarse_domain, tile_count=tile_count, domain_position=NORTH) end subroutine initialize_coarse_diagnostic_axes - subroutine fv_coarse_diag(Atm, Time) + subroutine fv_coarse_diag(Atm, Time, zvir) type(fv_atmos_type), intent(in), target :: Atm(:) type(time_type), intent(in) :: Time + real, intent(in) :: zvir real, allocatable :: work_2d(:,:), work_2d_coarse(:,:), work_3d_coarse(:,:,:) real, allocatable :: mass(:,:,:), height_on_interfaces(:,:,:), masked_area(:,:,:) real, allocatable :: phalf(:,:,:), upsampled_coarse_phalf(:,:,:) + real, allocatable, target :: vorticity(:,:,:) + real, allocatable :: zsurf(:,:) integer :: is, ie, js, je, is_coarse, ie_coarse, js_coarse, je_coarse, npz + integer :: isd, ied, jsd, jed logical :: used logical :: need_2d_work_array, need_3d_work_array, need_mass_array, need_height_array, need_masked_area_array + logical :: need_vorticity_array integer :: index, i, j character(len=256) :: error_message @@ -731,6 +1208,7 @@ subroutine fv_coarse_diag(Atm, Time) call get_need_nd_work_array(3, need_3d_work_array) call get_need_mass_array(need_mass_array) call get_need_height_array(need_height_array) + call get_need_vorticity_array(need_vorticity_array) if (trim(Atm(tile_count)%coarse_graining%strategy) .eq. PRESSURE_LEVEL) then call get_need_masked_area_array(need_masked_area_array) @@ -741,6 +1219,10 @@ subroutine fv_coarse_diag(Atm, Time) call get_fine_array_bounds(is, ie, js, je) call get_coarse_array_bounds(is_coarse, ie_coarse, js_coarse, je_coarse) npz = Atm(tile_count)%npz + isd = Atm(tile_count)%bd%isd + ied = Atm(tile_count)%bd%ied + jsd = Atm(tile_count)%bd%jsd + jed = Atm(tile_count)%bd%jed if (need_2d_work_array) then allocate(work_2d_coarse(is_coarse:ie_coarse,js_coarse:je_coarse)) @@ -786,32 +1268,29 @@ subroutine fv_coarse_diag(Atm, Time) if (need_height_array) then allocate(height_on_interfaces(is:ie,js:je,1:npz+1)) - if(Atm(tile_count)%flagstruct%hydrostatic) then - call compute_height_on_interfaces_hydrostatic( & - is, & - ie, & - js, & - je, & - npz, & - Atm(tile_count)%pt(is:ie,js:je,1:npz), & - Atm(tile_count)%peln(is:ie,1:npz+1,js:je), & - height_on_interfaces(is:ie,js:je,1:npz) & - ) - else - call compute_height_on_interfaces_nonhydrostatic( & - is, & - ie, & - js, & - je, & - npz, & - Atm(tile_count)%delz(is:ie,js:je,1:npz), & - height_on_interfaces(is:ie,js:je,1:npz) & - ) - endif + allocate(zsurf(is:ie,js:je)) + zsurf = Atm(tile_count)%phis(is:ie,js:je) / grav + call get_height_field(is, ie, js, je, Atm(tile_count)%ng, npz, & + Atm(tile_count)%flagstruct%hydrostatic, & + zsurf, & + Atm(tile_count)%delz, & + height_on_interfaces, & + Atm(tile_count)%pt, & + Atm(tile_count)%q, & + Atm(tile_count)%peln, & + zvir & + ) if (.not. allocated(work_2d_coarse)) allocate(work_2d_coarse(is_coarse:ie_coarse,js_coarse:je_coarse)) allocate(work_2d(is:ie,js:je)) endif + if (need_vorticity_array) then + allocate(vorticity(is:ie,js:je,1:npz)) + call get_vorticity(is, ie, js, je, isd, ied, jsd, jed, npz, Atm(tile_count)%u, Atm(tile_count)%v, vorticity, & + Atm(tile_count)%gridstruct%dx, Atm(tile_count)%gridstruct%dy, Atm(tile_count)%gridstruct%rarea) + call associate_vorticity_pointers(is, ie, js, je, npz, vorticity) + endif + do index = 1, DIAG_SIZE if (coarse_diagnostics(index)%id .gt. 0) then if (coarse_diagnostics(index)%axes .eq. 2) then @@ -821,12 +1300,16 @@ subroutine fv_coarse_diag(Atm, Time) elseif (coarse_diagnostics(index)%axes .eq. 3) then if (trim(Atm(tile_count)%coarse_graining%strategy) .eq. MODEL_LEVEL .or. coarse_diagnostics(index)%always_model_level_coarse_grain) then call coarse_grain_3D_field_on_model_levels(is, ie, js, je, is_coarse, ie_coarse, js_coarse, je_coarse, npz, & - coarse_diagnostics(index), Atm(tile_count)%gridstruct%area(is:ie,js:je),& - mass, work_3d_coarse) + coarse_diagnostics(index), Atm(tile_count)%gridstruct%area(is:ie,js:je),& + mass, & + Atm(tile_count)%omga(is:ie,js:je,1:npz), & + work_3d_coarse) else if (trim(Atm(tile_count)%coarse_graining%strategy) .eq. PRESSURE_LEVEL) then call coarse_grain_3D_field_on_pressure_levels(is, ie, js, je, is_coarse, ie_coarse, js_coarse, je_coarse, npz, & - coarse_diagnostics(index), masked_area, mass, phalf, & - upsampled_coarse_phalf, Atm(tile_count)%ptop, work_3d_coarse) + coarse_diagnostics(index), masked_area, mass, phalf, & + upsampled_coarse_phalf, Atm(tile_count)%ptop, & + Atm(tile_count)%omga(is:ie,js:je,1:npz),& + work_3d_coarse) else write(error_message, *) 'fv_coarse_diag: invalid coarse-graining strategy provided for 3D variables, ' // & trim(Atm(tile_count)%coarse_graining%strategy) @@ -839,10 +1322,11 @@ subroutine fv_coarse_diag(Atm, Time) end subroutine fv_coarse_diag subroutine coarse_grain_3D_field_on_model_levels(is, ie, js, je, is_coarse, ie_coarse, js_coarse, je_coarse, & - npz, coarse_diag, area, mass, result) + npz, coarse_diag, area, mass, omega, result) integer, intent(in) :: is, ie, js, je, is_coarse, ie_coarse, js_coarse, je_coarse, npz type(coarse_diag_type) :: coarse_diag real, intent(in) :: mass(is:ie,js:je,1:npz), area(is:ie,js:je) + real, intent(in) :: omega(is:ie,js:je,1:npz) real, intent(out) :: result(is_coarse:ie_coarse,js_coarse:je_coarse,1:npz) character(len=256) :: error_message @@ -859,6 +1343,13 @@ subroutine coarse_grain_3D_field_on_model_levels(is, ie, js, je, is_coarse, ie_c coarse_diag%data%var3, & result & ) + elseif (trim(coarse_diag%reduction_method) .eq. EDDY_COVARIANCE) then + call eddy_covariance_2d_weights( & + area(is:ie,js:je), & + omega(is:ie,js:je,1:npz), & + coarse_diag%data%var3, & + result & + ) else write(error_message, *) 'coarse_grain_3D_field_on_model_levels: invalid reduction_method, ' // & trim(coarse_diag%reduction_method) // ', provided for 3D variable, ' // & @@ -868,26 +1359,36 @@ subroutine coarse_grain_3D_field_on_model_levels(is, ie, js, je, is_coarse, ie_c end subroutine coarse_grain_3D_field_on_model_levels subroutine coarse_grain_3D_field_on_pressure_levels(is, ie, js, je, is_coarse, ie_coarse, js_coarse, je_coarse, & - npz, coarse_diag, masked_area, masked_mass, phalf, upsampled_coarse_phalf, & - ptop, result) + npz, coarse_diag, masked_area, masked_mass, phalf, upsampled_coarse_phalf, & + ptop, omega, result) integer, intent(in) :: is, ie, js, je, is_coarse, ie_coarse, js_coarse, je_coarse, npz type(coarse_diag_type) :: coarse_diag real, intent(in) :: masked_mass(is:ie,js:je,1:npz), masked_area(is:ie,js:je,1:npz) real, intent(in) :: phalf(is:ie,js:je,1:npz+1), upsampled_coarse_phalf(is:ie,js:je,1:npz+1) real, intent(in) :: ptop + real, intent(in) :: omega(is:ie,js:je,1:npz) real, intent(out) :: result(is_coarse:ie_coarse,js_coarse:je_coarse,1:npz) - real, allocatable :: remapped_field(:,:,:) + real, allocatable, dimension(:,:,:) :: remapped_field, remapped_omega character(len=256) :: error_message allocate(remapped_field(is:ie,js:je,1:npz)) - call vertically_remap_field( & phalf, & coarse_diag%data%var3, & upsampled_coarse_phalf, & ptop, & remapped_field) + if (trim(coarse_diag%reduction_method) .eq. EDDY_COVARIANCE) then + allocate(remapped_omega(is:ie,js:je,1:npz)) + call vertically_remap_field( & + phalf, & + omega, & + upsampled_coarse_phalf, & + ptop, & + remapped_omega) + endif + if (trim(coarse_diag%reduction_method) .eq. AREA_WEIGHTED) then call weighted_block_average( & masked_area(is:ie,js:je,1:npz), & @@ -900,6 +1401,13 @@ subroutine coarse_grain_3D_field_on_pressure_levels(is, ie, js, je, is_coarse, i remapped_field(is:ie,js:je,1:npz), & result & ) + elseif (trim(coarse_diag%reduction_method) .eq. EDDY_COVARIANCE) then + call eddy_covariance_3d_weights( & + masked_area(is:ie,js:je,1:npz), & + remapped_omega(is:ie,js:je,1:npz), & + remapped_field(is:ie,js:je,1:npz), & + result & + ) else write(error_message, *) 'coarse_grain_3D_field_on_pressure_levels: invalid reduction_method, ' // & trim(coarse_diag%reduction_method) // ', provided for 3D variable, ' // & @@ -916,18 +1424,23 @@ subroutine coarse_grain_2D_field(is, ie, js, je, npz, is_coarse, ie_coarse, js_c real, intent(in) :: height_on_interfaces(is:ie,js:je,1:npz+1) real, intent(out) :: result(is_coarse:ie_coarse,js_coarse:je_coarse) + integer :: nwat character(len=256) :: error_message real, allocatable :: work_2d(:,:) + nwat = Atm%flagstruct%nwat + if (coarse_diag%pressure_level > 0 .or. coarse_diag%vertically_integrated & - .or. coarse_diag%scaled_by_specific_heat_and_vertically_integrated) then + .or. coarse_diag%scaled_by_specific_heat_and_vertically_integrated & + .or. coarse_diag%special_case .ne. '') then allocate(work_2d(is:ie,js:je)) endif if (trim(coarse_diag%reduction_method) .eq. AREA_WEIGHTED) then if (coarse_diag%pressure_level < 0 & .and. .not. coarse_diag%vertically_integrated & - .and. .not. coarse_diag%scaled_by_specific_heat_and_vertically_integrated) then + .and. .not. coarse_diag%scaled_by_specific_heat_and_vertically_integrated & + .and. coarse_diag%special_case .eq. '') then call weighted_block_average( & Atm%gridstruct%area(is:ie,js:je), & coarse_diag%data%var2, & @@ -950,7 +1463,75 @@ subroutine coarse_grain_2D_field(is, ie, js, je, npz, is_coarse, ie_coarse, js_c work_2d, & result & ) - elseif (coarse_diag%vertically_integrated) then + elseif (trim(coarse_diag%special_case) .eq. 'vorticity') then + call interpolate_vertical( & + is, & + ie, & + js, & + je, & + npz, & + 100.0 * coarse_diag%pressure_level, & ! Convert mb to Pa + Atm%peln(is:ie,1:npz+1,js:je), & + coarse_diag%data%var3, & + work_2d(is:ie,js:je) & + ) + call weighted_block_average( & + Atm%gridstruct%area(is:ie,js:je), & + work_2d, & + result & + ) + elseif (trim(coarse_diag%special_case) .eq. 'tq') then + call total_water_path( & + is, & + ie, & + js, & + je, & + npz, & + nwat, & + Atm%q(is:ie,js:je,1:npz,1:nwat), & + Atm%delp(is:ie,js:je,1:npz), & + work_2d(is:ie,js:je) & + ) + call weighted_block_average( & + Atm%gridstruct%area(is:ie,js:je), & + work_2d, & + result & + ) + elseif (trim(coarse_diag%special_case) .eq. 'lw') then + call liquid_water_path( & + is, & + ie, & + js, & + je, & + npz, & + nwat, & + Atm%q(is:ie,js:je,1:npz,1:nwat), & + Atm%delp(is:ie,js:je,1:npz), & + work_2d(is:ie,js:je) & + ) + call weighted_block_average( & + Atm%gridstruct%area(is:ie,js:je), & + work_2d, & + result & + ) + elseif (trim(coarse_diag%special_case) .eq. 'iw') then + call ice_water_path( & + is, & + ie, & + js, & + je, & + npz, & + nwat, & + Atm%q(is:ie,js:je,1:npz,1:nwat), & + Atm%delp(is:ie,js:je,1:npz), & + work_2d(is:ie,js:je) & + ) + call weighted_block_average( & + Atm%gridstruct%area(is:ie,js:je), & + work_2d, & + result & + ) + elseif (coarse_diag%vertically_integrated) then call vertically_integrate( & is, & ie, & @@ -1057,22 +1638,53 @@ subroutine get_need_height_array(need_height_array) enddo end subroutine get_need_height_array + subroutine get_need_vorticity_array(need_vorticity_array) + logical, intent(out) :: need_vorticity_array + + integer :: index + + need_vorticity_array = .false. + do index = 1, DIAG_SIZE + if (trim(coarse_diagnostics(index)%special_case) .eq. 'vorticity' .and. & + coarse_diagnostics(index)%id .gt. 0) then + need_vorticity_array = .true. + exit + endif + enddo + end subroutine get_need_vorticity_array + subroutine get_need_masked_area_array(need_masked_area_array) logical, intent(out) :: need_masked_area_array + logical :: valid_axes, valid_reduction_method, valid_id integer :: index need_masked_area_array = .false. do index = 1, DIAG_SIZE - if ((coarse_diagnostics(index)%axes == 3) .and. & - (trim(coarse_diagnostics(index)%reduction_method) .eq. AREA_WEIGHTED) .and. & - (coarse_diagnostics(index)%id > 0)) then - need_masked_area_array = .true. - exit - endif + valid_reduction_method = & + trim(coarse_diagnostics(index)%reduction_method) .eq. AREA_WEIGHTED .or. & + trim(coarse_diagnostics(index)%reduction_method) .eq. EDDY_COVARIANCE + valid_axes = coarse_diagnostics(index)%axes .eq. 3 + valid_id = coarse_diagnostics(index)%id .gt. 0 + need_masked_area_array = valid_reduction_method .and. valid_axes .and. valid_id + if (need_masked_area_array) exit enddo end subroutine get_need_masked_area_array + subroutine associate_vorticity_pointers(is, ie, js, je, npz, vorticity) + integer, intent(in) :: is, ie, js, je, npz + real, target, intent(in) :: vorticity(is:ie,js:je,1:npz) + + integer :: index + + do index = 1, DIAG_SIZE + if (trim(coarse_diagnostics(index)%special_case) .eq. 'vorticity' .and. & + coarse_diagnostics(index)%id .gt. 0) then + coarse_diagnostics(index)%data%var3 => vorticity(is:ie,js:je,1:npz) + endif + enddo + end subroutine associate_vorticity_pointers + subroutine compute_mass(Atm, is, ie, js, je, npz, mass) type(fv_atmos_type), intent(in) :: Atm integer, intent(in) :: is, ie, js, je, npz @@ -1103,43 +1715,6 @@ subroutine interpolate_to_pressure_level(is, ie, js, je, npz, field, height, pha result = work(is:ie,js:je,1) end subroutine interpolate_to_pressure_level - subroutine compute_height_on_interfaces_hydrostatic(is, ie, js, je, npz, temperature, phalf, height) - integer, intent(in) :: is, ie, js, je, npz - real, intent(in) :: temperature(is:ie,js:je,1:npz), phalf(is:ie,1:npz+1,js:je) - real, intent(out) :: height(is:ie,js:je,1:npz+1) - - integer :: i, j, k - real :: rgrav - - rgrav = 1.0 / grav - - do j = js, je - do i = is, ie - height(i,j,npz+1) = 0.0 - do k = npz, 1, -1 - height(i,j,k) = height(i,j,k+1) - (rdgas / grav) * temperature(i,j,k) * (phalf(i,k,j) - phalf(i,k+1,j)) - enddo - enddo - enddo - end subroutine compute_height_on_interfaces_hydrostatic - - subroutine compute_height_on_interfaces_nonhydrostatic(is, ie, js, je, npz, delz, height) - integer, intent(in) :: is, ie, js, je, npz - real, intent(in) :: delz(is:ie,js:je,1:npz) - real, intent(out) :: height(is:ie,js:je,1:npz+1) - - integer :: i, j, k - - do j = js, je - do i = is, ie - height(i,j,npz+1) = 0.0 - do k = npz, 1, -1 - height(i,j,k) = height(i,j,k+1) - delz(i,j,k) - enddo - enddo - enddo - end subroutine compute_height_on_interfaces_nonhydrostatic - subroutine height_given_pressure_level(is, ie, js, je, npz, height, phalf, pressure_level, result) integer, intent(in) :: is, ie, js, je, npz, pressure_level real, intent(in) :: height(is:ie,js:je,1:npz+1), phalf(is:ie,1:npz+1,js:je) @@ -1158,7 +1733,7 @@ subroutine height_given_pressure_level(is, ie, js, je, npz, height, phalf, press end subroutine height_given_pressure_level function starts_with(string, prefix) - character(len=64), intent(in) :: string, prefix + character(len=128), intent(in) :: string, prefix logical :: starts_with starts_with = string(1:len(trim(prefix))) .eq. trim(prefix) @@ -1166,7 +1741,7 @@ function starts_with(string, prefix) end function starts_with function ends_with(string, suffix) - character(len=64), intent(in) :: string + character(len=128), intent(in) :: string character(len=*), intent(in) :: suffix logical :: ends_with @@ -1362,4 +1937,100 @@ subroutine compute_grid_coarse(is, ie, js, je, is_coarse, ie_coarse, & factor = Atm(tile_count)%coarse_graining%factor grid_coarse = Atm(tile_count)%gridstruct%grid(is:ie+1:factor,js:je+1:factor,:) end subroutine compute_grid_coarse + + subroutine get_height_field(is, ie, js, je, ng, km, hydrostatic, zsurf, delz, wz, pt, q, peln, zvir) + integer, intent(in):: is, ie, js, je, km, ng + real, intent(in):: peln(is:ie,km+1,js:je) + real, intent(in):: pt(is-ng:ie+ng,js-ng:je+ng,km) + real, intent(in):: q(is-ng:ie+ng,js-ng:je+ng,km,*) ! water vapor + real, intent(in):: delz(is:,js:,1:) + real, intent(in):: zvir + logical, intent(in):: hydrostatic + real, intent(in) :: zsurf(is:ie,js:je) + real, intent(out):: wz(is:ie,js:je,km+1) +! + integer i,j,k, sphum + real gg + + sphum = get_tracer_index (MODEL_ATMOS, 'sphum') + gg = rdgas / grav + + do j=js,je + do i=is,ie + wz(i,j,km+1) = zsurf(i,j) + enddo + if (hydrostatic ) then + do k=km,1,-1 + do i=is,ie + wz(i,j,k) = wz(i,j,k+1) + gg*pt(i,j,k)*(1.+zvir*q(i,j,k,sphum)) & + *(peln(i,k+1,j)-peln(i,k,j)) + enddo + enddo + else + do k=km,1,-1 + do i=is,ie + wz(i,j,k) = wz(i,j,k+1) - delz(i,j,k) + enddo + enddo + endif + enddo + + end subroutine get_height_field + + subroutine total_water_path(is, ie, js, je, npz, nwat, q, delp, tq) + integer, intent(in) :: is, ie, js, je, npz, nwat + real, intent(in) :: q(is:ie,js:je,1:npz,1:nwat), delp(is:ie,js:je,1:npz) + real, intent(out) :: tq(is:ie,js:je) + + real :: ginv + + ginv = 1. / GRAV + tq = ginv * sum(sum(q, 4) * delp, 3) + end subroutine total_water_path + + subroutine liquid_water_path(is, ie, js, je, npz, nwat, q, delp, lw) + integer, intent(in) :: is, ie, js, je, npz, nwat + real, intent(in) :: q(is:ie,js:je,1:npz,1:nwat), delp(is:ie,js:je,1:npz) + real, intent(out) :: lw(is:ie,js:je) + + integer :: liq_wat, rainwat + real :: ginv + + liq_wat = get_tracer_index (MODEL_ATMOS, 'liq_wat') + rainwat = get_tracer_index (MODEL_ATMOS, 'rainwat') + + ginv = 1. / GRAV + lw = 0.0 + if (liq_wat .gt. 0) then + lw = lw + ginv * sum(q(is:ie,js:je,1:npz,liq_wat) * delp(is:ie,js:je,1:npz), 3) + endif + if (rainwat .gt. 0) then + lw = lw + ginv * sum(q(is:ie,js:je,1:npz,rainwat) * delp(is:ie,js:je,1:npz), 3) + endif + end subroutine liquid_water_path + + subroutine ice_water_path(is, ie, js, je, npz, nwat, q, delp, iw) + integer, intent(in) :: is, ie, js, je, npz, nwat + real, intent(in) :: q(is:ie,js:je,1:npz,1:nwat), delp(is:ie,js:je,1:npz) + real, intent(out) :: iw(is:ie,js:je) + + integer :: ice_wat, snowwat, graupel + real :: ginv + + ice_wat = get_tracer_index (MODEL_ATMOS, 'ice_wat') + snowwat = get_tracer_index (MODEL_ATMOS, 'snowwat') + graupel = get_tracer_index (MODEL_ATMOS, 'graupel') + + ginv = 1. / GRAV + iw = 0.0 + if (ice_wat .gt. 0) then + iw = iw + ginv * sum(q(is:ie,js:je,1:npz,ice_wat) * delp(is:ie,js:je,1:npz), 3) + endif + if (snowwat .gt. 0) then + iw = iw + ginv * sum(q(is:ie,js:je,1:npz,snowwat) * delp(is:ie,js:je,1:npz), 3) + endif + if (graupel .gt. 0) then + iw = iw + ginv * sum(q(is:ie,js:je,1:npz,graupel) * delp(is:ie,js:je,1:npz), 3) + endif + end subroutine ice_water_path end module coarse_grained_diagnostics_mod diff --git a/tools/coarse_grained_restart_files.F90 b/tools/coarse_grained_restart_files.F90 index ce6297752..15d3ed51b 100644 --- a/tools/coarse_grained_restart_files.F90 +++ b/tools/coarse_grained_restart_files.F90 @@ -1,3 +1,24 @@ +!*********************************************************************** +!* GNU Lesser General Public License +!* +!* This file is part of the FV3 dynamical core. +!* +!* The FV3 dynamical core is free software: you can redistribute it +!* and/or modify it under the terms of the +!* GNU Lesser General Public License as published by the +!* Free Software Foundation, either version 3 of the License, or +!* (at your option) any later version. +!* +!* The FV3 dynamical core is distributed in the hope that it will be +!* useful, but WITHOUT ANY WARRANTY; without even the implied warranty +!* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. +!* See the GNU General Public License for more details. +!* +!* You should have received a copy of the GNU Lesser General Public +!* License along with the FV3 dynamical core. +!* If not, see . +!*********************************************************************** + module coarse_grained_restart_files_mod use coarse_graining_mod, only: compute_mass_weights, get_coarse_array_bounds,& @@ -7,7 +28,7 @@ module coarse_grained_restart_files_mod remap_edges_along_y, vertically_remap_field use constants_mod, only: GRAV, RDGAS, RVGAS use field_manager_mod, only: MODEL_ATMOS - use fms2_io_mod, only: register_restart_field, write_restart, open_file, close_file + use fms2_io_mod, only: register_restart_field, write_restart, open_file, close_file, register_variable_attribute, variable_exists use fv_arrays_mod, only: coarse_restart_type, fv_atmos_type use mpp_domains_mod, only: domain2d, EAST, NORTH, CENTER, mpp_update_domains use mpp_mod, only: FATAL, mpp_error @@ -210,34 +231,78 @@ subroutine register_fv_core_coarse(hydrostatic, hybrid_z, & if (write_coarse_dgrid_vel_rst) then call register_restart_field(restart%fv_core_coarse, & 'u', restart%u, dim_names_4d) + call register_variable_attribute(restart%fv_core_coarse, & + 'u', "long_name", "u", str_len=len("u")) + call register_variable_attribute(restart%fv_core_coarse, & + 'u', "units", "none", str_len=len("none")) call register_restart_field(restart%fv_core_coarse, & 'v', restart%v, dim_names_4d2) + call register_variable_attribute(restart%fv_core_coarse, & + 'v', "long_name", "v", str_len=len("v")) + call register_variable_attribute(restart%fv_core_coarse, & + 'v', "units", "none", str_len=len("none")) endif if (write_coarse_agrid_vel_rst) then call register_restart_field(restart%fv_core_coarse, & 'ua', restart%ua, dim_names_4d3) + call register_variable_attribute(restart%fv_core_coarse, & + 'ua', "long_name", "ua", str_len=len("ua")) + call register_variable_attribute(restart%fv_core_coarse, & + 'ua', "units", "none", str_len=len("none")) call register_restart_field(restart%fv_core_coarse, & 'va', restart%va, dim_names_4d3) + call register_variable_attribute(restart%fv_core_coarse, & + 'va', "long_name", "va", str_len=len("va")) + call register_variable_attribute(restart%fv_core_coarse, & + 'va', "units", "none", str_len=len("none")) endif if (.not. hydrostatic) then call register_restart_field(restart%fv_core_coarse, & 'W', restart%w, dim_names_4d3, is_optional=.true.) + if (variable_exists(restart%fv_core_coarse, 'W')) then + call register_variable_attribute(restart%fv_core_coarse, & + 'W', "long_name", "W", str_len=len("W")) + call register_variable_attribute(restart%fv_core_coarse, & + 'W', "units", "none", str_len=len("none")) + endif call register_restart_field(restart%fv_core_coarse, & 'DZ', restart%delz, dim_names_4d3, is_optional=.true.) + if (variable_exists(restart%fv_core_coarse, 'DZ')) then + call register_variable_attribute(restart%fv_core_coarse, & + 'DZ', "long_name", "DZ", str_len=len("DZ")) + call register_variable_attribute(restart%fv_core_coarse, & + 'DZ', "units", "none", str_len=len("none")) + endif if (hybrid_z) then call register_restart_field(restart%fv_core_coarse, & 'ZE0', restart%ze0, dim_names_4d3, is_optional=.false.) + call register_variable_attribute(restart%fv_core_coarse, & + 'ZE0', "long_name", "ZE0", str_len=len("ZE0")) + call register_variable_attribute(restart%fv_core_coarse, & + 'ZE0', "units", "none", str_len=len("none")) endif endif call register_restart_field(restart%fv_core_coarse, & 'T', restart%pt, dim_names_4d3) + call register_variable_attribute(restart%fv_core_coarse, & + 'T', "long_name", "T", str_len=len("T")) + call register_variable_attribute(restart%fv_core_coarse, & + 'T', "units", "none", str_len=len("none")) call register_restart_field(restart%fv_core_coarse, & 'delp', restart%delp, dim_names_4d3) + call register_variable_attribute(restart%fv_core_coarse, & + 'delp', "long_name", "delp", str_len=len("delp")) + call register_variable_attribute(restart%fv_core_coarse, & + 'delp', "units", "none", str_len=len("none")) call register_restart_field(restart%fv_core_coarse, & 'phis', restart%phis, dim_names_3d) + call register_variable_attribute(restart%fv_core_coarse, & + 'phis', "long_name", "phis", str_len=len("phis")) + call register_variable_attribute(restart%fv_core_coarse, & + 'phis', "units", "none", str_len=len("none")) endif end subroutine register_fv_core_coarse @@ -274,6 +339,12 @@ subroutine register_fv_tracer_coarse(coarse_domain, restart, timestamp) call register_restart_field(restart%fv_tracer_coarse, & tracer_name, restart%q(:,:,:,n_tracer), dim_names_4d, & is_optional=.true.) + if (variable_exists(restart%fv_tracer_coarse, tracer_name)) then + call register_variable_attribute(restart%fv_tracer_coarse, & + tracer_name, "long_name", tracer_name, str_len=len(tracer_name)) + call register_variable_attribute(restart%fv_tracer_coarse, & + tracer_name, "units", "none", str_len=len("none")) + endif enddo do n_tracer = n_prognostic_tracers + 1, n_tracers @@ -282,6 +353,12 @@ subroutine register_fv_tracer_coarse(coarse_domain, restart, timestamp) call register_restart_field(restart%fv_tracer_coarse, & tracer_name, restart%qdiag(:,:,:,n_tracer), dim_names_4d, & is_optional=.true.) + if (variable_exists(restart%fv_tracer_coarse, tracer_name)) then + call register_variable_attribute(restart%fv_tracer_coarse, & + tracer_name, "long_name", tracer_name, str_len=len(tracer_name)) + call register_variable_attribute(restart%fv_tracer_coarse, & + tracer_name, "units", "none", str_len=len("none")) + endif enddo endif end subroutine register_fv_tracer_coarse @@ -311,8 +388,16 @@ subroutine register_fv_srf_wnd_coarse(coarse_domain, restart, timestamp) call register_restart_field(restart%fv_srf_wnd_coarse, & 'u_srf', restart%u_srf, dim_names_3d) + call register_variable_attribute(restart%fv_srf_wnd_coarse, & + 'u_srf', "long_name", "u_srf", str_len=len("u_srf")) + call register_variable_attribute(restart%fv_srf_wnd_coarse, & + 'u_srf', "units", "none", str_len=len("none")) call register_restart_field(restart%fv_srf_wnd_coarse, & 'v_srf', restart%v_srf, dim_names_3d) + call register_variable_attribute(restart%fv_srf_wnd_coarse, & + 'v_srf', "long_name", "v_srf", str_len=len("v_srf")) + call register_variable_attribute(restart%fv_srf_wnd_coarse, & + 'v_srf', "units", "none", str_len=len("none")) endif end subroutine register_fv_srf_wnd_coarse @@ -341,6 +426,10 @@ subroutine register_mg_drag_coarse(coarse_domain, restart, timestamp) call register_restart_field(restart%mg_drag_coarse, & 'ghprime', restart%sgh, dim_names_3d) + call register_variable_attribute(restart%mg_drag_coarse, & + 'ghprime', "long_name", "ghprime", str_len=len("ghprime")) + call register_variable_attribute(restart%mg_drag_coarse, & + 'ghprime', "units", "none", str_len=len("none")) endif end subroutine register_mg_drag_coarse @@ -369,6 +458,10 @@ subroutine register_fv_land_coarse(coarse_domain, restart, timestamp) call register_restart_field(restart%fv_land_coarse, & 'oro', restart%oro, dim_names_3d) + call register_variable_attribute(restart%fv_land_coarse, & + 'oro', "long_name", "oro", str_len=len("oro")) + call register_variable_attribute(restart%fv_core_coarse, & + 'oro', "units", "none", str_len=len("none")) endif end subroutine register_fv_land_coarse diff --git a/tools/coarse_graining.F90 b/tools/coarse_graining.F90 index 4584d4f0e..97bb2f6b4 100644 --- a/tools/coarse_graining.F90 +++ b/tools/coarse_graining.F90 @@ -1,9 +1,30 @@ +!*********************************************************************** +!* GNU Lesser General Public License +!* +!* This file is part of the FV3 dynamical core. +!* +!* The FV3 dynamical core is free software: you can redistribute it +!* and/or modify it under the terms of the +!* GNU Lesser General Public License as published by the +!* Free Software Foundation, either version 3 of the License, or +!* (at your option) any later version. +!* +!* The FV3 dynamical core is distributed in the hope that it will be +!* useful, but WITHOUT ANY WARRANTY; without even the implied warranty +!* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. +!* See the GNU General Public License for more details. +!* +!* You should have received a copy of the GNU Lesser General Public +!* License along with the FV3 dynamical core. +!* If not, see . +!*********************************************************************** + module coarse_graining_mod - use fms_mod, only: check_nml_error + use fms_mod, only: check_nml_error, close_file, open_namelist_file use mpp_domains_mod, only: domain2d, mpp_define_io_domain, mpp_define_mosaic, mpp_get_compute_domain - use fv_mapz_mod, only: mappm use mpp_mod, only: FATAL, input_nml_file, mpp_error, mpp_npes + use statistics_mod, only: mode implicit none private @@ -13,10 +34,14 @@ module coarse_graining_mod weighted_block_edge_average_x, weighted_block_edge_average_y, MODEL_LEVEL, & block_upsample, mask_area_weights, PRESSURE_LEVEL, vertical_remapping_requirements, & vertically_remap_field, mask_mass_weights, remap_edges_along_x, remap_edges_along_y, & - block_edge_sum_x, block_edge_sum_y + block_edge_sum_x, block_edge_sum_y, block_mode, block_min, block_max, & + eddy_covariance, eddy_covariance_2d_weights, eddy_covariance_3d_weights interface block_sum - module procedure block_sum_2d + module procedure block_sum_2d_real4 + module procedure block_sum_2d_real8 + module procedure masked_block_sum_2d_real4 + module procedure masked_block_sum_2d_real8 end interface block_sum interface block_edge_sum_x @@ -28,9 +53,16 @@ module coarse_graining_mod end interface block_edge_sum_y interface weighted_block_average - module procedure weighted_block_average_2d - module procedure weighted_block_average_3d_field_2d_weights - module procedure weighted_block_average_3d_field_3d_weights + module procedure weighted_block_average_2d_real4 + module procedure weighted_block_average_2d_real8 + module procedure masked_weighted_block_average_2d_real4 + module procedure masked_weighted_block_average_2d_real8 + module procedure masked_weighted_block_average_3d_field_2d_weights_real4 + module procedure masked_weighted_block_average_3d_field_2d_weights_real8 + module procedure weighted_block_average_3d_field_2d_weights_real4 + module procedure weighted_block_average_3d_field_2d_weights_real8 + module procedure weighted_block_average_3d_field_3d_weights_real4 + module procedure weighted_block_average_3d_field_3d_weights_real8 end interface weighted_block_average interface weighted_block_edge_average_x @@ -44,8 +76,10 @@ module coarse_graining_mod end interface weighted_block_edge_average_y interface block_upsample - module procedure block_upsample_2d - module procedure block_upsample_3d + module procedure block_upsample_2d_real4 + module procedure block_upsample_3d_real4 + module procedure block_upsample_2d_real8 + module procedure block_upsample_3d_real8 end interface block_upsample interface weighted_block_edge_average_x_pre_downsampled @@ -58,12 +92,83 @@ module coarse_graining_mod module procedure weighted_block_edge_average_y_pre_downsampled_masked end interface weighted_block_edge_average_y_pre_downsampled + interface eddy_covariance + module procedure eddy_covariance_2d_weights + module procedure eddy_covariance_3d_weights + end interface eddy_covariance + + interface block_mode + module procedure block_mode_2d_real4 + module procedure masked_block_mode_2d_real4 + module procedure block_mode_2d_real8 + module procedure masked_block_mode_2d_real8 + end interface block_mode + + interface block_min + module procedure masked_block_min_2d_real4 + module procedure masked_block_min_2d_real8 + end interface block_min + + interface block_max + module procedure masked_block_max_2d_real4 + module procedure masked_block_max_2d_real8 + end interface block_max + + interface vertical_remapping_requirements + module procedure vertical_remapping_requirements_real4 + module procedure vertical_remapping_requirements_real8 + end interface vertical_remapping_requirements + + interface compute_phalf_from_delp + module procedure compute_phalf_from_delp_real4 + module procedure compute_phalf_from_delp_real8 + end interface compute_phalf_from_delp + + interface mask_area_weights + module procedure mask_area_weights_real4 + module procedure mask_area_weights_real8 + end interface mask_area_weights + + interface vertically_remap_field + module procedure vertically_remap_field_real4 + module procedure vertically_remap_field_real8 + end interface vertically_remap_field + + interface mappm + module procedure mappm_real4 + module procedure mappm_real8 + end interface mappm + + interface cs_profile + module procedure cs_profile_real4 + module procedure cs_profile_real8 + end interface cs_profile + + interface cs_limiters + module procedure cs_limiters_real4 + module procedure cs_limiters_real8 + end interface cs_limiters + + interface ppm_profile + module procedure ppm_profile_real4 + module procedure ppm_profile_real8 + end interface ppm_profile + + interface ppm_limiters + module procedure ppm_limiters_real4 + module procedure ppm_limiters_real8 + end interface ppm_limiters + ! Global variables for the module, initialized in coarse_graining_init integer :: is, ie, js, je, npz integer :: is_coarse, ie_coarse, js_coarse, je_coarse character(len=11) :: MODEL_LEVEL = 'model_level' character(len=14) :: PRESSURE_LEVEL = 'pressure_level' + ! GLobal variables for mappm + real(kind=4), parameter:: r3_real4 = 1./3., r23_real4 = 2./3., r12_real4 = 1./12. + real(kind=8), parameter:: r3_real8 = 1./3., r23_real8 = 2./3., r12_real8 = 1./12. + ! Namelist parameters initialized with default values integer :: coarsening_factor = 8 !< factor the coarse grid is downsampled by (e.g. 8 if coarsening from C384 to C48 resolution) integer :: coarse_io_layout(2) = (/1, 1/) !< I/O layout for coarse-grid fields @@ -112,12 +217,6 @@ subroutine compute_nx_coarse(npx, coarsening_factor, nx_coarse) integer :: nx nx = npx - 1 - - if (coarsening_factor < 1) then - write(error_message, *) 'Invalid coarsening_factor chosen' - call mpp_error(FATAL, error_message) - endif - if (mod(nx, coarsening_factor) > 0) then write(error_message, *) 'coarse_graining_init: coarsening_factor does not evenly divide the native resolution.' call mpp_error(FATAL, error_message) @@ -190,9 +289,9 @@ subroutine compute_mass_weights(area, delp, mass) enddo end subroutine compute_mass_weights - subroutine block_sum_2d(fine, coarse) - real, intent(in) :: fine(is:ie,js:je) - real, intent(out) :: coarse(is_coarse:ie_coarse,js_coarse:je_coarse) + subroutine block_sum_2d_real4(fine, coarse) + real(kind=4), intent(in) :: fine(is:ie,js:je) + real(kind=4), intent(out) :: coarse(is_coarse:ie_coarse,js_coarse:je_coarse) integer :: i, j, i_coarse, j_coarse, offset @@ -204,45 +303,194 @@ subroutine block_sum_2d(fine, coarse) coarse(i_coarse,j_coarse) = sum(fine(i:i+offset,j:j+offset)) enddo enddo - end subroutine + end subroutine block_sum_2d_real4 - subroutine weighted_block_average_2d(weights, fine, coarse) - real, intent(in) :: weights(is:ie,js:je), fine(is:ie,js:je) - real, intent(out) :: coarse(is_coarse:ie_coarse,js_coarse:je_coarse) + subroutine block_sum_2d_real8(fine, coarse) + real(kind=8), intent(in) :: fine(is:ie,js:je) + real(kind=8), intent(out) :: coarse(is_coarse:ie_coarse,js_coarse:je_coarse) - real, allocatable :: weighted_fine(:,:), weighted_block_sum(:,:), block_sum_weights(:,:) + integer :: i, j, i_coarse, j_coarse, offset + + offset = coarsening_factor - 1 + do i = is, ie, coarsening_factor + i_coarse = (i - 1) / coarsening_factor + 1 + do j = js, je, coarsening_factor + j_coarse = (j - 1) / coarsening_factor + 1 + coarse(i_coarse,j_coarse) = sum(fine(i:i+offset,j:j+offset)) + enddo + enddo + end subroutine block_sum_2d_real8 + + subroutine masked_block_sum_2d_real4(fine, mask, coarse) + real(kind=4), intent(in) :: fine(is:ie,js:je) + logical, intent(in) :: mask(is:ie,js:je) + real(kind=4), intent(out) :: coarse(is_coarse:ie_coarse,js_coarse:je_coarse) + + integer :: i, j, i_coarse, j_coarse, offset + + offset = coarsening_factor - 1 + do i = is, ie, coarsening_factor + i_coarse = (i - 1) / coarsening_factor + 1 + do j = js, je, coarsening_factor + j_coarse = (j - 1) / coarsening_factor + 1 + coarse(i_coarse,j_coarse) = sum(fine(i:i+offset,j:j+offset), mask=mask(i:i+offset,j:j+offset)) + enddo + enddo + end subroutine masked_block_sum_2d_real4 + + subroutine masked_block_sum_2d_real8(fine, mask, coarse) + real(kind=8), intent(in) :: fine(is:ie,js:je) + logical, intent(in) :: mask(is:ie,js:je) + real(kind=8), intent(out) :: coarse(is_coarse:ie_coarse,js_coarse:je_coarse) + + integer :: i, j, i_coarse, j_coarse, offset + + offset = coarsening_factor - 1 + do i = is, ie, coarsening_factor + i_coarse = (i - 1) / coarsening_factor + 1 + do j = js, je, coarsening_factor + j_coarse = (j - 1) / coarsening_factor + 1 + coarse(i_coarse,j_coarse) = sum(fine(i:i+offset,j:j+offset), mask=mask(i:i+offset,j:j+offset)) + enddo + enddo + end subroutine masked_block_sum_2d_real8 + + subroutine weighted_block_average_2d_real4(weights, fine, coarse) + real(kind=4), intent(in) :: weights(is:ie,js:je), fine(is:ie,js:je) + real(kind=4), intent(out) :: coarse(is_coarse:ie_coarse,js_coarse:je_coarse) + + real(kind=4), allocatable :: weighted_fine(:,:), weighted_block_sum(:,:), block_sum_weights(:,:) allocate(weighted_fine(is:ie,js:je)) allocate(weighted_block_sum(is_coarse:ie_coarse,js_coarse:je_coarse)) allocate(block_sum_weights(is_coarse:ie_coarse,js_coarse:je_coarse)) weighted_fine = weights * fine - call block_sum_2d(weighted_fine, weighted_block_sum) - call block_sum_2d(weights, block_sum_weights) + call block_sum_2d_real4(weighted_fine, weighted_block_sum) + call block_sum_2d_real4(weights, block_sum_weights) coarse = weighted_block_sum / block_sum_weights - end subroutine weighted_block_average_2d + end subroutine weighted_block_average_2d_real4 - subroutine weighted_block_average_3d_field_2d_weights(weights, fine, coarse) - real, intent(in) :: weights(is:ie,js:je), fine(is:ie,js:je,1:npz) - real, intent(out) :: coarse(is_coarse:ie_coarse,js_coarse:je_coarse,1:npz) + subroutine weighted_block_average_2d_real8(weights, fine, coarse) + real(kind=8), intent(in) :: weights(is:ie,js:je), fine(is:ie,js:je) + real(kind=8), intent(out) :: coarse(is_coarse:ie_coarse,js_coarse:je_coarse) + + real(kind=8), allocatable :: weighted_fine(:,:), weighted_block_sum(:,:), block_sum_weights(:,:) + + allocate(weighted_fine(is:ie,js:je)) + allocate(weighted_block_sum(is_coarse:ie_coarse,js_coarse:je_coarse)) + allocate(block_sum_weights(is_coarse:ie_coarse,js_coarse:je_coarse)) + + weighted_fine = weights * fine + call block_sum_2d_real8(weighted_fine, weighted_block_sum) + call block_sum_2d_real8(weights, block_sum_weights) + coarse = weighted_block_sum / block_sum_weights + end subroutine weighted_block_average_2d_real8 + + subroutine masked_weighted_block_average_2d_real4(weights, fine, mask, coarse) + real(kind=4), intent(in) :: weights(is:ie,js:je), fine(is:ie,js:je) + logical, intent(in) :: mask(is:ie,js:je) + real(kind=4), intent(out) :: coarse(is_coarse:ie_coarse,js_coarse:je_coarse) + + real(kind=4), allocatable :: weighted_fine(:,:), weighted_block_sum(:,:), block_sum_weights(:,:) + + allocate(weighted_fine(is:ie,js:je)) + allocate(weighted_block_sum(is_coarse:ie_coarse,js_coarse:je_coarse)) + allocate(block_sum_weights(is_coarse:ie_coarse,js_coarse:je_coarse)) + + weighted_fine = weights * fine + call masked_block_sum_2d_real4(weighted_fine, mask, weighted_block_sum) + call masked_block_sum_2d_real4(weights, mask, block_sum_weights) + coarse = weighted_block_sum / block_sum_weights + end subroutine masked_weighted_block_average_2d_real4 + + subroutine masked_weighted_block_average_2d_real8(weights, fine, mask, coarse) + real(kind=8), intent(in) :: weights(is:ie,js:je), fine(is:ie,js:je) + logical, intent(in) :: mask(is:ie,js:je) + real(kind=8), intent(out) :: coarse(is_coarse:ie_coarse,js_coarse:je_coarse) + + real(kind=8), allocatable :: weighted_fine(:,:), weighted_block_sum(:,:), block_sum_weights(:,:) + + allocate(weighted_fine(is:ie,js:je)) + allocate(weighted_block_sum(is_coarse:ie_coarse,js_coarse:je_coarse)) + allocate(block_sum_weights(is_coarse:ie_coarse,js_coarse:je_coarse)) + + weighted_fine = weights * fine + call masked_block_sum_2d_real8(weighted_fine, mask, weighted_block_sum) + call masked_block_sum_2d_real8(weights, mask, block_sum_weights) + coarse = weighted_block_sum / block_sum_weights + end subroutine masked_weighted_block_average_2d_real8 + + subroutine masked_weighted_block_average_3d_field_2d_weights_real4(weights, fine, mask, nz, coarse) + real(kind=4), intent(in) :: weights(is:ie,js:je), fine(is:ie,js:je,1:nz) + logical, intent(in) :: mask(is:ie,js:je) + integer, intent(in) :: nz + real(kind=4), intent(out) :: coarse(is_coarse:ie_coarse,js_coarse:je_coarse,1:nz) + + integer :: k + + do k = 1, nz + call masked_weighted_block_average_2d_real4(weights, fine(is:ie,js:je,k), mask, coarse(is_coarse:ie_coarse,js_coarse:je_coarse,k)) + enddo + end subroutine masked_weighted_block_average_3d_field_2d_weights_real4 + + subroutine masked_weighted_block_average_3d_field_2d_weights_real8(weights, fine, mask, nz, coarse) + real(kind=8), intent(in) :: weights(is:ie,js:je), fine(is:ie,js:je,1:nz) + logical, intent(in) :: mask(is:ie,js:je) + integer, intent(in) :: nz + real(kind=8), intent(out) :: coarse(is_coarse:ie_coarse,js_coarse:je_coarse,1:nz) + + integer :: k + + do k = 1, nz + call masked_weighted_block_average_2d_real8(weights, fine(is:ie,js:je,k), mask, coarse(is_coarse:ie_coarse,js_coarse:je_coarse,k)) + enddo + end subroutine masked_weighted_block_average_3d_field_2d_weights_real8 + + subroutine weighted_block_average_3d_field_2d_weights_real4(weights, fine, coarse) + real(kind=4), intent(in) :: weights(is:ie,js:je), fine(is:ie,js:je,1:npz) + real(kind=4), intent(out) :: coarse(is_coarse:ie_coarse,js_coarse:je_coarse,1:npz) integer :: k do k = 1, npz - call weighted_block_average_2d(weights, fine(is:ie,js:je,k), coarse(is_coarse:ie_coarse,js_coarse:je_coarse,k)) + call weighted_block_average_2d_real4(weights, fine(is:ie,js:je,k), coarse(is_coarse:ie_coarse,js_coarse:je_coarse,k)) enddo - end subroutine weighted_block_average_3d_field_2d_weights + end subroutine weighted_block_average_3d_field_2d_weights_real4 - subroutine weighted_block_average_3d_field_3d_weights(weights, fine, coarse) - real, intent(in) :: weights(is:ie,js:je,1:npz), fine(is:ie,js:je,1:npz) - real, intent(out) :: coarse(is_coarse:ie_coarse,js_coarse:je_coarse,1:npz) + subroutine weighted_block_average_3d_field_2d_weights_real8(weights, fine, coarse) + real(kind=8), intent(in) :: weights(is:ie,js:je), fine(is:ie,js:je,1:npz) + real(kind=8), intent(out) :: coarse(is_coarse:ie_coarse,js_coarse:je_coarse,1:npz) + + integer :: k + + do k = 1, npz + call weighted_block_average_2d_real8(weights, fine(is:ie,js:je,k), coarse(is_coarse:ie_coarse,js_coarse:je_coarse,k)) + enddo + end subroutine weighted_block_average_3d_field_2d_weights_real8 + + subroutine weighted_block_average_3d_field_3d_weights_real4(weights, fine, coarse) + real(kind=4), intent(in) :: weights(is:ie,js:je,1:npz), fine(is:ie,js:je,1:npz) + real(kind=4), intent(out) :: coarse(is_coarse:ie_coarse,js_coarse:je_coarse,1:npz) + + integer :: k + + do k = 1, npz + call weighted_block_average_2d_real4(weights(is:ie,js:je,k), fine(is:ie,js:je,k), coarse(is_coarse:ie_coarse,js_coarse:je_coarse,k)) + enddo + end subroutine weighted_block_average_3d_field_3d_weights_real4 + + subroutine weighted_block_average_3d_field_3d_weights_real8(weights, fine, coarse) + real(kind=8), intent(in) :: weights(is:ie,js:je,1:npz), fine(is:ie,js:je,1:npz) + real(kind=8), intent(out) :: coarse(is_coarse:ie_coarse,js_coarse:je_coarse,1:npz) integer :: k do k = 1, npz - call weighted_block_average_2d(weights(is:ie,js:je,k), fine(is:ie,js:je,k), coarse(is_coarse:ie_coarse,js_coarse:je_coarse,k)) + call weighted_block_average_2d_real8(weights(is:ie,js:je,k), fine(is:ie,js:je,k), coarse(is_coarse:ie_coarse,js_coarse:je_coarse,k)) enddo - end subroutine weighted_block_average_3d_field_3d_weights + end subroutine weighted_block_average_3d_field_3d_weights_real8 + subroutine block_edge_sum_x_2d(fine, coarse) real, intent(in) :: fine(is:ie,js_coarse:je_coarse+1) @@ -334,11 +582,167 @@ subroutine weighted_block_edge_average_y_3d_field_2d_weights(weights, fine, coar enddo end subroutine weighted_block_edge_average_y_3d_field_2d_weights - subroutine vertically_remap_field(phalf_in, field, phalf_out, ptop, field_out) - real, intent(in) :: phalf_in(is:ie,js:je,1:npz+1), phalf_out(is:ie,js:je,1:npz+1) - real, intent(in) :: field(is:ie,js:je,1:npz) - real, intent(in) :: ptop - real, intent(out) :: field_out(is:ie,js:je,1:npz) + subroutine block_mode_2d_real8(fine, coarse) + real(kind=8), intent(in) :: fine(is:ie,js:je) + real(kind=8), intent(out) :: coarse(is_coarse:ie_coarse,js_coarse:je_coarse) + + integer :: i, j, i_coarse, j_coarse, offset + + offset = coarsening_factor - 1 + do i = is, ie, coarsening_factor + i_coarse = (i - 1) / coarsening_factor + 1 + do j = js, je, coarsening_factor + j_coarse = (j - 1) / coarsening_factor + 1 + coarse(i_coarse, j_coarse) = mode(fine(i:i+offset,j:j+offset)) + enddo + enddo + end subroutine block_mode_2d_real8 + + subroutine masked_block_mode_2d_real8(fine, mask, coarse) + real(kind=8), intent(in) :: fine(is:ie,js:je) + logical, intent(in) :: mask(is:ie,js:je) + real(kind=8), intent(out) :: coarse(is_coarse:ie_coarse,js_coarse:je_coarse) + + integer :: i, j, i_coarse, j_coarse, offset + + offset = coarsening_factor - 1 + do i = is, ie, coarsening_factor + i_coarse = (i - 1) / coarsening_factor + 1 + do j = js, je, coarsening_factor + j_coarse = (j - 1) / coarsening_factor + 1 + coarse(i_coarse, j_coarse) = mode(fine(i:i+offset,j:j+offset), mask(i:i+offset,j:j+offset)) + enddo + enddo + end subroutine masked_block_mode_2d_real8 + + subroutine block_mode_2d_real4(fine, coarse) + real(kind=4), intent(in) :: fine(is:ie,js:je) + real(kind=4), intent(out) :: coarse(is_coarse:ie_coarse,js_coarse:je_coarse) + + integer :: i, j, i_coarse, j_coarse, offset + + offset = coarsening_factor - 1 + do i = is, ie, coarsening_factor + i_coarse = (i - 1) / coarsening_factor + 1 + do j = js, je, coarsening_factor + j_coarse = (j - 1) / coarsening_factor + 1 + coarse(i_coarse, j_coarse) = mode(fine(i:i+offset,j:j+offset)) + enddo + enddo + end subroutine block_mode_2d_real4 + + subroutine masked_block_mode_2d_real4(fine, mask, coarse) + real(kind=4), intent(in) :: fine(is:ie,js:je) + logical, intent(in) :: mask(is:ie,js:je) + real(kind=4), intent(out) :: coarse(is_coarse:ie_coarse,js_coarse:je_coarse) + + integer :: i, j, i_coarse, j_coarse, offset + + offset = coarsening_factor - 1 + do i = is, ie, coarsening_factor + i_coarse = (i - 1) / coarsening_factor + 1 + do j = js, je, coarsening_factor + j_coarse = (j - 1) / coarsening_factor + 1 + coarse(i_coarse, j_coarse) = mode(fine(i:i+offset,j:j+offset), mask(i:i+offset,j:j+offset)) + enddo + enddo + end subroutine masked_block_mode_2d_real4 + + subroutine masked_block_min_2d_real8(fine, mask, coarse) + real(kind=8), intent(in) :: fine(is:ie,js:je) + logical, intent(in) :: mask(is:ie,js:je) + real(kind=8), intent(out) :: coarse(is_coarse:ie_coarse,js_coarse:je_coarse) + + integer :: i, j, i_coarse, j_coarse, offset + + offset = coarsening_factor - 1 + do i = is, ie, coarsening_factor + i_coarse = (i - 1) / coarsening_factor + 1 + do j = js, je, coarsening_factor + j_coarse = (j - 1) / coarsening_factor + 1 + coarse(i_coarse, j_coarse) = minval(fine(i:i+offset,j:j+offset), mask=mask(i:i + offset,j:j + offset)) + enddo + enddo + end subroutine masked_block_min_2d_real8 + + subroutine masked_block_max_2d_real8(fine, mask, coarse) + real(kind=8), intent(in) :: fine(is:ie,js:je) + logical, intent(in) :: mask(is:ie,js:je) + real(kind=8), intent(out) :: coarse(is_coarse:ie_coarse,js_coarse:je_coarse) + + integer :: i, j, i_coarse, j_coarse, offset + + offset = coarsening_factor - 1 + do i = is, ie, coarsening_factor + i_coarse = (i - 1) / coarsening_factor + 1 + do j = js, je, coarsening_factor + j_coarse = (j - 1) / coarsening_factor + 1 + coarse(i_coarse, j_coarse) = maxval(fine(i:i+offset,j:j+offset), mask=mask(i:i + offset,j:j + offset)) + enddo + enddo + end subroutine masked_block_max_2d_real8 + + subroutine masked_block_min_2d_real4(fine, mask, coarse) + real(kind=4), intent(in) :: fine(is:ie,js:je) + logical, intent(in) :: mask(is:ie,js:je) + real(kind=4), intent(out) :: coarse(is_coarse:ie_coarse,js_coarse:je_coarse) + + integer :: i, j, i_coarse, j_coarse, offset + + offset = coarsening_factor - 1 + do i = is, ie, coarsening_factor + i_coarse = (i - 1) / coarsening_factor + 1 + do j = js, je, coarsening_factor + j_coarse = (j - 1) / coarsening_factor + 1 + coarse(i_coarse, j_coarse) = minval(fine(i:i+offset,j:j+offset), mask=mask(i:i + offset,j:j + offset)) + enddo + enddo + end subroutine masked_block_min_2d_real4 + + subroutine masked_block_max_2d_real4(fine, mask, coarse) + real(kind=4), intent(in) :: fine(is:ie,js:je) + logical, intent(in) :: mask(is:ie,js:je) + real(kind=4), intent(out) :: coarse(is_coarse:ie_coarse,js_coarse:je_coarse) + + integer :: i, j, i_coarse, j_coarse, offset + + offset = coarsening_factor - 1 + do i = is, ie, coarsening_factor + i_coarse = (i - 1) / coarsening_factor + 1 + do j = js, je, coarsening_factor + j_coarse = (j - 1) / coarsening_factor + 1 + coarse(i_coarse, j_coarse) = maxval(fine(i:i+offset,j:j+offset), mask=mask(i:i + offset,j:j + offset)) + enddo + enddo + end subroutine masked_block_max_2d_real4 + + subroutine vertically_remap_field_real4(phalf_in, field, phalf_out, ptop, field_out) + real(kind=4), intent(in) :: phalf_in(is:ie,js:je,1:npz+1), phalf_out(is:ie,js:je,1:npz+1) + real(kind=4), intent(in) :: field(is:ie,js:je,1:npz) + real(kind=4), intent(in) :: ptop + real(kind=4), intent(out) :: field_out(is:ie,js:je,1:npz) + + integer :: kn, km, kord, iv, j, q2 + + kn = npz + km = npz + + ! Hard code values of kord and iv for now + kord = 1 + iv = 1 + q2 = 1 + + do j = js, je + call mappm(km, phalf_in(is:ie,j,:), field(is:ie,j,:), kn, & + phalf_out(is:ie,j,:), field_out(is:ie,j,:), is, ie, iv, kord, ptop) + enddo + end subroutine vertically_remap_field_real4 + + subroutine vertically_remap_field_real8(phalf_in, field, phalf_out, ptop, field_out) + real(kind=8), intent(in) :: phalf_in(is:ie,js:je,1:npz+1), phalf_out(is:ie,js:je,1:npz+1) + real(kind=8), intent(in) :: field(is:ie,js:je,1:npz) + real(kind=8), intent(in) :: ptop + real(kind=8), intent(out) :: field_out(is:ie,js:je,1:npz) integer :: kn, km, kord, iv, j, q2 @@ -354,11 +758,39 @@ subroutine vertically_remap_field(phalf_in, field, phalf_out, ptop, field_out) call mappm(km, phalf_in(is:ie,j,:), field(is:ie,j,:), kn, & phalf_out(is:ie,j,:), field_out(is:ie,j,:), is, ie, iv, kord, ptop) enddo - end subroutine vertically_remap_field + end subroutine vertically_remap_field_real8 + + subroutine block_upsample_2d_real4(coarse, fine) + real(kind=4), intent(in) :: coarse(is_coarse:ie_coarse,js_coarse:je_coarse) + real(kind=4), intent(out) :: fine(is:ie,js:je) + + integer :: i, j, i_coarse, j_coarse, offset + + offset = coarsening_factor - 1 + do i = is, ie, coarsening_factor + i_coarse = (i - 1) / coarsening_factor + 1 + do j = js, je, coarsening_factor + j_coarse = (j - 1) / coarsening_factor + 1 + fine(i:i+offset,j:j+offset) = coarse(i_coarse, j_coarse) + enddo + enddo + end subroutine block_upsample_2d_real4 + + subroutine block_upsample_3d_real4(coarse, fine, nz) + integer, intent(in) :: nz + real(kind=4), intent(in) :: coarse(is_coarse:ie_coarse,js_coarse:je_coarse,1:nz) + real(kind=4), intent(out) :: fine(is:ie,js:je,1:nz) + + integer :: k + + do k = 1, nz + call block_upsample_2d_real4(coarse(is_coarse:ie_coarse,js_coarse:je_coarse,k), fine(is:ie,js:je,k)) + enddo + end subroutine block_upsample_3d_real4 - subroutine block_upsample_2d(coarse, fine) - real, intent(in) :: coarse(is_coarse:ie_coarse,js_coarse:je_coarse) - real, intent(out) :: fine(is:ie,js:je) + subroutine block_upsample_2d_real8(coarse, fine) + real(kind=8), intent(in) :: coarse(is_coarse:ie_coarse,js_coarse:je_coarse) + real(kind=8), intent(out) :: fine(is:ie,js:je) integer :: i, j, i_coarse, j_coarse, offset @@ -370,19 +802,19 @@ subroutine block_upsample_2d(coarse, fine) fine(i:i+offset,j:j+offset) = coarse(i_coarse, j_coarse) enddo enddo - end subroutine block_upsample_2d + end subroutine block_upsample_2d_real8 - subroutine block_upsample_3d(coarse, fine, nz) + subroutine block_upsample_3d_real8(coarse, fine, nz) integer, intent(in) :: nz - real, intent(in) :: coarse(is_coarse:ie_coarse,js_coarse:je_coarse,1:nz) - real, intent(out) :: fine(is:ie,js:je,1:nz) + real(kind=8), intent(in) :: coarse(is_coarse:ie_coarse,js_coarse:je_coarse,1:nz) + real(kind=8), intent(out) :: fine(is:ie,js:je,1:nz) integer :: k do k = 1, nz - call block_upsample_2d(coarse(is_coarse:ie_coarse,js_coarse:je_coarse,k), fine(is:ie,js:je,k)) + call block_upsample_2d_real8(coarse(is_coarse:ie_coarse,js_coarse:je_coarse,k), fine(is:ie,js:je,k)) enddo - end subroutine block_upsample_3d + end subroutine block_upsample_3d_real8 ! This subroutine is copied from FMS/test_fms/horiz_interp/test2_horiz_interp.F90. ! domain_decomp in fv_mp_mod.F90 does something similar, but it does a @@ -479,11 +911,11 @@ subroutine define_cubic_mosaic(domain, ni, nj, layout) symmetry=.true., name='coarse cubic mosaic') end subroutine define_cubic_mosaic - subroutine compute_phalf_from_delp(delp, ptop, i_start, i_end, j_start, j_end, phalf) + subroutine compute_phalf_from_delp_real4(delp, ptop, i_start, i_end, j_start, j_end, phalf) integer, intent(in) :: i_start, i_end, j_start, j_end - real, intent(in) :: delp(i_start:i_end,j_start:j_end,1:npz) - real, intent(in) :: ptop - real, intent(out) :: phalf(i_start:i_end,j_start:j_end,1:npz+1) + real(kind=4), intent(in) :: delp(i_start:i_end,j_start:j_end,1:npz) + real(kind=4), intent(in) :: ptop + real(kind=4), intent(out) :: phalf(i_start:i_end,j_start:j_end,1:npz+1) integer :: i, j, k @@ -497,17 +929,37 @@ subroutine compute_phalf_from_delp(delp, ptop, i_start, i_end, j_start, j_end, p enddo enddo enddo - end subroutine compute_phalf_from_delp + end subroutine compute_phalf_from_delp_real4 + + subroutine compute_phalf_from_delp_real8(delp, ptop, i_start, i_end, j_start, j_end, phalf) + integer, intent(in) :: i_start, i_end, j_start, j_end + real(kind=8), intent(in) :: delp(i_start:i_end,j_start:j_end,1:npz) + real(kind=8), intent(in) :: ptop + real(kind=8), intent(out) :: phalf(i_start:i_end,j_start:j_end,1:npz+1) + + integer :: i, j, k + + phalf(:,:,1) = ptop ! Top level interface pressure is the model top + + ! Integrate delp from top of model to the surface. + do i = i_start, i_end + do j = j_start, j_end + do k = 2, npz + 1 + phalf(i,j,k) = phalf(i,j,k-1) + delp(i,j,k-1) + enddo + enddo + enddo + end subroutine compute_phalf_from_delp_real8 ! Routine for computing the common requirements for pressure-level coarse-graining. - subroutine vertical_remapping_requirements(delp, area, ptop, phalf, upsampled_coarse_phalf) - real, intent(in) :: delp(is:ie,js:je,1:npz) - real, intent(in) :: area(is:ie,js:je) - real, intent(in) :: ptop - real, intent(out) :: phalf(is:ie,js:je,1:npz+1) - real, intent(out) :: upsampled_coarse_phalf(is:ie,js:je,1:npz+1) + subroutine vertical_remapping_requirements_real4(delp, area, ptop, phalf, upsampled_coarse_phalf) + real(kind=4), intent(in) :: delp(is:ie,js:je,1:npz) + real(kind=4), intent(in) :: area(is:ie,js:je) + real(kind=4), intent(in) :: ptop + real(kind=4), intent(out) :: phalf(is:ie,js:je,1:npz+1) + real(kind=4), intent(out) :: upsampled_coarse_phalf(is:ie,js:je,1:npz+1) - real, allocatable :: coarse_delp(:,:,:), coarse_phalf(:,:,:) + real(kind=4), allocatable :: coarse_delp(:,:,:), coarse_phalf(:,:,:) allocate(coarse_delp(is_coarse:ie_coarse,js_coarse:je_coarse,1:npz)) allocate(coarse_phalf(is_coarse:ie_coarse,js_coarse:je_coarse,1:npz+1)) @@ -519,13 +971,51 @@ subroutine vertical_remapping_requirements(delp, area, ptop, phalf, upsampled_co deallocate(coarse_delp) deallocate(coarse_phalf) - end subroutine vertical_remapping_requirements + end subroutine vertical_remapping_requirements_real4 - subroutine mask_area_weights(area, phalf, upsampled_coarse_phalf, masked_area_weights) - real, intent(in) :: area(is:ie,js:je) - real, intent(in) :: phalf(is:ie,js:je,1:npz+1) - real, intent(in) :: upsampled_coarse_phalf(is:ie,js:je,1:npz+1) - real, intent(out) :: masked_area_weights(is:ie,js:je,1:npz) + subroutine vertical_remapping_requirements_real8(delp, area, ptop, phalf, upsampled_coarse_phalf) + real(kind=8), intent(in) :: delp(is:ie,js:je,1:npz) + real(kind=8), intent(in) :: area(is:ie,js:je) + real(kind=8), intent(in) :: ptop + real(kind=8), intent(out) :: phalf(is:ie,js:je,1:npz+1) + real(kind=8), intent(out) :: upsampled_coarse_phalf(is:ie,js:je,1:npz+1) + + real(kind=8), allocatable :: coarse_delp(:,:,:), coarse_phalf(:,:,:) + + allocate(coarse_delp(is_coarse:ie_coarse,js_coarse:je_coarse,1:npz)) + allocate(coarse_phalf(is_coarse:ie_coarse,js_coarse:je_coarse,1:npz+1)) + + call compute_phalf_from_delp(delp(is:ie,js:je,1:npz), ptop, is, ie, js, je, phalf) + call weighted_block_average(area(is:ie,js:je), delp(is:ie,js:je,1:npz), coarse_delp) + call compute_phalf_from_delp(coarse_delp, ptop, is_coarse, ie_coarse, js_coarse, je_coarse, coarse_phalf) + call block_upsample(coarse_phalf, upsampled_coarse_phalf, npz+1) + + deallocate(coarse_delp) + deallocate(coarse_phalf) + end subroutine vertical_remapping_requirements_real8 + + subroutine mask_area_weights_real4(area, phalf, upsampled_coarse_phalf, masked_area_weights) + real(kind=4), intent(in) :: area(is:ie,js:je) + real(kind=4), intent(in) :: phalf(is:ie,js:je,1:npz+1) + real(kind=4), intent(in) :: upsampled_coarse_phalf(is:ie,js:je,1:npz+1) + real(kind=4), intent(out) :: masked_area_weights(is:ie,js:je,1:npz) + + integer :: k + + do k = 1, npz + where (upsampled_coarse_phalf(is:ie,js:je,k+1) .lt. phalf(is:ie,js:je,npz+1)) + masked_area_weights(is:ie,js:je,k) = area(is:ie,js:je) + elsewhere + masked_area_weights(is:ie,js:je,k) = 0.0 + endwhere + enddo + end subroutine mask_area_weights_real4 + + subroutine mask_area_weights_real8(area, phalf, upsampled_coarse_phalf, masked_area_weights) + real(kind=8), intent(in) :: area(is:ie,js:je) + real(kind=8), intent(in) :: phalf(is:ie,js:je,1:npz+1) + real(kind=8), intent(in) :: upsampled_coarse_phalf(is:ie,js:je,1:npz+1) + real(kind=8), intent(out) :: masked_area_weights(is:ie,js:je,1:npz) integer :: k @@ -536,7 +1026,7 @@ subroutine mask_area_weights(area, phalf, upsampled_coarse_phalf, masked_area_we masked_area_weights(is:ie,js:je,k) = 0.0 endwhere enddo - end subroutine mask_area_weights + end subroutine mask_area_weights_real8 subroutine mask_mass_weights(area, delp, phalf, upsampled_coarse_phalf, & masked_mass_weights) @@ -878,4 +1368,2032 @@ subroutine block_edge_sum_y_2d_full_input(fine, coarse) enddo end subroutine block_edge_sum_y_2d_full_input + ! Needed for computing variances over coarse grid cells. + subroutine anomaly_2d(weights, fine, anom) + real, intent(in) :: weights(is:ie,js:je), fine(is:ie,js:je) + real, intent(out) :: anom(is:ie,js:je) + + integer :: i, j, i_coarse, j_coarse, offset + real, allocatable :: coarse(:,:) + + allocate(coarse(is_coarse:ie_coarse,js_coarse:je_coarse)) + + ! First compute the coarse-grained field + call weighted_block_average(weights, fine, coarse) + + ! Then subtract it off + offset = coarsening_factor - 1 + do i = is, ie, coarsening_factor + i_coarse = (i - 1) / coarsening_factor + 1 + do j = js, je, coarsening_factor + j_coarse = (j - 1) / coarsening_factor + 1 + anom(i:i+offset,j:j+offset) = fine(i:i+offset,j:j+offset) - coarse(i_coarse,j_coarse) + enddo + enddo + end subroutine anomaly_2d + + subroutine anomaly_3d_weights_3d_array(weights, fine, anom) + real, intent(in) :: weights(is:ie,js:je,1:npz), fine(is:ie,js:je,1:npz) + real, intent(out) :: anom(is:ie,js:je,1:npz) + + integer :: k + do k = 1,npz + call anomaly_2d(weights(is:ie,js:je,k), fine(is:ie,js:je,k), anom(is:ie,js:je,k)) + enddo + end subroutine anomaly_3d_weights_3d_array + + subroutine anomaly_2d_weights_3d_array(weights, fine, anom) + real, intent(in) :: weights(is:ie,js:je) + real, intent(in) :: fine(is:ie,js:je,1:npz) + real, intent(out) :: anom(is:ie,js:je,1:npz) + + integer :: k + do k = 1,npz + call anomaly_2d(weights(is:ie,js:je), fine(is:ie,js:je,k), anom(is:ie,js:je,k)) + enddo + end subroutine anomaly_2d_weights_3d_array + + subroutine eddy_covariance_2d_weights(weights, field_a, field_b, coarse) + real, intent(in) :: weights(is:ie,js:je) + real, intent(in) :: field_a(is:ie,js:je,1:npz) + real, intent(in) :: field_b(is:ie,js:je,1:npz) + real, intent(out) :: coarse(is_coarse:ie_coarse,js_coarse:je_coarse,1:npz) + + real, allocatable :: anom_a(:,:,:) + real, allocatable :: anom_b(:,:,:) + + allocate(anom_a(is:ie,js:je,1:npz)) + allocate(anom_b(is:ie,js:je,1:npz)) + + call anomaly_2d_weights_3d_array(weights, field_a, anom_a) + call anomaly_2d_weights_3d_array(weights, field_b, anom_b) + call weighted_block_average(weights, anom_a * anom_b, coarse) + end subroutine eddy_covariance_2d_weights + + subroutine eddy_covariance_3d_weights(weights, field_a, field_b, coarse) + real, intent(in) :: weights(is:ie,js:je,1:npz) + real, intent(in) :: field_a(is:ie,js:je,1:npz) + real, intent(in) :: field_b(is:ie,js:je,1:npz) + real, intent(out) :: coarse(is_coarse:ie_coarse,js_coarse:je_coarse,1:npz) + + real, allocatable :: anom_a(:,:,:) + real, allocatable :: anom_b(:,:,:) + + allocate(anom_a(is:ie,js:je,1:npz)) + allocate(anom_b(is:ie,js:je,1:npz)) + + call anomaly_3d_weights_3d_array(weights, field_a, anom_a) + call anomaly_3d_weights_3d_array(weights, field_b, anom_b) + call weighted_block_average(weights, anom_a * anom_b, coarse) + end subroutine eddy_covariance_3d_weights + +! Port mappm for single and double precision + subroutine mappm_real4(km, pe1, q1, kn, pe2, q2, i1, i2, iv, kord, ptop) + +! IV = 0: constituents +! IV = 1: potential temp +! IV =-1: winds + +! Mass flux preserving mapping: q1(im,km) -> q2(im,kn) + +! pe1: pressure at layer edges (from model top to bottom surface) +! in the original vertical coordinate +! pe2: pressure at layer edges (from model top to bottom surface) +! in the new vertical coordinate + + integer, intent(in):: i1, i2, km, kn, kord, iv + real(kind=4), intent(in ):: pe1(i1:i2,km+1), pe2(i1:i2,kn+1) + real(kind=4), intent(in ):: q1(i1:i2,km) + real(kind=4), intent(out):: q2(i1:i2,kn) + real(kind=4), intent(IN) :: ptop +! local + real(kind=4) qs(i1:i2) + real(kind=4) dp1(i1:i2,km) + real(kind=4) a4(4,i1:i2,km) + integer i, k, l + integer k0, k1 + real(kind=4) pl, pr, tt, delp, qsum, dpsum, esl + + do k=1,km + do i=i1,i2 + dp1(i,k) = pe1(i,k+1) - pe1(i,k) + a4(1,i,k) = q1(i,k) + enddo + enddo + + if ( kord >7 ) then + call cs_profile( qs, a4, dp1, km, i1, i2, iv, kord ) + else + call ppm_profile( a4, dp1, km, i1, i2, iv, kord ) + endif + +!------------------------------------ +! Lowest layer: constant distribution +!------------------------------------ +#ifdef NGGPS_SUBMITTED + do i=i1,i2 + a4(2,i,km) = q1(i,km) + a4(3,i,km) = q1(i,km) + a4(4,i,km) = 0. + enddo +#endif + + do 5555 i=i1,i2 + k0 = 1 + do 555 k=1,kn + + if(pe2(i,k) .le. pe1(i,1)) then +! above old ptop + q2(i,k) = q1(i,1) + elseif(pe2(i,k) .ge. pe1(i,km+1)) then +! Entire grid below old ps +#ifdef NGGPS_SUBMITTED + q2(i,k) = a4(3,i,km) ! this is not good. +#else + q2(i,k) = q1(i,km) +#endif + else + + do 45 L=k0,km +! locate the top edge at pe2(i,k) + if( pe2(i,k) .ge. pe1(i,L) .and. & + pe2(i,k) .le. pe1(i,L+1) ) then + k0 = L + PL = (pe2(i,k)-pe1(i,L)) / dp1(i,L) + if(pe2(i,k+1) .le. pe1(i,L+1)) then + +! entire new grid is within the original grid + PR = (pe2(i,k+1)-pe1(i,L)) / dp1(i,L) + TT = r3_real4*(PR*(PR+PL)+PL**2) + q2(i,k) = a4(2,i,L) + 0.5*(a4(4,i,L)+a4(3,i,L) & + - a4(2,i,L))*(PR+PL) - a4(4,i,L)*TT + goto 555 + else +! Fractional area... + delp = pe1(i,L+1) - pe2(i,k) + TT = r3_real4*(1.+PL*(1.+PL)) + qsum = delp*(a4(2,i,L)+0.5*(a4(4,i,L)+ & + a4(3,i,L)-a4(2,i,L))*(1.+PL)-a4(4,i,L)*TT) + dpsum = delp + k1 = L + 1 + goto 111 + endif + endif +45 continue + +111 continue + do 55 L=k1,km + if( pe2(i,k+1) .gt. pe1(i,L+1) ) then + +! Whole layer.. + + qsum = qsum + dp1(i,L)*q1(i,L) + dpsum = dpsum + dp1(i,L) + else + delp = pe2(i,k+1)-pe1(i,L) + esl = delp / dp1(i,L) + qsum = qsum + delp * (a4(2,i,L)+0.5*esl* & + (a4(3,i,L)-a4(2,i,L)+a4(4,i,L)*(1.-r23_real4*esl)) ) + dpsum = dpsum + delp + k0 = L + goto 123 + endif +55 continue + delp = pe2(i,k+1) - pe1(i,km+1) + if(delp > 0.) then +! Extended below old ps +#ifdef NGGPS_SUBMITTED + qsum = qsum + delp * a4(3,i,km) ! not good. +#else + qsum = qsum + delp * q1(i,km) +#endif + dpsum = dpsum + delp + endif +123 q2(i,k) = qsum / dpsum + endif +555 continue +5555 continue + + end subroutine mappm_real4 + + subroutine mappm_real8(km, pe1, q1, kn, pe2, q2, i1, i2, iv, kord, ptop) + +! IV = 0: constituents +! IV = 1: potential temp +! IV =-1: winds + +! Mass flux preserving mapping: q1(im,km) -> q2(im,kn) + +! pe1: pressure at layer edges (from model top to bottom surface) +! in the original vertical coordinate +! pe2: pressure at layer edges (from model top to bottom surface) +! in the new vertical coordinate + + integer, intent(in):: i1, i2, km, kn, kord, iv + real(kind=8), intent(in ):: pe1(i1:i2,km+1), pe2(i1:i2,kn+1) + real(kind=8), intent(in ):: q1(i1:i2,km) + real(kind=8), intent(out):: q2(i1:i2,kn) + real(kind=8), intent(IN) :: ptop +! local + real(kind=8) qs(i1:i2) + real(kind=8) dp1(i1:i2,km) + real(kind=8) a4(4,i1:i2,km) + integer i, k, l + integer k0, k1 + real(kind=8) pl, pr, tt, delp, qsum, dpsum, esl + + do k=1,km + do i=i1,i2 + dp1(i,k) = pe1(i,k+1) - pe1(i,k) + a4(1,i,k) = q1(i,k) + enddo + enddo + + if ( kord >7 ) then + call cs_profile( qs, a4, dp1, km, i1, i2, iv, kord ) + else + call ppm_profile( a4, dp1, km, i1, i2, iv, kord ) + endif + +!------------------------------------ +! Lowest layer: constant distribution +!------------------------------------ +#ifdef NGGPS_SUBMITTED + do i=i1,i2 + a4(2,i,km) = q1(i,km) + a4(3,i,km) = q1(i,km) + a4(4,i,km) = 0. + enddo +#endif + + do 5555 i=i1,i2 + k0 = 1 + do 555 k=1,kn + + if(pe2(i,k) .le. pe1(i,1)) then +! above old ptop + q2(i,k) = q1(i,1) + elseif(pe2(i,k) .ge. pe1(i,km+1)) then +! Entire grid below old ps +#ifdef NGGPS_SUBMITTED + q2(i,k) = a4(3,i,km) ! this is not good. +#else + q2(i,k) = q1(i,km) +#endif + else + + do 45 L=k0,km +! locate the top edge at pe2(i,k) + if( pe2(i,k) .ge. pe1(i,L) .and. & + pe2(i,k) .le. pe1(i,L+1) ) then + k0 = L + PL = (pe2(i,k)-pe1(i,L)) / dp1(i,L) + if(pe2(i,k+1) .le. pe1(i,L+1)) then + +! entire new grid is within the original grid + PR = (pe2(i,k+1)-pe1(i,L)) / dp1(i,L) + TT = r3_real8*(PR*(PR+PL)+PL**2) + q2(i,k) = a4(2,i,L) + 0.5*(a4(4,i,L)+a4(3,i,L) & + - a4(2,i,L))*(PR+PL) - a4(4,i,L)*TT + goto 555 + else +! Fractional area... + delp = pe1(i,L+1) - pe2(i,k) + TT = r3_real8*(1.+PL*(1.+PL)) + qsum = delp*(a4(2,i,L)+0.5*(a4(4,i,L)+ & + a4(3,i,L)-a4(2,i,L))*(1.+PL)-a4(4,i,L)*TT) + dpsum = delp + k1 = L + 1 + goto 111 + endif + endif +45 continue + +111 continue + do 55 L=k1,km + if( pe2(i,k+1) .gt. pe1(i,L+1) ) then + +! Whole layer.. + + qsum = qsum + dp1(i,L)*q1(i,L) + dpsum = dpsum + dp1(i,L) + else + delp = pe2(i,k+1)-pe1(i,L) + esl = delp / dp1(i,L) + qsum = qsum + delp * (a4(2,i,L)+0.5*esl* & + (a4(3,i,L)-a4(2,i,L)+a4(4,i,L)*(1.-r23_real8*esl)) ) + dpsum = dpsum + delp + k0 = L + goto 123 + endif +55 continue + delp = pe2(i,k+1) - pe1(i,km+1) + if(delp > 0.) then +! Extended below old ps +#ifdef NGGPS_SUBMITTED + qsum = qsum + delp * a4(3,i,km) ! not good. +#else + qsum = qsum + delp * q1(i,km) +#endif + dpsum = dpsum + delp + endif +123 q2(i,k) = qsum / dpsum + endif +555 continue +5555 continue + + end subroutine mappm_real8 + + subroutine cs_profile_real4(qs, a4, delp, km, i1, i2, iv, kord) +! Optimized vertical profile reconstruction: +! Latest: Apr 2008 S.-J. Lin, NOAA/GFDL + integer, intent(in):: i1, i2 + integer, intent(in):: km ! vertical dimension + integer, intent(in):: iv ! iv =-2: vertical velocity + ! iv =-1: winds + ! iv = 0: positive definite scalars + ! iv = 1: others + integer, intent(in):: kord + real(kind=4), intent(in) :: qs(i1:i2) + real(kind=4), intent(in) :: delp(i1:i2,km) ! layer pressure thickness + real(kind=4), intent(inout):: a4(4,i1:i2,km) ! Interpolated values +!----------------------------------------------------------------------- + logical, dimension(i1:i2,km):: extm, ext5, ext6 + real(kind=4) gam(i1:i2,km) + real(kind=4) q(i1:i2,km+1) ! interface values + real(kind=4) d4(i1:i2) + real(kind=4) bet, a_bot, grat + real(kind=4) pmp_1, lac_1, pmp_2, lac_2, x0, x1 + integer i, k, im + + if ( iv .eq. -2 ) then + do i=i1,i2 + gam(i,2) = 0.5 + q(i,1) = 1.5*a4(1,i,1) + enddo + do k=2,km-1 + do i=i1, i2 + grat = delp(i,k-1) / delp(i,k) + bet = 2. + grat + grat - gam(i,k) + q(i,k) = (3.*(a4(1,i,k-1)+a4(1,i,k)) - q(i,k-1))/bet + gam(i,k+1) = grat / bet + enddo + enddo + do i=i1,i2 + grat = delp(i,km-1) / delp(i,km) + q(i,km) = (3.*(a4(1,i,km-1)+a4(1,i,km)) - grat*qs(i) - q(i,km-1)) / & + (2. + grat + grat - gam(i,km)) + q(i,km+1) = qs(i) + enddo + do k=km-1,1,-1 + do i=i1,i2 + q(i,k) = q(i,k) - gam(i,k+1)*q(i,k+1) + enddo + enddo + +else ! all others + do i=i1,i2 + grat = delp(i,2) / delp(i,1) ! grid ratio + bet = grat*(grat+0.5) + q(i,1) = ( (grat+grat)*(grat+1.)*a4(1,i,1) + a4(1,i,2) ) / bet + gam(i,1) = ( 1. + grat*(grat+1.5) ) / bet + enddo + + if (iv.eq.-3) then !LBC for vertical velocities + do k=2,km-1 + do i=i1,i2 + d4(i) = delp(i,k-1) / delp(i,k) + bet = 2. + d4(i) + d4(i) - gam(i,k-1) + q(i,k) = ( 3.*(a4(1,i,k-1)+d4(i)*a4(1,i,k)) - q(i,k-1) )/bet + gam(i,k) = d4(i) / bet + enddo + enddo + + do i=i1,i2 + ! a_bot = 1. + d4(i)*(d4(i)+1.5) + !q(i,km+1) = (2.*d4(i)*(d4(i)+1.)*a4(1,i,km)+a4(1,i,km-1)-a_bot*q(i,km)) & + ! / ( d4(i)*(d4(i)+0.5) - a_bot*gam(i,km) ) + d4(i) = delp(i,km-1) / delp(i,km) + bet = 2. + d4(i) + d4(i) - gam(i,km-1) + grat = delp(i,km-1) / delp(i,km) + q(i,km) = ( 3.*(a4(1,i,k-1)+d4(i)*a4(1,i,k)) - grat*qs(i) - q(i,k-1) )/bet + q(i,km+1) = qs(i) + enddo + + else ! all others + do k=2,km + do i=i1,i2 + d4(i) = delp(i,k-1) / delp(i,k) + bet = 2. + d4(i) + d4(i) - gam(i,k-1) + q(i,k) = ( 3.*(a4(1,i,k-1)+d4(i)*a4(1,i,k)) - q(i,k-1) )/bet + gam(i,k) = d4(i) / bet + enddo + enddo + + do i=i1,i2 + a_bot = 1. + d4(i)*(d4(i)+1.5) + q(i,km+1) = (2.*d4(i)*(d4(i)+1.)*a4(1,i,km)+a4(1,i,km-1)-a_bot*q(i,km)) & + / ( d4(i)*(d4(i)+0.5) - a_bot*gam(i,km) ) + enddo + endif + + do k=km,1,-1 + do i=i1,i2 + q(i,k) = q(i,k) - gam(i,k)*q(i,k+1) + enddo + enddo + endif +!----- Perfectly linear scheme -------------------------------- + if ( abs(kord) > 16 ) then + do k=1,km + do i=i1,i2 + a4(2,i,k) = q(i,k ) + a4(3,i,k) = q(i,k+1) + a4(4,i,k) = 3.*(2.*a4(1,i,k) - (a4(2,i,k)+a4(3,i,k))) + enddo + enddo + return + endif +!----- Perfectly linear scheme -------------------------------- + +!------------------ +! Apply constraints +!------------------ + im = i2 - i1 + 1 + +! Apply *large-scale* constraints + do i=i1,i2 + q(i,2) = min( q(i,2), max(a4(1,i,1), a4(1,i,2)) ) + q(i,2) = max( q(i,2), min(a4(1,i,1), a4(1,i,2)) ) + enddo + + do k=2,km + do i=i1,i2 + gam(i,k) = a4(1,i,k) - a4(1,i,k-1) ! now dq + enddo + enddo + +! Interior: + do k=3,km-1 + do i=i1,i2 + if ( gam(i,k-1)*gam(i,k+1)>0. ) then +! Apply large-scale constraint to ALL fields if not local max/min + q(i,k) = min( q(i,k), max(a4(1,i,k-1),a4(1,i,k)) ) + q(i,k) = max( q(i,k), min(a4(1,i,k-1),a4(1,i,k)) ) + else + if ( gam(i,k-1) > 0. ) then +! There exists a local max + q(i,k) = max(q(i,k), min(a4(1,i,k-1),a4(1,i,k))) + else +! There exists a local min + q(i,k) = min(q(i,k), max(a4(1,i,k-1),a4(1,i,k))) + if ( iv==0 ) q(i,k) = max(0., q(i,k)) ! positive-definite + endif + endif + enddo + enddo + +! Bottom: + do i=i1,i2 + q(i,km) = min( q(i,km), max(a4(1,i,km-1), a4(1,i,km)) ) + q(i,km) = max( q(i,km), min(a4(1,i,km-1), a4(1,i,km)) ) + enddo + + do k=1,km + do i=i1,i2 + a4(2,i,k) = q(i,k ) + a4(3,i,k) = q(i,k+1) + enddo + enddo + + do k=1,km + if ( k==1 .or. k==km ) then + do i=i1,i2 + extm(i,k) = (a4(2,i,k)-a4(1,i,k)) * (a4(3,i,k)-a4(1,i,k)) > 0. + enddo + else + do i=i1,i2 + extm(i,k) = gam(i,k)*gam(i,k+1) < 0. + enddo + endif + if ( abs(kord) > 9 ) then + do i=i1,i2 + x0 = 2.*a4(1,i,k) - (a4(2,i,k)+a4(3,i,k)) + x1 = abs(a4(2,i,k)-a4(3,i,k)) + a4(4,i,k) = 3.*x0 + ext5(i,k) = abs(x0) > x1 + ext6(i,k) = abs(a4(4,i,k)) > x1 + enddo + endif + enddo + +!--------------------------- +! Apply subgrid constraints: +!--------------------------- +! f(s) = AL + s*[(AR-AL) + A6*(1-s)] ( 0 <= s <= 1 ) +! Top 2 and bottom 2 layers always use monotonic mapping + + if ( iv==0 ) then + do i=i1,i2 + a4(2,i,1) = max(0., a4(2,i,1)) + enddo + elseif ( iv==-1 ) then + do i=i1,i2 + if ( a4(2,i,1)*a4(1,i,1) <= 0. ) a4(2,i,1) = 0. + enddo + elseif ( iv==2 ) then + do i=i1,i2 + a4(2,i,1) = a4(1,i,1) + a4(3,i,1) = a4(1,i,1) + a4(4,i,1) = 0. + enddo + endif + + if ( iv/=2 ) then + do i=i1,i2 + a4(4,i,1) = 3.*(2.*a4(1,i,1) - (a4(2,i,1)+a4(3,i,1))) + enddo + call cs_limiters_real4(im, extm(i1,1), a4(1,i1,1), 1) + endif + +! k=2 + do i=i1,i2 + a4(4,i,2) = 3.*(2.*a4(1,i,2) - (a4(2,i,2)+a4(3,i,2))) + enddo + call cs_limiters_real4(im, extm(i1,2), a4(1,i1,2), 2) + +!------------------------------------- +! Huynh's 2nd constraint for interior: +!------------------------------------- + do k=3,km-2 + if ( abs(kord)<9 ) then + do i=i1,i2 +! Left edges + pmp_1 = a4(1,i,k) - 2.*gam(i,k+1) + lac_1 = pmp_1 + 1.5*gam(i,k+2) + a4(2,i,k) = min(max(a4(2,i,k), min(a4(1,i,k), pmp_1, lac_1)), & + max(a4(1,i,k), pmp_1, lac_1) ) +! Right edges + pmp_2 = a4(1,i,k) + 2.*gam(i,k) + lac_2 = pmp_2 - 1.5*gam(i,k-1) + a4(3,i,k) = min(max(a4(3,i,k), min(a4(1,i,k), pmp_2, lac_2)), & + max(a4(1,i,k), pmp_2, lac_2) ) + + a4(4,i,k) = 3.*(2.*a4(1,i,k) - (a4(2,i,k)+a4(3,i,k))) + enddo + + elseif ( abs(kord)==9 ) then + do i=i1,i2 + if ( extm(i,k) .and. extm(i,k-1) ) then ! c90_mp122 +! grid-scale 2-delta-z wave detected + a4(2,i,k) = a4(1,i,k) + a4(3,i,k) = a4(1,i,k) + a4(4,i,k) = 0. + else if ( extm(i,k) .and. extm(i,k+1) ) then ! c90_mp122 +! grid-scale 2-delta-z wave detected + a4(2,i,k) = a4(1,i,k) + a4(3,i,k) = a4(1,i,k) + a4(4,i,k) = 0. + else + a4(4,i,k) = 6.*a4(1,i,k) - 3.*(a4(2,i,k)+a4(3,i,k)) +! Check within the smooth region if subgrid profile is non-monotonic + if( abs(a4(4,i,k)) > abs(a4(2,i,k)-a4(3,i,k)) ) then + pmp_1 = a4(1,i,k) - 2.*gam(i,k+1) + lac_1 = pmp_1 + 1.5*gam(i,k+2) + a4(2,i,k) = min(max(a4(2,i,k), min(a4(1,i,k), pmp_1, lac_1)), & + max(a4(1,i,k), pmp_1, lac_1) ) + pmp_2 = a4(1,i,k) + 2.*gam(i,k) + lac_2 = pmp_2 - 1.5*gam(i,k-1) + a4(3,i,k) = min(max(a4(3,i,k), min(a4(1,i,k), pmp_2, lac_2)), & + max(a4(1,i,k), pmp_2, lac_2) ) + a4(4,i,k) = 6.*a4(1,i,k) - 3.*(a4(2,i,k)+a4(3,i,k)) + endif + endif + enddo + elseif ( abs(kord)==10 ) then + do i=i1,i2 + if( ext5(i,k) ) then + if( ext5(i,k-1) .or. ext5(i,k+1) ) then + a4(2,i,k) = a4(1,i,k) + a4(3,i,k) = a4(1,i,k) + elseif ( ext6(i,k-1) .or. ext6(i,k+1) ) then + pmp_1 = a4(1,i,k) - 2.*gam(i,k+1) + lac_1 = pmp_1 + 1.5*gam(i,k+2) + a4(2,i,k) = min(max(a4(2,i,k), min(a4(1,i,k), pmp_1, lac_1)), & + max(a4(1,i,k), pmp_1, lac_1) ) + pmp_2 = a4(1,i,k) + 2.*gam(i,k) + lac_2 = pmp_2 - 1.5*gam(i,k-1) + a4(3,i,k) = min(max(a4(3,i,k), min(a4(1,i,k), pmp_2, lac_2)), & + max(a4(1,i,k), pmp_2, lac_2) ) + endif + elseif( ext6(i,k) ) then + if( ext5(i,k-1) .or. ext5(i,k+1) ) then + pmp_1 = a4(1,i,k) - 2.*gam(i,k+1) + lac_1 = pmp_1 + 1.5*gam(i,k+2) + a4(2,i,k) = min(max(a4(2,i,k), min(a4(1,i,k), pmp_1, lac_1)), & + max(a4(1,i,k), pmp_1, lac_1) ) + pmp_2 = a4(1,i,k) + 2.*gam(i,k) + lac_2 = pmp_2 - 1.5*gam(i,k-1) + a4(3,i,k) = min(max(a4(3,i,k), min(a4(1,i,k), pmp_2, lac_2)), & + max(a4(1,i,k), pmp_2, lac_2) ) + endif + endif + enddo + do i=i1,i2 + a4(4,i,k) = 3.*(2.*a4(1,i,k) - (a4(2,i,k)+a4(3,i,k))) + enddo + elseif ( abs(kord)==12 ) then + do i=i1,i2 + if( extm(i,k) ) then +! grid-scale 2-delta-z wave detected + a4(2,i,k) = a4(1,i,k) + a4(3,i,k) = a4(1,i,k) + a4(4,i,k) = 0. + else ! not a local extremum + a4(4,i,k) = 6.*a4(1,i,k) - 3.*(a4(2,i,k)+a4(3,i,k)) +! Check within the smooth region if subgrid profile is non-monotonic + if( abs(a4(4,i,k)) > abs(a4(2,i,k)-a4(3,i,k)) ) then + pmp_1 = a4(1,i,k) - 2.*gam(i,k+1) + lac_1 = pmp_1 + 1.5*gam(i,k+2) + a4(2,i,k) = min(max(a4(2,i,k), min(a4(1,i,k), pmp_1, lac_1)), & + max(a4(1,i,k), pmp_1, lac_1) ) + pmp_2 = a4(1,i,k) + 2.*gam(i,k) + lac_2 = pmp_2 - 1.5*gam(i,k-1) + a4(3,i,k) = min(max(a4(3,i,k), min(a4(1,i,k), pmp_2, lac_2)), & + max(a4(1,i,k), pmp_2, lac_2) ) + a4(4,i,k) = 6.*a4(1,i,k) - 3.*(a4(2,i,k)+a4(3,i,k)) + endif + endif + enddo + elseif ( abs(kord)==13 ) then + do i=i1,i2 + if( ext6(i,k) ) then + if ( ext6(i,k-1) .and. ext6(i,k+1) ) then +! grid-scale 2-delta-z wave detected + a4(2,i,k) = a4(1,i,k) + a4(3,i,k) = a4(1,i,k) + endif + endif + enddo + do i=i1,i2 + a4(4,i,k) = 3.*(2.*a4(1,i,k) - (a4(2,i,k)+a4(3,i,k))) + enddo + elseif ( abs(kord)==14 ) then + + do i=i1,i2 + a4(4,i,k) = 3.*(2.*a4(1,i,k) - (a4(2,i,k)+a4(3,i,k))) + enddo + + elseif ( abs(kord)==15 ) then ! revised kord=9 scehem + do i=i1,i2 + if ( ext5(i,k) ) then ! c90_mp122 + if ( ext5(i,k-1) .or. ext5(i,k+1) ) then ! c90_mp122 +! grid-scale 2-delta-z wave detected + a4(2,i,k) = a4(1,i,k) + a4(3,i,k) = a4(1,i,k) + endif + elseif( ext6(i,k) ) then +! Check within the smooth region if subgrid profile is non-monotonic + pmp_1 = a4(1,i,k) - 2.*gam(i,k+1) + lac_1 = pmp_1 + 1.5*gam(i,k+2) + a4(2,i,k) = min(max(a4(2,i,k), min(a4(1,i,k), pmp_1, lac_1)), & + max(a4(1,i,k), pmp_1, lac_1) ) + pmp_2 = a4(1,i,k) + 2.*gam(i,k) + lac_2 = pmp_2 - 1.5*gam(i,k-1) + a4(3,i,k) = min(max(a4(3,i,k), min(a4(1,i,k), pmp_2, lac_2)), & + max(a4(1,i,k), pmp_2, lac_2) ) + endif + enddo + do i=i1,i2 + a4(4,i,k) = 3.*(2.*a4(1,i,k) - (a4(2,i,k)+a4(3,i,k))) + enddo + elseif ( abs(kord)==16 ) then + do i=i1,i2 + if( ext5(i,k) ) then + if ( ext5(i,k-1) .or. ext5(i,k+1) ) then + a4(2,i,k) = a4(1,i,k) + a4(3,i,k) = a4(1,i,k) + elseif ( ext6(i,k-1) .or. ext6(i,k+1) ) then + ! Left edges + pmp_1 = a4(1,i,k) - 2.*gam(i,k+1) + lac_1 = pmp_1 + 1.5*gam(i,k+2) + a4(2,i,k) = min(max(a4(2,i,k), min(a4(1,i,k), pmp_1, lac_1)), & + max(a4(1,i,k), pmp_1, lac_1) ) + ! Right edges + pmp_2 = a4(1,i,k) + 2.*gam(i,k) + lac_2 = pmp_2 - 1.5*gam(i,k-1) + a4(3,i,k) = min(max(a4(3,i,k), min(a4(1,i,k), pmp_2, lac_2)), & + max(a4(1,i,k), pmp_2, lac_2) ) + endif + endif + enddo + do i=i1,i2 + a4(4,i,k) = 3.*(2.*a4(1,i,k) - (a4(2,i,k)+a4(3,i,k))) + enddo + else ! kord = 11 + do i=i1,i2 + if ( ext5(i,k) .and. (ext5(i,k-1) .or. ext5(i,k+1)) ) then +! Noisy region: + a4(2,i,k) = a4(1,i,k) + a4(3,i,k) = a4(1,i,k) + a4(4,i,k) = 0. + else + a4(4,i,k) = 3.*(2.*a4(1,i,k) - (a4(2,i,k)+a4(3,i,k))) + endif + enddo + endif + +! Additional constraint to ensure positivity + if ( iv==0 ) call cs_limiters_real4(im, extm(i1,k), a4(1,i1,k), 0) + + enddo ! k-loop + +!---------------------------------- +! Bottom layer subgrid constraints: +!---------------------------------- + if ( iv==0 ) then + do i=i1,i2 + a4(3,i,km) = max(0., a4(3,i,km)) + enddo + elseif ( iv .eq. -1 ) then + do i=i1,i2 + if ( a4(3,i,km)*a4(1,i,km) <= 0. ) a4(3,i,km) = 0. + enddo + endif + + do k=km-1,km + do i=i1,i2 + a4(4,i,k) = 3.*(2.*a4(1,i,k) - (a4(2,i,k)+a4(3,i,k))) + enddo + if(k==(km-1)) call cs_limiters_real4(im, extm(i1,k), a4(1,i1,k), 2) + if(k== km ) call cs_limiters_real4(im, extm(i1,k), a4(1,i1,k), 1) + enddo + + end subroutine cs_profile_real4 + + subroutine cs_limiters_real4(im, extm, a4, iv) + integer, intent(in) :: im + integer, intent(in) :: iv + logical, intent(in) :: extm(im) + real(kind=4) , intent(inout) :: a4(4,im) ! PPM array +! !LOCAL VARIABLES: + real(kind=4) da1, da2, a6da + integer i + + if ( iv==0 ) then +! Positive definite constraint + do i=1,im + if( a4(1,i)<=0.) then + a4(2,i) = a4(1,i) + a4(3,i) = a4(1,i) + a4(4,i) = 0. + else + if( abs(a4(3,i)-a4(2,i)) < -a4(4,i) ) then + if( (a4(1,i)+0.25*(a4(3,i)-a4(2,i))**2/a4(4,i)+a4(4,i)*r12_real4) < 0. ) then +! local minimum is negative + if( a4(1,i) a4(2,i) ) then + a4(4,i) = 3.*(a4(2,i)-a4(1,i)) + a4(3,i) = a4(2,i) - a4(4,i) + else + a4(4,i) = 3.*(a4(3,i)-a4(1,i)) + a4(2,i) = a4(3,i) - a4(4,i) + endif + endif + endif + endif + enddo + elseif ( iv==1 ) then + do i=1,im + if( (a4(1,i)-a4(2,i))*(a4(1,i)-a4(3,i))>=0. ) then + a4(2,i) = a4(1,i) + a4(3,i) = a4(1,i) + a4(4,i) = 0. + else + da1 = a4(3,i) - a4(2,i) + da2 = da1**2 + a6da = a4(4,i)*da1 + if(a6da < -da2) then + a4(4,i) = 3.*(a4(2,i)-a4(1,i)) + a4(3,i) = a4(2,i) - a4(4,i) + elseif(a6da > da2) then + a4(4,i) = 3.*(a4(3,i)-a4(1,i)) + a4(2,i) = a4(3,i) - a4(4,i) + endif + endif + enddo + else +! Standard PPM constraint + do i=1,im + if( extm(i) ) then + a4(2,i) = a4(1,i) + a4(3,i) = a4(1,i) + a4(4,i) = 0. + else + da1 = a4(3,i) - a4(2,i) + da2 = da1**2 + a6da = a4(4,i)*da1 + if(a6da < -da2) then + a4(4,i) = 3.*(a4(2,i)-a4(1,i)) + a4(3,i) = a4(2,i) - a4(4,i) + elseif(a6da > da2) then + a4(4,i) = 3.*(a4(3,i)-a4(1,i)) + a4(2,i) = a4(3,i) - a4(4,i) + endif + endif + enddo + endif + end subroutine cs_limiters_real4 + + subroutine cs_profile_real8(qs, a4, delp, km, i1, i2, iv, kord) +! Optimized vertical profile reconstruction: +! Latest: Apr 2008 S.-J. Lin, NOAA/GFDL + integer, intent(in):: i1, i2 + integer, intent(in):: km ! vertical dimension + integer, intent(in):: iv ! iv =-2: vertical velocity + ! iv =-1: winds + ! iv = 0: positive definite scalars + ! iv = 1: others + integer, intent(in):: kord + real(kind=8), intent(in) :: qs(i1:i2) + real(kind=8), intent(in) :: delp(i1:i2,km) ! layer pressure thickness + real(kind=8), intent(inout):: a4(4,i1:i2,km) ! Interpolated values +!----------------------------------------------------------------------- + logical, dimension(i1:i2,km):: extm, ext5, ext6 + real(kind=8) gam(i1:i2,km) + real(kind=8) q(i1:i2,km+1) ! interface values + real(kind=8) d4(i1:i2) + real(kind=8) bet, a_bot, grat + real(kind=8) pmp_1, lac_1, pmp_2, lac_2, x0, x1 + integer i, k, im + + if ( iv .eq. -2 ) then + do i=i1,i2 + gam(i,2) = 0.5 + q(i,1) = 1.5*a4(1,i,1) + enddo + do k=2,km-1 + do i=i1, i2 + grat = delp(i,k-1) / delp(i,k) + bet = 2. + grat + grat - gam(i,k) + q(i,k) = (3.*(a4(1,i,k-1)+a4(1,i,k)) - q(i,k-1))/bet + gam(i,k+1) = grat / bet + enddo + enddo + do i=i1,i2 + grat = delp(i,km-1) / delp(i,km) + q(i,km) = (3.*(a4(1,i,km-1)+a4(1,i,km)) - grat*qs(i) - q(i,km-1)) / & + (2. + grat + grat - gam(i,km)) + q(i,km+1) = qs(i) + enddo + do k=km-1,1,-1 + do i=i1,i2 + q(i,k) = q(i,k) - gam(i,k+1)*q(i,k+1) + enddo + enddo + +else ! all others + do i=i1,i2 + grat = delp(i,2) / delp(i,1) ! grid ratio + bet = grat*(grat+0.5) + q(i,1) = ( (grat+grat)*(grat+1.)*a4(1,i,1) + a4(1,i,2) ) / bet + gam(i,1) = ( 1. + grat*(grat+1.5) ) / bet + enddo + + if (iv.eq.-3) then !LBC for vertical velocities + do k=2,km-1 + do i=i1,i2 + d4(i) = delp(i,k-1) / delp(i,k) + bet = 2. + d4(i) + d4(i) - gam(i,k-1) + q(i,k) = ( 3.*(a4(1,i,k-1)+d4(i)*a4(1,i,k)) - q(i,k-1) )/bet + gam(i,k) = d4(i) / bet + enddo + enddo + + do i=i1,i2 + ! a_bot = 1. + d4(i)*(d4(i)+1.5) + !q(i,km+1) = (2.*d4(i)*(d4(i)+1.)*a4(1,i,km)+a4(1,i,km-1)-a_bot*q(i,km)) & + ! / ( d4(i)*(d4(i)+0.5) - a_bot*gam(i,km) ) + d4(i) = delp(i,km-1) / delp(i,km) + bet = 2. + d4(i) + d4(i) - gam(i,km-1) + grat = delp(i,km-1) / delp(i,km) + q(i,km) = ( 3.*(a4(1,i,k-1)+d4(i)*a4(1,i,k)) - grat*qs(i) - q(i,k-1) )/bet + q(i,km+1) = qs(i) + enddo + + else ! all others + do k=2,km + do i=i1,i2 + d4(i) = delp(i,k-1) / delp(i,k) + bet = 2. + d4(i) + d4(i) - gam(i,k-1) + q(i,k) = ( 3.*(a4(1,i,k-1)+d4(i)*a4(1,i,k)) - q(i,k-1) )/bet + gam(i,k) = d4(i) / bet + enddo + enddo + + do i=i1,i2 + a_bot = 1. + d4(i)*(d4(i)+1.5) + q(i,km+1) = (2.*d4(i)*(d4(i)+1.)*a4(1,i,km)+a4(1,i,km-1)-a_bot*q(i,km)) & + / ( d4(i)*(d4(i)+0.5) - a_bot*gam(i,km) ) + enddo + endif + + do k=km,1,-1 + do i=i1,i2 + q(i,k) = q(i,k) - gam(i,k)*q(i,k+1) + enddo + enddo + endif +!----- Perfectly linear scheme -------------------------------- + if ( abs(kord) > 16 ) then + do k=1,km + do i=i1,i2 + a4(2,i,k) = q(i,k ) + a4(3,i,k) = q(i,k+1) + a4(4,i,k) = 3.*(2.*a4(1,i,k) - (a4(2,i,k)+a4(3,i,k))) + enddo + enddo + return + endif +!----- Perfectly linear scheme -------------------------------- + +!------------------ +! Apply constraints +!------------------ + im = i2 - i1 + 1 + +! Apply *large-scale* constraints + do i=i1,i2 + q(i,2) = min( q(i,2), max(a4(1,i,1), a4(1,i,2)) ) + q(i,2) = max( q(i,2), min(a4(1,i,1), a4(1,i,2)) ) + enddo + + do k=2,km + do i=i1,i2 + gam(i,k) = a4(1,i,k) - a4(1,i,k-1) ! now dq + enddo + enddo + +! Interior: + do k=3,km-1 + do i=i1,i2 + if ( gam(i,k-1)*gam(i,k+1)>0. ) then +! Apply large-scale constraint to ALL fields if not local max/min + q(i,k) = min( q(i,k), max(a4(1,i,k-1),a4(1,i,k)) ) + q(i,k) = max( q(i,k), min(a4(1,i,k-1),a4(1,i,k)) ) + else + if ( gam(i,k-1) > 0. ) then +! There exists a local max + q(i,k) = max(q(i,k), min(a4(1,i,k-1),a4(1,i,k))) + else +! There exists a local min + q(i,k) = min(q(i,k), max(a4(1,i,k-1),a4(1,i,k))) + if ( iv==0 ) q(i,k) = max(0., q(i,k)) ! positive-definite + endif + endif + enddo + enddo + +! Bottom: + do i=i1,i2 + q(i,km) = min( q(i,km), max(a4(1,i,km-1), a4(1,i,km)) ) + q(i,km) = max( q(i,km), min(a4(1,i,km-1), a4(1,i,km)) ) + enddo + + do k=1,km + do i=i1,i2 + a4(2,i,k) = q(i,k ) + a4(3,i,k) = q(i,k+1) + enddo + enddo + + do k=1,km + if ( k==1 .or. k==km ) then + do i=i1,i2 + extm(i,k) = (a4(2,i,k)-a4(1,i,k)) * (a4(3,i,k)-a4(1,i,k)) > 0. + enddo + else + do i=i1,i2 + extm(i,k) = gam(i,k)*gam(i,k+1) < 0. + enddo + endif + if ( abs(kord) > 9 ) then + do i=i1,i2 + x0 = 2.*a4(1,i,k) - (a4(2,i,k)+a4(3,i,k)) + x1 = abs(a4(2,i,k)-a4(3,i,k)) + a4(4,i,k) = 3.*x0 + ext5(i,k) = abs(x0) > x1 + ext6(i,k) = abs(a4(4,i,k)) > x1 + enddo + endif + enddo + +!--------------------------- +! Apply subgrid constraints: +!--------------------------- +! f(s) = AL + s*[(AR-AL) + A6*(1-s)] ( 0 <= s <= 1 ) +! Top 2 and bottom 2 layers always use monotonic mapping + + if ( iv==0 ) then + do i=i1,i2 + a4(2,i,1) = max(0., a4(2,i,1)) + enddo + elseif ( iv==-1 ) then + do i=i1,i2 + if ( a4(2,i,1)*a4(1,i,1) <= 0. ) a4(2,i,1) = 0. + enddo + elseif ( iv==2 ) then + do i=i1,i2 + a4(2,i,1) = a4(1,i,1) + a4(3,i,1) = a4(1,i,1) + a4(4,i,1) = 0. + enddo + endif + + if ( iv/=2 ) then + do i=i1,i2 + a4(4,i,1) = 3.*(2.*a4(1,i,1) - (a4(2,i,1)+a4(3,i,1))) + enddo + call cs_limiters_real8(im, extm(i1,1), a4(1,i1,1), 1) + endif + +! k=2 + do i=i1,i2 + a4(4,i,2) = 3.*(2.*a4(1,i,2) - (a4(2,i,2)+a4(3,i,2))) + enddo + call cs_limiters_real8(im, extm(i1,2), a4(1,i1,2), 2) + +!------------------------------------- +! Huynh's 2nd constraint for interior: +!------------------------------------- + do k=3,km-2 + if ( abs(kord)<9 ) then + do i=i1,i2 +! Left edges + pmp_1 = a4(1,i,k) - 2.*gam(i,k+1) + lac_1 = pmp_1 + 1.5*gam(i,k+2) + a4(2,i,k) = min(max(a4(2,i,k), min(a4(1,i,k), pmp_1, lac_1)), & + max(a4(1,i,k), pmp_1, lac_1) ) +! Right edges + pmp_2 = a4(1,i,k) + 2.*gam(i,k) + lac_2 = pmp_2 - 1.5*gam(i,k-1) + a4(3,i,k) = min(max(a4(3,i,k), min(a4(1,i,k), pmp_2, lac_2)), & + max(a4(1,i,k), pmp_2, lac_2) ) + + a4(4,i,k) = 3.*(2.*a4(1,i,k) - (a4(2,i,k)+a4(3,i,k))) + enddo + + elseif ( abs(kord)==9 ) then + do i=i1,i2 + if ( extm(i,k) .and. extm(i,k-1) ) then ! c90_mp122 +! grid-scale 2-delta-z wave detected + a4(2,i,k) = a4(1,i,k) + a4(3,i,k) = a4(1,i,k) + a4(4,i,k) = 0. + else if ( extm(i,k) .and. extm(i,k+1) ) then ! c90_mp122 +! grid-scale 2-delta-z wave detected + a4(2,i,k) = a4(1,i,k) + a4(3,i,k) = a4(1,i,k) + a4(4,i,k) = 0. + else + a4(4,i,k) = 6.*a4(1,i,k) - 3.*(a4(2,i,k)+a4(3,i,k)) +! Check within the smooth region if subgrid profile is non-monotonic + if( abs(a4(4,i,k)) > abs(a4(2,i,k)-a4(3,i,k)) ) then + pmp_1 = a4(1,i,k) - 2.*gam(i,k+1) + lac_1 = pmp_1 + 1.5*gam(i,k+2) + a4(2,i,k) = min(max(a4(2,i,k), min(a4(1,i,k), pmp_1, lac_1)), & + max(a4(1,i,k), pmp_1, lac_1) ) + pmp_2 = a4(1,i,k) + 2.*gam(i,k) + lac_2 = pmp_2 - 1.5*gam(i,k-1) + a4(3,i,k) = min(max(a4(3,i,k), min(a4(1,i,k), pmp_2, lac_2)), & + max(a4(1,i,k), pmp_2, lac_2) ) + a4(4,i,k) = 6.*a4(1,i,k) - 3.*(a4(2,i,k)+a4(3,i,k)) + endif + endif + enddo + elseif ( abs(kord)==10 ) then + do i=i1,i2 + if( ext5(i,k) ) then + if( ext5(i,k-1) .or. ext5(i,k+1) ) then + a4(2,i,k) = a4(1,i,k) + a4(3,i,k) = a4(1,i,k) + elseif ( ext6(i,k-1) .or. ext6(i,k+1) ) then + pmp_1 = a4(1,i,k) - 2.*gam(i,k+1) + lac_1 = pmp_1 + 1.5*gam(i,k+2) + a4(2,i,k) = min(max(a4(2,i,k), min(a4(1,i,k), pmp_1, lac_1)), & + max(a4(1,i,k), pmp_1, lac_1) ) + pmp_2 = a4(1,i,k) + 2.*gam(i,k) + lac_2 = pmp_2 - 1.5*gam(i,k-1) + a4(3,i,k) = min(max(a4(3,i,k), min(a4(1,i,k), pmp_2, lac_2)), & + max(a4(1,i,k), pmp_2, lac_2) ) + endif + elseif( ext6(i,k) ) then + if( ext5(i,k-1) .or. ext5(i,k+1) ) then + pmp_1 = a4(1,i,k) - 2.*gam(i,k+1) + lac_1 = pmp_1 + 1.5*gam(i,k+2) + a4(2,i,k) = min(max(a4(2,i,k), min(a4(1,i,k), pmp_1, lac_1)), & + max(a4(1,i,k), pmp_1, lac_1) ) + pmp_2 = a4(1,i,k) + 2.*gam(i,k) + lac_2 = pmp_2 - 1.5*gam(i,k-1) + a4(3,i,k) = min(max(a4(3,i,k), min(a4(1,i,k), pmp_2, lac_2)), & + max(a4(1,i,k), pmp_2, lac_2) ) + endif + endif + enddo + do i=i1,i2 + a4(4,i,k) = 3.*(2.*a4(1,i,k) - (a4(2,i,k)+a4(3,i,k))) + enddo + elseif ( abs(kord)==12 ) then + do i=i1,i2 + if( extm(i,k) ) then +! grid-scale 2-delta-z wave detected + a4(2,i,k) = a4(1,i,k) + a4(3,i,k) = a4(1,i,k) + a4(4,i,k) = 0. + else ! not a local extremum + a4(4,i,k) = 6.*a4(1,i,k) - 3.*(a4(2,i,k)+a4(3,i,k)) +! Check within the smooth region if subgrid profile is non-monotonic + if( abs(a4(4,i,k)) > abs(a4(2,i,k)-a4(3,i,k)) ) then + pmp_1 = a4(1,i,k) - 2.*gam(i,k+1) + lac_1 = pmp_1 + 1.5*gam(i,k+2) + a4(2,i,k) = min(max(a4(2,i,k), min(a4(1,i,k), pmp_1, lac_1)), & + max(a4(1,i,k), pmp_1, lac_1) ) + pmp_2 = a4(1,i,k) + 2.*gam(i,k) + lac_2 = pmp_2 - 1.5*gam(i,k-1) + a4(3,i,k) = min(max(a4(3,i,k), min(a4(1,i,k), pmp_2, lac_2)), & + max(a4(1,i,k), pmp_2, lac_2) ) + a4(4,i,k) = 6.*a4(1,i,k) - 3.*(a4(2,i,k)+a4(3,i,k)) + endif + endif + enddo + elseif ( abs(kord)==13 ) then + do i=i1,i2 + if( ext6(i,k) ) then + if ( ext6(i,k-1) .and. ext6(i,k+1) ) then +! grid-scale 2-delta-z wave detected + a4(2,i,k) = a4(1,i,k) + a4(3,i,k) = a4(1,i,k) + endif + endif + enddo + do i=i1,i2 + a4(4,i,k) = 3.*(2.*a4(1,i,k) - (a4(2,i,k)+a4(3,i,k))) + enddo + elseif ( abs(kord)==14 ) then + + do i=i1,i2 + a4(4,i,k) = 3.*(2.*a4(1,i,k) - (a4(2,i,k)+a4(3,i,k))) + enddo + + elseif ( abs(kord)==15 ) then ! revised kord=9 scehem + do i=i1,i2 + if ( ext5(i,k) ) then ! c90_mp122 + if ( ext5(i,k-1) .or. ext5(i,k+1) ) then ! c90_mp122 +! grid-scale 2-delta-z wave detected + a4(2,i,k) = a4(1,i,k) + a4(3,i,k) = a4(1,i,k) + endif + elseif( ext6(i,k) ) then +! Check within the smooth region if subgrid profile is non-monotonic + pmp_1 = a4(1,i,k) - 2.*gam(i,k+1) + lac_1 = pmp_1 + 1.5*gam(i,k+2) + a4(2,i,k) = min(max(a4(2,i,k), min(a4(1,i,k), pmp_1, lac_1)), & + max(a4(1,i,k), pmp_1, lac_1) ) + pmp_2 = a4(1,i,k) + 2.*gam(i,k) + lac_2 = pmp_2 - 1.5*gam(i,k-1) + a4(3,i,k) = min(max(a4(3,i,k), min(a4(1,i,k), pmp_2, lac_2)), & + max(a4(1,i,k), pmp_2, lac_2) ) + endif + enddo + do i=i1,i2 + a4(4,i,k) = 3.*(2.*a4(1,i,k) - (a4(2,i,k)+a4(3,i,k))) + enddo + elseif ( abs(kord)==16 ) then + do i=i1,i2 + if( ext5(i,k) ) then + if ( ext5(i,k-1) .or. ext5(i,k+1) ) then + a4(2,i,k) = a4(1,i,k) + a4(3,i,k) = a4(1,i,k) + elseif ( ext6(i,k-1) .or. ext6(i,k+1) ) then + ! Left edges + pmp_1 = a4(1,i,k) - 2.*gam(i,k+1) + lac_1 = pmp_1 + 1.5*gam(i,k+2) + a4(2,i,k) = min(max(a4(2,i,k), min(a4(1,i,k), pmp_1, lac_1)), & + max(a4(1,i,k), pmp_1, lac_1) ) + ! Right edges + pmp_2 = a4(1,i,k) + 2.*gam(i,k) + lac_2 = pmp_2 - 1.5*gam(i,k-1) + a4(3,i,k) = min(max(a4(3,i,k), min(a4(1,i,k), pmp_2, lac_2)), & + max(a4(1,i,k), pmp_2, lac_2) ) + endif + endif + enddo + do i=i1,i2 + a4(4,i,k) = 3.*(2.*a4(1,i,k) - (a4(2,i,k)+a4(3,i,k))) + enddo + else ! kord = 11 + do i=i1,i2 + if ( ext5(i,k) .and. (ext5(i,k-1) .or. ext5(i,k+1)) ) then +! Noisy region: + a4(2,i,k) = a4(1,i,k) + a4(3,i,k) = a4(1,i,k) + a4(4,i,k) = 0. + else + a4(4,i,k) = 3.*(2.*a4(1,i,k) - (a4(2,i,k)+a4(3,i,k))) + endif + enddo + endif + +! Additional constraint to ensure positivity + if ( iv==0 ) call cs_limiters_real8(im, extm(i1,k), a4(1,i1,k), 0) + + enddo ! k-loop + +!---------------------------------- +! Bottom layer subgrid constraints: +!---------------------------------- + if ( iv==0 ) then + do i=i1,i2 + a4(3,i,km) = max(0., a4(3,i,km)) + enddo + elseif ( iv .eq. -1 ) then + do i=i1,i2 + if ( a4(3,i,km)*a4(1,i,km) <= 0. ) a4(3,i,km) = 0. + enddo + endif + + do k=km-1,km + do i=i1,i2 + a4(4,i,k) = 3.*(2.*a4(1,i,k) - (a4(2,i,k)+a4(3,i,k))) + enddo + if(k==(km-1)) call cs_limiters_real8(im, extm(i1,k), a4(1,i1,k), 2) + if(k== km ) call cs_limiters_real8(im, extm(i1,k), a4(1,i1,k), 1) + enddo + + end subroutine cs_profile_real8 + + subroutine cs_limiters_real8(im, extm, a4, iv) + integer, intent(in) :: im + integer, intent(in) :: iv + logical, intent(in) :: extm(im) + real(kind=8) , intent(inout) :: a4(4,im) ! PPM array +! !LOCAL VARIABLES: + real(kind=8) da1, da2, a6da + integer i + + if ( iv==0 ) then +! Positive definite constraint + do i=1,im + if( a4(1,i)<=0.) then + a4(2,i) = a4(1,i) + a4(3,i) = a4(1,i) + a4(4,i) = 0. + else + if( abs(a4(3,i)-a4(2,i)) < -a4(4,i) ) then + if( (a4(1,i)+0.25*(a4(3,i)-a4(2,i))**2/a4(4,i)+a4(4,i)*r12_real8) < 0. ) then +! local minimum is negative + if( a4(1,i) a4(2,i) ) then + a4(4,i) = 3.*(a4(2,i)-a4(1,i)) + a4(3,i) = a4(2,i) - a4(4,i) + else + a4(4,i) = 3.*(a4(3,i)-a4(1,i)) + a4(2,i) = a4(3,i) - a4(4,i) + endif + endif + endif + endif + enddo + elseif ( iv==1 ) then + do i=1,im + if( (a4(1,i)-a4(2,i))*(a4(1,i)-a4(3,i))>=0. ) then + a4(2,i) = a4(1,i) + a4(3,i) = a4(1,i) + a4(4,i) = 0. + else + da1 = a4(3,i) - a4(2,i) + da2 = da1**2 + a6da = a4(4,i)*da1 + if(a6da < -da2) then + a4(4,i) = 3.*(a4(2,i)-a4(1,i)) + a4(3,i) = a4(2,i) - a4(4,i) + elseif(a6da > da2) then + a4(4,i) = 3.*(a4(3,i)-a4(1,i)) + a4(2,i) = a4(3,i) - a4(4,i) + endif + endif + enddo + else +! Standard PPM constraint + do i=1,im + if( extm(i) ) then + a4(2,i) = a4(1,i) + a4(3,i) = a4(1,i) + a4(4,i) = 0. + else + da1 = a4(3,i) - a4(2,i) + da2 = da1**2 + a6da = a4(4,i)*da1 + if(a6da < -da2) then + a4(4,i) = 3.*(a4(2,i)-a4(1,i)) + a4(3,i) = a4(2,i) - a4(4,i) + elseif(a6da > da2) then + a4(4,i) = 3.*(a4(3,i)-a4(1,i)) + a4(2,i) = a4(3,i) - a4(4,i) + endif + endif + enddo + endif + end subroutine cs_limiters_real8 + + subroutine ppm_profile_real4(a4, delp, km, i1, i2, iv, kord) + +! !INPUT PARAMETERS: + integer, intent(in):: iv ! iv =-1: winds + ! iv = 0: positive definite scalars + ! iv = 1: others + ! iv = 2: temp (if remap_t) and w (iv=-2) + integer, intent(in):: i1 ! Starting longitude + integer, intent(in):: i2 ! Finishing longitude + integer, intent(in):: km ! vertical dimension + integer, intent(in):: kord ! Order (or more accurately method no.): + ! + real(kind=4) , intent(in):: delp(i1:i2,km) ! layer pressure thickness + +! !INPUT/OUTPUT PARAMETERS: + real(kind=4) , intent(inout):: a4(4,i1:i2,km) ! Interpolated values + +! DESCRIPTION: +! +! Perform the piecewise parabolic reconstruction +! +! !REVISION HISTORY: +! S.-J. Lin revised at GFDL 2007 +!----------------------------------------------------------------------- +! local arrays: + real(kind=4) dc(i1:i2,km) + real(kind=4) h2(i1:i2,km) + real(kind=4) delq(i1:i2,km) + real(kind=4) df2(i1:i2,km) + real(kind=4) d4(i1:i2,km) + +! local scalars: + integer i, k, km1, lmt, it + real(kind=4) fac + real(kind=4) a1, a2, c1, c2, c3, d1, d2 + real(kind=4) qm, dq, lac, qmp, pmp + + km1 = km - 1 + it = i2 - i1 + 1 + + do k=2,km + do i=i1,i2 + delq(i,k-1) = a4(1,i,k) - a4(1,i,k-1) + d4(i,k ) = delp(i,k-1) + delp(i,k) + enddo + enddo + + do k=2,km1 + do i=i1,i2 + c1 = (delp(i,k-1)+0.5*delp(i,k))/d4(i,k+1) + c2 = (delp(i,k+1)+0.5*delp(i,k))/d4(i,k) + df2(i,k) = delp(i,k)*(c1*delq(i,k) + c2*delq(i,k-1)) / & + (d4(i,k)+delp(i,k+1)) + dc(i,k) = sign( min(abs(df2(i,k)), & + max(a4(1,i,k-1),a4(1,i,k),a4(1,i,k+1))-a4(1,i,k), & + a4(1,i,k)-min(a4(1,i,k-1),a4(1,i,k),a4(1,i,k+1))), df2(i,k) ) + enddo + enddo + +!----------------------------------------------------------- +! 4th order interpolation of the provisional cell edge value +!----------------------------------------------------------- + + do k=3,km1 + do i=i1,i2 + c1 = delq(i,k-1)*delp(i,k-1) / d4(i,k) + a1 = d4(i,k-1) / (d4(i,k) + delp(i,k-1)) + a2 = d4(i,k+1) / (d4(i,k) + delp(i,k)) + a4(2,i,k) = a4(1,i,k-1) + c1 + 2./(d4(i,k-1)+d4(i,k+1)) * & + ( delp(i,k)*(c1*(a1 - a2)+a2*dc(i,k-1)) - & + delp(i,k-1)*a1*dc(i,k ) ) + enddo + enddo + +! if(km>8 .and. kord>4) call steepz(i1, i2, km, a4, df2, dc, delq, delp, d4) + +! Area preserving cubic with 2nd deriv. = 0 at the boundaries +! Top + do i=i1,i2 + d1 = delp(i,1) + d2 = delp(i,2) + qm = (d2*a4(1,i,1)+d1*a4(1,i,2)) / (d1+d2) + dq = 2.*(a4(1,i,2)-a4(1,i,1)) / (d1+d2) + c1 = 4.*(a4(2,i,3)-qm-d2*dq) / ( d2*(2.*d2*d2+d1*(d2+3.*d1)) ) + c3 = dq - 0.5*c1*(d2*(5.*d1+d2)-3.*d1*d1) + a4(2,i,2) = qm - 0.25*c1*d1*d2*(d2+3.*d1) +! Top edge: +!------------------------------------------------------- + a4(2,i,1) = d1*(2.*c1*d1**2-c3) + a4(2,i,2) +!------------------------------------------------------- +! a4(2,i,1) = (12./7.)*a4(1,i,1)-(13./14.)*a4(1,i,2)+(3./14.)*a4(1,i,3) +!------------------------------------------------------- +! No over- and undershoot condition + a4(2,i,2) = max( a4(2,i,2), min(a4(1,i,1), a4(1,i,2)) ) + a4(2,i,2) = min( a4(2,i,2), max(a4(1,i,1), a4(1,i,2)) ) + dc(i,1) = 0.5*(a4(2,i,2) - a4(1,i,1)) + enddo + +! Enforce monotonicity within the top layer + + if( iv==0 ) then + do i=i1,i2 + a4(2,i,1) = max(0., a4(2,i,1)) + a4(2,i,2) = max(0., a4(2,i,2)) + enddo + elseif( iv==-1 ) then + do i=i1,i2 + if ( a4(2,i,1)*a4(1,i,1) <= 0. ) a4(2,i,1) = 0. + enddo + elseif( abs(iv)==2 ) then + do i=i1,i2 + a4(2,i,1) = a4(1,i,1) + a4(3,i,1) = a4(1,i,1) + enddo + endif + +! Bottom +! Area preserving cubic with 2nd deriv. = 0 at the surface + do i=i1,i2 + d1 = delp(i,km) + d2 = delp(i,km1) + qm = (d2*a4(1,i,km)+d1*a4(1,i,km1)) / (d1+d2) + dq = 2.*(a4(1,i,km1)-a4(1,i,km)) / (d1+d2) + c1 = (a4(2,i,km1)-qm-d2*dq) / (d2*(2.*d2*d2+d1*(d2+3.*d1))) + c3 = dq - 2.0*c1*(d2*(5.*d1+d2)-3.*d1*d1) + a4(2,i,km) = qm - c1*d1*d2*(d2+3.*d1) +! Bottom edge: +!----------------------------------------------------- + a4(3,i,km) = d1*(8.*c1*d1**2-c3) + a4(2,i,km) +! dc(i,km) = 0.5*(a4(3,i,km) - a4(1,i,km)) +!----------------------------------------------------- +! a4(3,i,km) = (12./7.)*a4(1,i,km)-(13./14.)*a4(1,i,km-1)+(3./14.)*a4(1,i,km-2) +! No over- and under-shoot condition + a4(2,i,km) = max( a4(2,i,km), min(a4(1,i,km), a4(1,i,km1)) ) + a4(2,i,km) = min( a4(2,i,km), max(a4(1,i,km), a4(1,i,km1)) ) + dc(i,km) = 0.5*(a4(1,i,km) - a4(2,i,km)) + enddo + + +! Enforce constraint on the "slope" at the surface + +#ifdef BOT_MONO + do i=i1,i2 + a4(4,i,km) = 0 + if( a4(3,i,km) * a4(1,i,km) <= 0. ) a4(3,i,km) = 0. + d1 = a4(1,i,km) - a4(2,i,km) + d2 = a4(3,i,km) - a4(1,i,km) + if ( d1*d2 < 0. ) then + a4(2,i,km) = a4(1,i,km) + a4(3,i,km) = a4(1,i,km) + else + dq = sign(min(abs(d1),abs(d2),0.5*abs(delq(i,km-1))), d1) + a4(2,i,km) = a4(1,i,km) - dq + a4(3,i,km) = a4(1,i,km) + dq + endif + enddo +#else + if( iv==0 ) then + do i=i1,i2 + a4(2,i,km) = max(0.,a4(2,i,km)) + a4(3,i,km) = max(0.,a4(3,i,km)) + enddo + elseif( iv<0 ) then + do i=i1,i2 + if( a4(1,i,km)*a4(3,i,km) <= 0. ) a4(3,i,km) = 0. + enddo + endif +#endif + + do k=1,km1 + do i=i1,i2 + a4(3,i,k) = a4(2,i,k+1) + enddo + enddo + +!----------------------------------------------------------- +! f(s) = AL + s*[(AR-AL) + A6*(1-s)] ( 0 <= s <= 1 ) +!----------------------------------------------------------- +! Top 2 and bottom 2 layers always use monotonic mapping + do k=1,2 + do i=i1,i2 + a4(4,i,k) = 3.*(2.*a4(1,i,k) - (a4(2,i,k)+a4(3,i,k))) + enddo + call ppm_limiters_real4(dc(i1,k), a4(1,i1,k), it, 0) + enddo + + if(kord >= 7) then +!----------------------- +! Huynh's 2nd constraint +!----------------------- + do k=2,km1 + do i=i1,i2 +! Method#1 +! h2(i,k) = delq(i,k) - delq(i,k-1) +! Method#2 - better + h2(i,k) = 2.*(dc(i,k+1)/delp(i,k+1) - dc(i,k-1)/delp(i,k-1)) & + / ( delp(i,k)+0.5*(delp(i,k-1)+delp(i,k+1)) ) & + * delp(i,k)**2 +! Method#3 +!!! h2(i,k) = dc(i,k+1) - dc(i,k-1) + enddo + enddo + + fac = 1.5 ! original quasi-monotone + + do k=3,km-2 + do i=i1,i2 +! Right edges +! qmp = a4(1,i,k) + 2.0*delq(i,k-1) +! lac = a4(1,i,k) + fac*h2(i,k-1) + 0.5*delq(i,k-1) +! + pmp = 2.*dc(i,k) + qmp = a4(1,i,k) + pmp + lac = a4(1,i,k) + fac*h2(i,k-1) + dc(i,k) + a4(3,i,k) = min(max(a4(3,i,k), min(a4(1,i,k), qmp, lac)), & + max(a4(1,i,k), qmp, lac) ) +! Left edges +! qmp = a4(1,i,k) - 2.0*delq(i,k) +! lac = a4(1,i,k) + fac*h2(i,k+1) - 0.5*delq(i,k) +! + qmp = a4(1,i,k) - pmp + lac = a4(1,i,k) + fac*h2(i,k+1) - dc(i,k) + a4(2,i,k) = min(max(a4(2,i,k), min(a4(1,i,k), qmp, lac)), & + max(a4(1,i,k), qmp, lac)) +!------------- +! Recompute A6 +!------------- + a4(4,i,k) = 3.*(2.*a4(1,i,k) - (a4(2,i,k)+a4(3,i,k))) + enddo +! Additional constraint to ensure positivity when kord=7 + if (iv == 0 .and. kord >= 6 ) & + call ppm_limiters_real4(dc(i1,k), a4(1,i1,k), it, 2) + enddo + + else + + lmt = kord - 3 + lmt = max(0, lmt) + if (iv == 0) lmt = min(2, lmt) + + do k=3,km-2 + if( kord /= 4) then + do i=i1,i2 + a4(4,i,k) = 3.*(2.*a4(1,i,k) - (a4(2,i,k)+a4(3,i,k))) + enddo + endif + if(kord/=6) call ppm_limiters_real4(dc(i1,k), a4(1,i1,k), it, lmt) + enddo + endif + + do k=km1,km + do i=i1,i2 + a4(4,i,k) = 3.*(2.*a4(1,i,k) - (a4(2,i,k)+a4(3,i,k))) + enddo + call ppm_limiters_real4(dc(i1,k), a4(1,i1,k), it, 0) + enddo + + end subroutine ppm_profile_real4 + + subroutine ppm_limiters_real4(dm, a4, itot, lmt) + +! !INPUT PARAMETERS: + real(kind=4) , intent(in):: dm(*) ! the linear slope + integer, intent(in) :: itot ! Total Longitudes + integer, intent(in) :: lmt ! 0: Standard PPM constraint + ! 1: Improved full monotonicity constraint (Lin) + ! 2: Positive definite constraint + ! 3: do nothing (return immediately) +! !INPUT/OUTPUT PARAMETERS: + real(kind=4) , intent(inout) :: a4(4,*) ! PPM array + ! AA <-- a4(1,i) + ! AL <-- a4(2,i) + ! AR <-- a4(3,i) + ! A6 <-- a4(4,i) +! !LOCAL VARIABLES: + real(kind=4) qmp + real(kind=4) da1, da2, a6da + real(kind=4) fmin + integer i + +! Developer: S.-J. Lin + + if ( lmt == 3 ) return + + if(lmt == 0) then +! Standard PPM constraint + do i=1,itot + if(dm(i) == 0.) then + a4(2,i) = a4(1,i) + a4(3,i) = a4(1,i) + a4(4,i) = 0. + else + da1 = a4(3,i) - a4(2,i) + da2 = da1**2 + a6da = a4(4,i)*da1 + if(a6da < -da2) then + a4(4,i) = 3.*(a4(2,i)-a4(1,i)) + a4(3,i) = a4(2,i) - a4(4,i) + elseif(a6da > da2) then + a4(4,i) = 3.*(a4(3,i)-a4(1,i)) + a4(2,i) = a4(3,i) - a4(4,i) + endif + endif + enddo + + elseif (lmt == 1) then + +! Improved full monotonicity constraint (Lin 2004) +! Note: no need to provide first guess of A6 <-- a4(4,i) + do i=1, itot + qmp = 2.*dm(i) + a4(2,i) = a4(1,i)-sign(min(abs(qmp),abs(a4(2,i)-a4(1,i))), qmp) + a4(3,i) = a4(1,i)+sign(min(abs(qmp),abs(a4(3,i)-a4(1,i))), qmp) + a4(4,i) = 3.*( 2.*a4(1,i) - (a4(2,i)+a4(3,i)) ) + enddo + + elseif (lmt == 2) then + +! Positive definite constraint + do i=1,itot + if( abs(a4(3,i)-a4(2,i)) < -a4(4,i) ) then + fmin = a4(1,i)+0.25*(a4(3,i)-a4(2,i))**2/a4(4,i)+a4(4,i)*r12_real4 + if( fmin < 0. ) then + if(a4(1,i) a4(2,i)) then + a4(4,i) = 3.*(a4(2,i)-a4(1,i)) + a4(3,i) = a4(2,i) - a4(4,i) + else + a4(4,i) = 3.*(a4(3,i)-a4(1,i)) + a4(2,i) = a4(3,i) - a4(4,i) + endif + endif + endif + enddo + + endif + + end subroutine ppm_limiters_real4 + + subroutine ppm_profile_real8(a4, delp, km, i1, i2, iv, kord) + +! !INPUT PARAMETERS: + integer, intent(in):: iv ! iv =-1: winds + ! iv = 0: positive definite scalars + ! iv = 1: others + ! iv = 2: temp (if remap_t) and w (iv=-2) + integer, intent(in):: i1 ! Starting longitude + integer, intent(in):: i2 ! Finishing longitude + integer, intent(in):: km ! vertical dimension + integer, intent(in):: kord ! Order (or more accurately method no.): + ! + real(kind=8) , intent(in):: delp(i1:i2,km) ! layer pressure thickness + +! !INPUT/OUTPUT PARAMETERS: + real(kind=8) , intent(inout):: a4(4,i1:i2,km) ! Interpolated values + +! DESCRIPTION: +! +! Perform the piecewise parabolic reconstruction +! +! !REVISION HISTORY: +! S.-J. Lin revised at GFDL 2007 +!----------------------------------------------------------------------- +! local arrays: + real(kind=8) dc(i1:i2,km) + real(kind=8) h2(i1:i2,km) + real(kind=8) delq(i1:i2,km) + real(kind=8) df2(i1:i2,km) + real(kind=8) d4(i1:i2,km) + +! local scalars: + integer i, k, km1, lmt, it + real(kind=8) fac + real(kind=8) a1, a2, c1, c2, c3, d1, d2 + real(kind=8) qm, dq, lac, qmp, pmp + + km1 = km - 1 + it = i2 - i1 + 1 + + do k=2,km + do i=i1,i2 + delq(i,k-1) = a4(1,i,k) - a4(1,i,k-1) + d4(i,k ) = delp(i,k-1) + delp(i,k) + enddo + enddo + + do k=2,km1 + do i=i1,i2 + c1 = (delp(i,k-1)+0.5*delp(i,k))/d4(i,k+1) + c2 = (delp(i,k+1)+0.5*delp(i,k))/d4(i,k) + df2(i,k) = delp(i,k)*(c1*delq(i,k) + c2*delq(i,k-1)) / & + (d4(i,k)+delp(i,k+1)) + dc(i,k) = sign( min(abs(df2(i,k)), & + max(a4(1,i,k-1),a4(1,i,k),a4(1,i,k+1))-a4(1,i,k), & + a4(1,i,k)-min(a4(1,i,k-1),a4(1,i,k),a4(1,i,k+1))), df2(i,k) ) + enddo + enddo + +!----------------------------------------------------------- +! 4th order interpolation of the provisional cell edge value +!----------------------------------------------------------- + + do k=3,km1 + do i=i1,i2 + c1 = delq(i,k-1)*delp(i,k-1) / d4(i,k) + a1 = d4(i,k-1) / (d4(i,k) + delp(i,k-1)) + a2 = d4(i,k+1) / (d4(i,k) + delp(i,k)) + a4(2,i,k) = a4(1,i,k-1) + c1 + 2./(d4(i,k-1)+d4(i,k+1)) * & + ( delp(i,k)*(c1*(a1 - a2)+a2*dc(i,k-1)) - & + delp(i,k-1)*a1*dc(i,k ) ) + enddo + enddo + +! if(km>8 .and. kord>4) call steepz(i1, i2, km, a4, df2, dc, delq, delp, d4) + +! Area preserving cubic with 2nd deriv. = 0 at the boundaries +! Top + do i=i1,i2 + d1 = delp(i,1) + d2 = delp(i,2) + qm = (d2*a4(1,i,1)+d1*a4(1,i,2)) / (d1+d2) + dq = 2.*(a4(1,i,2)-a4(1,i,1)) / (d1+d2) + c1 = 4.*(a4(2,i,3)-qm-d2*dq) / ( d2*(2.*d2*d2+d1*(d2+3.*d1)) ) + c3 = dq - 0.5*c1*(d2*(5.*d1+d2)-3.*d1*d1) + a4(2,i,2) = qm - 0.25*c1*d1*d2*(d2+3.*d1) +! Top edge: +!------------------------------------------------------- + a4(2,i,1) = d1*(2.*c1*d1**2-c3) + a4(2,i,2) +!------------------------------------------------------- +! a4(2,i,1) = (12./7.)*a4(1,i,1)-(13./14.)*a4(1,i,2)+(3./14.)*a4(1,i,3) +!------------------------------------------------------- +! No over- and undershoot condition + a4(2,i,2) = max( a4(2,i,2), min(a4(1,i,1), a4(1,i,2)) ) + a4(2,i,2) = min( a4(2,i,2), max(a4(1,i,1), a4(1,i,2)) ) + dc(i,1) = 0.5*(a4(2,i,2) - a4(1,i,1)) + enddo + +! Enforce monotonicity within the top layer + + if( iv==0 ) then + do i=i1,i2 + a4(2,i,1) = max(0., a4(2,i,1)) + a4(2,i,2) = max(0., a4(2,i,2)) + enddo + elseif( iv==-1 ) then + do i=i1,i2 + if ( a4(2,i,1)*a4(1,i,1) <= 0. ) a4(2,i,1) = 0. + enddo + elseif( abs(iv)==2 ) then + do i=i1,i2 + a4(2,i,1) = a4(1,i,1) + a4(3,i,1) = a4(1,i,1) + enddo + endif + +! Bottom +! Area preserving cubic with 2nd deriv. = 0 at the surface + do i=i1,i2 + d1 = delp(i,km) + d2 = delp(i,km1) + qm = (d2*a4(1,i,km)+d1*a4(1,i,km1)) / (d1+d2) + dq = 2.*(a4(1,i,km1)-a4(1,i,km)) / (d1+d2) + c1 = (a4(2,i,km1)-qm-d2*dq) / (d2*(2.*d2*d2+d1*(d2+3.*d1))) + c3 = dq - 2.0*c1*(d2*(5.*d1+d2)-3.*d1*d1) + a4(2,i,km) = qm - c1*d1*d2*(d2+3.*d1) +! Bottom edge: +!----------------------------------------------------- + a4(3,i,km) = d1*(8.*c1*d1**2-c3) + a4(2,i,km) +! dc(i,km) = 0.5*(a4(3,i,km) - a4(1,i,km)) +!----------------------------------------------------- +! a4(3,i,km) = (12./7.)*a4(1,i,km)-(13./14.)*a4(1,i,km-1)+(3./14.)*a4(1,i,km-2) +! No over- and under-shoot condition + a4(2,i,km) = max( a4(2,i,km), min(a4(1,i,km), a4(1,i,km1)) ) + a4(2,i,km) = min( a4(2,i,km), max(a4(1,i,km), a4(1,i,km1)) ) + dc(i,km) = 0.5*(a4(1,i,km) - a4(2,i,km)) + enddo + + +! Enforce constraint on the "slope" at the surface + +#ifdef BOT_MONO + do i=i1,i2 + a4(4,i,km) = 0 + if( a4(3,i,km) * a4(1,i,km) <= 0. ) a4(3,i,km) = 0. + d1 = a4(1,i,km) - a4(2,i,km) + d2 = a4(3,i,km) - a4(1,i,km) + if ( d1*d2 < 0. ) then + a4(2,i,km) = a4(1,i,km) + a4(3,i,km) = a4(1,i,km) + else + dq = sign(min(abs(d1),abs(d2),0.5*abs(delq(i,km-1))), d1) + a4(2,i,km) = a4(1,i,km) - dq + a4(3,i,km) = a4(1,i,km) + dq + endif + enddo +#else + if( iv==0 ) then + do i=i1,i2 + a4(2,i,km) = max(0.,a4(2,i,km)) + a4(3,i,km) = max(0.,a4(3,i,km)) + enddo + elseif( iv<0 ) then + do i=i1,i2 + if( a4(1,i,km)*a4(3,i,km) <= 0. ) a4(3,i,km) = 0. + enddo + endif +#endif + + do k=1,km1 + do i=i1,i2 + a4(3,i,k) = a4(2,i,k+1) + enddo + enddo + +!----------------------------------------------------------- +! f(s) = AL + s*[(AR-AL) + A6*(1-s)] ( 0 <= s <= 1 ) +!----------------------------------------------------------- +! Top 2 and bottom 2 layers always use monotonic mapping + do k=1,2 + do i=i1,i2 + a4(4,i,k) = 3.*(2.*a4(1,i,k) - (a4(2,i,k)+a4(3,i,k))) + enddo + call ppm_limiters_real8(dc(i1,k), a4(1,i1,k), it, 0) + enddo + + if(kord >= 7) then +!----------------------- +! Huynh's 2nd constraint +!----------------------- + do k=2,km1 + do i=i1,i2 +! Method#1 +! h2(i,k) = delq(i,k) - delq(i,k-1) +! Method#2 - better + h2(i,k) = 2.*(dc(i,k+1)/delp(i,k+1) - dc(i,k-1)/delp(i,k-1)) & + / ( delp(i,k)+0.5*(delp(i,k-1)+delp(i,k+1)) ) & + * delp(i,k)**2 +! Method#3 +!!! h2(i,k) = dc(i,k+1) - dc(i,k-1) + enddo + enddo + + fac = 1.5 ! original quasi-monotone + + do k=3,km-2 + do i=i1,i2 +! Right edges +! qmp = a4(1,i,k) + 2.0*delq(i,k-1) +! lac = a4(1,i,k) + fac*h2(i,k-1) + 0.5*delq(i,k-1) +! + pmp = 2.*dc(i,k) + qmp = a4(1,i,k) + pmp + lac = a4(1,i,k) + fac*h2(i,k-1) + dc(i,k) + a4(3,i,k) = min(max(a4(3,i,k), min(a4(1,i,k), qmp, lac)), & + max(a4(1,i,k), qmp, lac) ) +! Left edges +! qmp = a4(1,i,k) - 2.0*delq(i,k) +! lac = a4(1,i,k) + fac*h2(i,k+1) - 0.5*delq(i,k) +! + qmp = a4(1,i,k) - pmp + lac = a4(1,i,k) + fac*h2(i,k+1) - dc(i,k) + a4(2,i,k) = min(max(a4(2,i,k), min(a4(1,i,k), qmp, lac)), & + max(a4(1,i,k), qmp, lac)) +!------------- +! Recompute A6 +!------------- + a4(4,i,k) = 3.*(2.*a4(1,i,k) - (a4(2,i,k)+a4(3,i,k))) + enddo +! Additional constraint to ensure positivity when kord=7 + if (iv == 0 .and. kord >= 6 ) & + call ppm_limiters_real8(dc(i1,k), a4(1,i1,k), it, 2) + enddo + + else + + lmt = kord - 3 + lmt = max(0, lmt) + if (iv == 0) lmt = min(2, lmt) + + do k=3,km-2 + if( kord /= 4) then + do i=i1,i2 + a4(4,i,k) = 3.*(2.*a4(1,i,k) - (a4(2,i,k)+a4(3,i,k))) + enddo + endif + if(kord/=6) call ppm_limiters_real8(dc(i1,k), a4(1,i1,k), it, lmt) + enddo + endif + + do k=km1,km + do i=i1,i2 + a4(4,i,k) = 3.*(2.*a4(1,i,k) - (a4(2,i,k)+a4(3,i,k))) + enddo + call ppm_limiters_real8(dc(i1,k), a4(1,i1,k), it, 0) + enddo + + end subroutine ppm_profile_real8 + + + subroutine ppm_limiters_real8(dm, a4, itot, lmt) + +! !INPUT PARAMETERS: + real(kind=8) , intent(in):: dm(*) ! the linear slope + integer, intent(in) :: itot ! Total Longitudes + integer, intent(in) :: lmt ! 0: Standard PPM constraint + ! 1: Improved full monotonicity constraint (Lin) + ! 2: Positive definite constraint + ! 3: do nothing (return immediately) +! !INPUT/OUTPUT PARAMETERS: + real(kind=8) , intent(inout) :: a4(4,*) ! PPM array + ! AA <-- a4(1,i) + ! AL <-- a4(2,i) + ! AR <-- a4(3,i) + ! A6 <-- a4(4,i) +! !LOCAL VARIABLES: + real(kind=8) qmp + real(kind=8) da1, da2, a6da + real(kind=8) fmin + integer i + +! Developer: S.-J. Lin + + if ( lmt == 3 ) return + + if(lmt == 0) then +! Standard PPM constraint + do i=1,itot + if(dm(i) == 0.) then + a4(2,i) = a4(1,i) + a4(3,i) = a4(1,i) + a4(4,i) = 0. + else + da1 = a4(3,i) - a4(2,i) + da2 = da1**2 + a6da = a4(4,i)*da1 + if(a6da < -da2) then + a4(4,i) = 3.*(a4(2,i)-a4(1,i)) + a4(3,i) = a4(2,i) - a4(4,i) + elseif(a6da > da2) then + a4(4,i) = 3.*(a4(3,i)-a4(1,i)) + a4(2,i) = a4(3,i) - a4(4,i) + endif + endif + enddo + + elseif (lmt == 1) then + +! Improved full monotonicity constraint (Lin 2004) +! Note: no need to provide first guess of A6 <-- a4(4,i) + do i=1, itot + qmp = 2.*dm(i) + a4(2,i) = a4(1,i)-sign(min(abs(qmp),abs(a4(2,i)-a4(1,i))), qmp) + a4(3,i) = a4(1,i)+sign(min(abs(qmp),abs(a4(3,i)-a4(1,i))), qmp) + a4(4,i) = 3.*( 2.*a4(1,i) - (a4(2,i)+a4(3,i)) ) + enddo + + elseif (lmt == 2) then + +! Positive definite constraint + do i=1,itot + if( abs(a4(3,i)-a4(2,i)) < -a4(4,i) ) then + fmin = a4(1,i)+0.25*(a4(3,i)-a4(2,i))**2/a4(4,i)+a4(4,i)*r12_real8 + if( fmin < 0. ) then + if(a4(1,i) a4(2,i)) then + a4(4,i) = 3.*(a4(2,i)-a4(1,i)) + a4(3,i) = a4(2,i) - a4(4,i) + else + a4(4,i) = 3.*(a4(3,i)-a4(1,i)) + a4(2,i) = a4(3,i) - a4(4,i) + endif + endif + endif + enddo + + endif + + end subroutine ppm_limiters_real8 end module coarse_graining_mod diff --git a/tools/external_ic.F90 b/tools/external_ic.F90 index 26834105d..23ec6cc03 100644 --- a/tools/external_ic.F90 +++ b/tools/external_ic.F90 @@ -10,7 +10,7 @@ !* (at your option) any later version. !* !* The FV3 dynamical core is distributed in the hope that it will be -!* useful, but WITHOUT ANYWARRANTY; without even the implied warranty +!* useful, but WITHOUT ANY WARRANTY; without even the implied warranty !* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. !* See the GNU General Public License for more details. !* @@ -41,8 +41,8 @@ module external_ic_mod use tracer_manager_mod, only: get_tracer_names, get_number_tracers, get_tracer_index use tracer_manager_mod, only: set_tracer_profile use field_manager_mod, only: MODEL_ATMOS - use platform_mod, only: r4_kind, r8_kind - use constants_mod, only: pi=>pi_8, omega, grav, kappa, rdgas, rvgas, cp_air + use constants_mod, only: pi=>pi_8, grav, kappa, rdgas, rvgas, cp_air + use fv_arrays_mod, only: omega ! scaled for small earth use fv_arrays_mod, only: fv_atmos_type, fv_grid_type, fv_grid_bounds_type, R_GRID use fv_diagnostics_mod,only: prt_maxmin, prt_gb_nh_sh, prt_height use fv_grid_utils_mod, only: ptop_min, g_sum,mid_pt_sphere,get_unit_vect2,get_latlon_vector,inner_prod @@ -75,6 +75,7 @@ module external_ic_mod real, parameter:: zvir = rvgas/rdgas - 1. real(kind=R_GRID), parameter :: cnst_0p20=0.20d0 real :: deg2rad + character(len=128) :: inputdir logical :: source_fv3gfs ! version number of this module @@ -85,11 +86,11 @@ module external_ic_mod contains - subroutine get_external_ic( Atm, fv_domain, cold_start ) + subroutine get_external_ic( Atm, cold_start, icdir ) type(fv_atmos_type), intent(inout), target :: Atm - type(domain2d), intent(inout) :: fv_domain logical, intent(IN) :: cold_start + character(len=*), intent(in), optional :: icdir real:: alpha = 0. real rdg integer i,j,k,nq @@ -101,6 +102,9 @@ subroutine get_external_ic( Atm, fv_domain, cold_start ) integer :: isd, ied, jsd, jed, ng integer :: sphum, liq_wat, ice_wat, rainwat, snowwat, graupel, o3mr, sgs_tke, cld_amt + inputdir = 'INPUT/' + if(present(icdir)) inputdir = icdir + is = Atm%bd%is ie = Atm%bd%ie js = Atm%bd%js @@ -133,14 +137,14 @@ subroutine get_external_ic( Atm, fv_domain, cold_start ) enddo enddo - call mpp_update_domains( f0, fv_domain ) + call mpp_update_domains( f0, Atm%domain ) if ( Atm%gridstruct%cubed_sphere .and. (.not. Atm%gridstruct%bounded_domain))then call fill_corners(f0, Atm%npx, Atm%npy, YDir) endif ! Read in cubed_sphere terrain if ( Atm%flagstruct%mountain ) then - call get_cubed_sphere_terrain(Atm, fv_domain) + call get_cubed_sphere_terrain(Atm) else if (.not. Atm%neststruct%nested) Atm%phis = 0. !TODO: Not sure about this line --- lmh 30 may 18 endif @@ -149,41 +153,38 @@ subroutine get_external_ic( Atm, fv_domain, cold_start ) if ( Atm%flagstruct%ncep_ic ) then nq = 1 call timing_on('NCEP_IC') - call get_ncep_ic( Atm, fv_domain, nq ) + call get_ncep_ic( Atm, nq ) call timing_off('NCEP_IC') #ifdef FV_TRACERS if (.not. cold_start) then - call fv_io_read_tracers( fv_domain, Atm ) + call fv_io_read_tracers( Atm ) if(is_master()) write(*,*) 'All tracers except sphum replaced by FV IC' endif #endif elseif ( Atm%flagstruct%nggps_ic ) then call timing_on('NGGPS_IC') - call get_nggps_ic( Atm, fv_domain ) + call get_nggps_ic( Atm ) call timing_off('NGGPS_IC') elseif ( Atm%flagstruct%hrrrv3_ic ) then call timing_on('HRRR_IC') - call get_hrrr_ic( Atm, fv_domain ) + call get_hrrr_ic( Atm ) call timing_off('HRRR_IC') elseif ( Atm%flagstruct%ecmwf_ic ) then if( is_master() ) write(*,*) 'Calling get_ecmwf_ic' call timing_on('ECMWF_IC') - call get_ecmwf_ic( Atm, fv_domain ) + call get_ecmwf_ic( Atm ) call timing_off('ECMWF_IC') else ! The following is to read in legacy lat-lon FV core restart file ! is Atm%q defined in all cases? nq = size(Atm%q,4) - call get_fv_ic( Atm, fv_domain, nq ) + call get_fv_ic( Atm, nq ) endif call prt_maxmin('PS', Atm%ps, is, ie, js, je, ng, 1, 0.01) call prt_maxmin('T', Atm%pt, is, ie, js, je, ng, Atm%npz, 1.) if (.not.Atm%flagstruct%hydrostatic) call prt_maxmin('W', Atm%w, is, ie, js, je, ng, Atm%npz, 1.) call prt_maxmin('SPHUM', Atm%q(:,:,:,1), is, ie, js, je, ng, Atm%npz, 1.) - if ( Atm%flagstruct%nggps_ic .or. Atm%flagstruct%hrrrv3_ic ) then - call prt_maxmin('TS', Atm%ts, is, ie, js, je, 0, 1, 1.) - endif if ( Atm%flagstruct%nggps_ic .or. Atm%flagstruct%ecmwf_ic .or. Atm%flagstruct%hrrrv3_ic ) then sphum = get_tracer_index(MODEL_ATMOS, 'sphum') liq_wat = get_tracer_index(MODEL_ATMOS, 'liq_wat') @@ -216,9 +217,8 @@ end subroutine get_external_ic !------------------------------------------------------------------ - subroutine get_cubed_sphere_terrain( Atm, fv_domain ) + subroutine get_cubed_sphere_terrain( Atm ) type(fv_atmos_type), intent(inout), target :: Atm - type(domain2d), intent(inout) :: fv_domain type(FmsNetcdfDomainFile_t) :: Fv_core integer :: tile_id(1) character(len=64) :: fname @@ -241,13 +241,13 @@ subroutine get_cubed_sphere_terrain( Atm, fv_domain ) jed = Atm%bd%jed ng = Atm%bd%ng - tile_id = mpp_get_tile_id( fv_domain ) + tile_id = mpp_get_tile_id( Atm%domain ) fname = 'INPUT/fv_core.res.nc' call mpp_error(NOTE, 'external_ic: looking for '//fname) - if( open_file(Fv_core, fname, "read", fv_domain, is_restart=.true.) ) then + if( open_file(Fv_core, fname, "read", Atm%domain_for_read, is_restart=.true.) ) then call read_data(Fv_core, 'phis', Atm%phis(is:ie,js:je)) call close_file(Fv_core) else @@ -273,7 +273,7 @@ subroutine get_cubed_sphere_terrain( Atm, fv_domain ) end subroutine get_cubed_sphere_terrain - subroutine get_nggps_ic (Atm, fv_domain) + subroutine get_nggps_ic (Atm) ! read in data after it has been preprocessed with ! NCEP/EMC orography maker and global_chgres ! and has been horiztontally interpolated to the @@ -282,11 +282,6 @@ subroutine get_nggps_ic (Atm, fv_domain) !--- variables read in from 'gfs_ctrl.nc' ! VCOORD - level information ! maps to 'ak & bk' -!--- variables read in from 'sfc_data.nc' -! land_frac - land-sea-ice mask (L:0 / S:1) -! maps to 'oro' -! TSEA - surface skin temperature (k) -! maps to 'ts' !--- variables read in from 'gfs_data.nc' ! ZH - GFS grid height at edges (m) ! PS - surface pressure (Pa) @@ -303,7 +298,6 @@ subroutine get_nggps_ic (Atm, fv_domain) type(fv_atmos_type), intent(inout) :: Atm - type(domain2d), intent(inout) :: fv_domain ! local: real, dimension(:), allocatable:: ak, bk real, dimension(:,:), allocatable:: wk2, ps, oro_g @@ -316,6 +310,7 @@ subroutine get_nggps_ic (Atm, fv_domain) integer :: is, ie, js, je integer :: isd, ied, jsd, jed integer :: ios, ierr, unit, id_res + type(FmsNetcdfDomainFile_t) :: ORO_restart, SFC_restart, GFS_restart type(FmsNetcdfFile_t) :: Gfs_ctl integer, allocatable, dimension(:) :: pes !< Array of the pes in the current pelist @@ -405,12 +400,10 @@ subroutine get_nggps_ic (Atm, fv_domain) ! - call get_data_source(source_fv3gfs,Atm%flagstruct%regional) - + call get_data_source(source_fv3gfs,Atm%flagstruct%regional,inputdir) levp = levsp-1 - ! read in GFS IC call mpp_error(NOTE,'==> External_ic::get_nggps_ic: Reading processed IC') call mpp_error(NOTE,'==> External_ic::get_nggps_ic: IC has ', levp ,' levels' ) @@ -427,7 +420,7 @@ subroutine get_nggps_ic (Atm, fv_domain) !--- read in surface temperature (k) and land-frac ! surface skin temperature - if( open_file(SFC_restart, fn_sfc_ics, "read", Atm%domain, is_restart=.true., dont_add_res_to_filename=.true.) ) then + if( open_file(SFC_restart, fn_sfc_ics, "read", Atm%domain_for_read, is_restart=.true., dont_add_res_to_filename=.true.) ) then naxis_dims = get_variable_num_dimensions(SFC_restart, 'tsea') allocate (dim_names_alloc(naxis_dims)) call get_variable_dimension_names(SFC_restart, 'tsea', dim_names_alloc) @@ -447,7 +440,7 @@ subroutine get_nggps_ic (Atm, fv_domain) dim_names_2d(2) = "lon" ! terrain surface height -- (needs to be transformed into phis = zs*grav) - if( open_file(ORO_restart, fn_oro_ics, "read", Atm%domain, is_restart=.true., dont_add_res_to_filename=.true.) ) then + if( open_file(ORO_restart, fn_oro_ics, "read", Atm%domain_for_read, is_restart=.true., dont_add_res_to_filename=.true.) ) then call register_axis(ORO_restart, "lat", "y") call register_axis(ORO_restart, "lon", "x") if (filtered_terrain) then @@ -478,8 +471,10 @@ subroutine get_nggps_ic (Atm, fv_domain) else call mpp_error(FATAL,'==> Error in External_ic::get_nggps_ic: tiled file '//trim(fn_oro_ics)//' for NGGPS IC does not exist') endif + call mpp_error(NOTE,'==> External_ic::get_nggps_ic: using tiled data file '//trim(fn_oro_ics)//' for NGGPS IC') + ! initialize all tracers to default values prior to being input do nt = 1, ntprog call get_tracer_names(MODEL_ATMOS, nt, tracer_name) @@ -744,6 +739,7 @@ subroutine read_gfs_ic() allocate ( v_s(is:ie, js:je+1, 1:levp) ) if (source_fv3gfs) allocate (temp(is:ie,js:je,1:levp)) + ! initialize dim_names for register restart dim_names_3d(1) = "lev" dim_names_3d(2) = "lat" @@ -757,7 +753,7 @@ subroutine read_gfs_ic() dim_names_3d4(1) = "levp" ! surface pressure (Pa) - if( open_file(GFS_restart, fn_gfs_ics, "read", Atm%domain, is_restart=.true., dont_add_res_to_filename=.true.) ) then + if( open_file(GFS_restart, fn_gfs_ics, "read", Atm%domain_for_read, is_restart=.true., dont_add_res_to_filename=.true.) ) then call register_axis(GFS_restart, "lat", "y") call register_axis(GFS_restart, "lon", "x") call register_axis(GFS_restart, "lonp", "x", domain_position=east) @@ -803,18 +799,13 @@ subroutine read_gfs_ic() end subroutine get_nggps_ic !------------------------------------------------------------------ !------------------------------------------------------------------ - subroutine get_hrrr_ic (Atm, fv_domain) + subroutine get_hrrr_ic (Atm) ! read in data after it has been preprocessed with ! NCEP/EMC orography maker ! !--- variables read in from 'hrrr_ctrl.nc' ! VCOORD - level information ! maps to 'ak & bk' -!--- variables read in from 'sfc_data.nc' -! land_frac - land-sea-ice mask (L:0 / S:1) -! maps to 'oro' -! TSEA - surface skin temperature (k) -! maps to 'ts' !--- variables read in from 'gfs_data.nc' ! ZH - GFS grid height at edges (m) ! PS - surface pressure (Pa) @@ -829,7 +820,6 @@ subroutine get_hrrr_ic (Atm, fv_domain) type(fv_atmos_type), intent(inout) :: Atm - type(domain2d), intent(inout) :: fv_domain ! local: real, dimension(:), allocatable:: ak, bk real, dimension(:,:), allocatable:: wk2, ps, oro_g @@ -842,6 +832,7 @@ subroutine get_hrrr_ic (Atm, fv_domain) integer :: is, ie, js, je integer :: isd, ied, jsd, jed integer :: ios, ierr, unit, id_res + type (FmsNetcdfDomainFile_t) :: ORO_restart, SFC_restart, HRRR_restart type(FmsNetcdfFile_t) :: Hrr_ctl integer, allocatable, dimension(:) :: pes !< Array of the pes in the current pelist @@ -943,7 +934,7 @@ subroutine get_hrrr_ic (Atm, fv_domain) !--- read in surface temperature (k) and land-frac ! surface skin temperature - if( open_file(SFC_restart, fn_sfc_ics, "read", Atm%domain, is_restart=.true., dont_add_res_to_filename=.true.) ) then + if( open_file(SFC_restart, fn_sfc_ics, "read", Atm%domain_for_read, is_restart=.true., dont_add_res_to_filename=.true.) ) then call get_variable_dimension_names(SFC_restart, 'tsea', dim_names_2d) call register_axis(SFC_restart, dim_names_2d(2), "y") call register_axis(SFC_restart, dim_names_2d(1), "x") @@ -960,7 +951,7 @@ subroutine get_hrrr_ic (Atm, fv_domain) dim_names_2d(2) = "lon" ! terrain surface height -- (needs to be transformed into phis = zs*grav) - if( open_file(ORO_restart, fn_oro_ics, "read", Atm%domain, is_restart=.true., dont_add_res_to_filename=.true.) ) then + if( open_file(ORO_restart, fn_oro_ics, "read", Atm%domain_for_read, is_restart=.true., dont_add_res_to_filename=.true.) ) then call register_axis(ORO_restart, "lat", "y") call register_axis(ORO_restart, "lon", "x") if (filtered_terrain) then @@ -1003,7 +994,7 @@ subroutine get_hrrr_ic (Atm, fv_domain) dim_names_3d4(1) = "levp" ! edge pressure (Pa) - if( open_file(HRRR_restart, fn_hrr_ics, "read", Atm%domain,is_restart=.true., dont_add_res_to_filename=.true.) ) then + if( open_file(HRRR_restart, fn_hrr_ics, "read", Atm%domain_for_read, is_restart=.true., dont_add_res_to_filename=.true.) ) then call register_axis(HRRR_restart, "lat", "y") call register_axis(HRRR_restart, "lon", "x") call register_axis(HRRR_restart, "lonp", "x", domain_position=east) @@ -1198,9 +1189,8 @@ subroutine get_hrrr_ic (Atm, fv_domain) end subroutine get_hrrr_ic !------------------------------------------------------------------ !------------------------------------------------------------------ - subroutine get_ncep_ic( Atm, fv_domain, nq ) + subroutine get_ncep_ic( Atm, nq ) type(fv_atmos_type), intent(inout) :: Atm - type(domain2d), intent(inout) :: fv_domain integer, intent(in):: nq ! local: #ifdef HIWPP_ETA @@ -1656,9 +1646,8 @@ subroutine get_ncep_ic( Atm, fv_domain, nq ) end subroutine get_ncep_ic !------------------------------------------------------------------ !------------------------------------------------------------------ - subroutine get_ecmwf_ic( Atm, fv_domain ) + subroutine get_ecmwf_ic( Atm ) type(fv_atmos_type), intent(inout) :: Atm - type(domain2d), intent(inout) :: fv_domain ! local: real :: ak_ec(138), bk_ec(138) data ak_ec/ 0.000000, 2.000365, 3.102241, 4.666084, 6.827977, 9.746966, & @@ -1794,7 +1783,7 @@ subroutine get_ecmwf_ic( Atm, fv_domain ) real(kind=R_GRID), dimension(3):: e1, e2, ex, ey real, allocatable:: ps_gfs(:,:), zh_gfs(:,:,:), o3mr_gfs(:,:,:) real, allocatable:: ak_gfs(:), bk_gfs(:) - integer :: id_res, ntprog, ntracers, ks, iq, nt + integer :: id_res, ntprog, ntracers, ks, iq, nt, levsp character(len=64) :: tracer_name integer :: levp_gfs = 64 type(FmsNetcdfDomainFile_t) :: ORO_restart, GFS_restart @@ -1817,6 +1806,11 @@ subroutine get_ecmwf_ic( Atm, fv_domain ) jsd = Atm%bd%jsd jed = Atm%bd%jed + call open_ncfile( trim(inputdir)//'/'//trim(fn_gfs_ctl), ncid ) + call get_ncdim1( ncid, 'levsp', levsp ) + call close_ncfile( ncid ) + levp_gfs = levsp-1 + deg2rad = pi/180. npz = Atm%npz @@ -1870,7 +1864,7 @@ subroutine get_ecmwf_ic( Atm, fv_domain ) dim_names_3d4(1) = "levp" !! Read in model terrain from oro_data.tile?.nc - if( open_file(ORO_restart, fn_oro_ics, "read", Atm%domain, is_restart=.true., dont_add_res_to_filename=.true.) ) then + if( open_file(ORO_restart, fn_oro_ics, "read", Atm%domain_for_read, is_restart=.true., dont_add_res_to_filename=.true.) ) then call register_axis(ORO_restart, "lat", "y") call register_axis(ORO_restart, "lon", "x") if (filtered_terrain) then @@ -1890,7 +1884,7 @@ subroutine get_ecmwf_ic( Atm, fv_domain ) allocate (ps_gfs(is:ie,js:je)) allocate (zh_gfs(is:ie,js:je,levp_gfs+1)) - if( open_file(GFS_restart, fn_gfs_ics, "read", Atm%domain, is_restart=.true., dont_add_res_to_filename=.true.) ) then + if( open_file(GFS_restart, fn_gfs_ics, "read", Atm%domain_for_read, is_restart=.true., dont_add_res_to_filename=.true.) ) then call register_axis(GFS_restart, "lat", "y") call register_axis(GFS_restart, "lon", "x") call register_axis(GFS_restart, "lev", size(o3mr_gfs,3)) @@ -2396,9 +2390,8 @@ subroutine get_ecmwf_ic( Atm, fv_domain ) end subroutine get_ecmwf_ic !------------------------------------------------------------------ !------------------------------------------------------------------ - subroutine get_fv_ic( Atm, fv_domain, nq ) + subroutine get_fv_ic( Atm, nq ) type(fv_atmos_type), intent(inout) :: Atm - type(domain2d), intent(inout) :: fv_domain integer, intent(in):: nq type(FmsNetcdfFile_t) :: Latlon_dyn, Latlon_tra @@ -2859,7 +2852,7 @@ subroutine remap_scalar(Atm, km, npz, ncnst, ak0, bk0, psc, qa, zh, omga, t_in) qp(i,k) = qa(i,j,k,iq) enddo enddo - call mappm(km, pe0, qp, npz, pe1, qn1, is,ie, 0, 8, Atm%ptop) + call mappm(km, pe0, qp, npz, pe1, qn1, is,ie, 0, 8) if ( iq==sphum ) then call fillq(ie-is+1, npz, 1, qn1, dp2) else @@ -2943,8 +2936,8 @@ subroutine remap_scalar(Atm, km, npz, ncnst, ak0, bk0, psc, qa, zh, omga, t_in) qp(i,k) = t_in(i,j,k) enddo - call mappm(km, log(pe0), qp, npz, log(pe1), qn1, is,ie, 2, 4, Atm%ptop) ! pn0 and pn1 are higher-precision - ! and cannot be passed to mappm + call mappm(km, log(pe0), qp, npz, log(pe1), qn1, is,ie, 2, 4) ! pn0 and pn1 are higher-precision + ! and cannot be passed to mappm do k=1,npz Atm%pt(i,j,k) = qn1(i,k) enddo @@ -3023,7 +3016,7 @@ subroutine remap_scalar(Atm, km, npz, ncnst, ak0, bk0, psc, qa, zh, omga, t_in) qp(i,k) = omga(i,j,k) enddo enddo - call mappm(km, pe0, qp, npz, pe1, qn1, is,ie, -1, 4, Atm%ptop) + call mappm(km, pe0, qp, npz, pe1, qn1, is,ie, -1, 4) if (source_fv3gfs) then do k=1,npz do i=is,ie @@ -3167,7 +3160,7 @@ subroutine remap_scalar_single(Atm, km, npz, ak0, bk0, psc, qa, zh ,iq) qp(i,k) = qa(i,j,k) enddo enddo - call mappm(km, pe0, qp, npz, pe1, qn1, is,ie, 0, 8, Atm%ptop) + call mappm(km, pe0, qp, npz, pe1, qn1, is,ie, 0, 8) if ( iq==1 ) then call fillq(ie-is+1, npz, 1, qn1, dp2) else @@ -3266,7 +3259,7 @@ subroutine remap_dwinds(km, npz, ak0, bk0, psc, ud, vd, Atm) enddo enddo call mappm(km, pe0(is:ie,1:km+1), ud(is:ie,j,1:km), npz, pe1(is:ie,1:npz+1), & - qn1(is:ie,1:npz), is,ie, -1, 8, Atm%ptop) + qn1(is:ie,1:npz), is,ie, -1, 8) do k=1,npz do i=is,ie Atm%u(i,j,k) = qn1(i,k) @@ -3288,7 +3281,7 @@ subroutine remap_dwinds(km, npz, ak0, bk0, psc, ud, vd, Atm) enddo enddo call mappm(km, pe0(is:ie+1,1:km+1), vd(is:ie+1,j,1:km), npz, pe1(is:ie+1,1:npz+1), & - qn1(is:ie+1,1:npz), is,ie+1, -1, 8, Atm%ptop) + qn1(is:ie+1,1:npz), is,ie+1, -1, 8) do k=1,npz do i=is,ie+1 Atm%v(i,j,k) = qn1(i,k) @@ -3348,7 +3341,7 @@ subroutine remap_winds(im, jm, km, npz, ak0, bk0, psc, ua, va, Atm) !------ ! map u !------ - call mappm(km, pe0, ua(is:ie,j,1:km), npz, pe1, qn1, is,ie, -1, 8, Atm%ptop) + call mappm(km, pe0, ua(is:ie,j,1:km), npz, pe1, qn1, is,ie, -1, 8) do k=1,npz do i=is,ie ut(i,j,k) = qn1(i,k) @@ -3357,7 +3350,7 @@ subroutine remap_winds(im, jm, km, npz, ak0, bk0, psc, ua, va, Atm) !------ ! map v !------ - call mappm(km, pe0, va(is:ie,j,1:km), npz, pe1, qn1, is,ie, -1, 8, Atm%ptop) + call mappm(km, pe0, va(is:ie,j,1:km), npz, pe1, qn1, is,ie, -1, 8) do k=1,npz do i=is,ie vt(i,j,k) = qn1(i,k) @@ -3584,7 +3577,7 @@ subroutine remap_xyz( im, jbeg, jend, jm, km, npz, nq, ncnst, lon, lat, ak0, bk0 !------ ! map u !------ - call mappm(km, pe0, up, npz, pe1, qn1, is,ie, -1, 9, Atm%ptop) + call mappm(km, pe0, up, npz, pe1, qn1, is,ie, -1, 9) do k=1,npz do i=is,ie ut(i,j,k) = qn1(i,k) @@ -3593,7 +3586,7 @@ subroutine remap_xyz( im, jbeg, jend, jm, km, npz, nq, ncnst, lon, lat, ak0, bk0 !------ ! map v !------ - call mappm(km, pe0, vp, npz, pe1, qn1, is,ie, -1, 9, Atm%ptop) + call mappm(km, pe0, vp, npz, pe1, qn1, is,ie, -1, 9) do k=1,npz do i=is,ie vt(i,j,k) = qn1(i,k) @@ -3606,7 +3599,7 @@ subroutine remap_xyz( im, jbeg, jend, jm, km, npz, nq, ncnst, lon, lat, ak0, bk0 do iq=1,ncnst ! Note: AM2 physics tracers only ! if ( iq==sphum .or. iq==liq_wat .or. iq==ice_wat .or. iq==cld_amt ) then - call mappm(km, pe0, qp(is,1,iq), npz, pe1, qn1, is,ie, 0, 11, Atm%ptop) + call mappm(km, pe0, qp(is,1,iq), npz, pe1, qn1, is,ie, 0, 11) do k=1,npz do i=is,ie Atm%q(i,j,k,iq) = qn1(i,k) @@ -3618,7 +3611,7 @@ subroutine remap_xyz( im, jbeg, jend, jm, km, npz, nq, ncnst, lon, lat, ak0, bk0 !------------------------------------------------------------- ! map virtual temperature using geopotential conserving scheme. !------------------------------------------------------------- - call mappm(km, pn0, tp, npz, pn1, qn1, is,ie, 1, 9, Atm%ptop) + call mappm(km, pn0, tp, npz, pn1, qn1, is,ie, 1, 9) do k=1,npz do i=is,ie Atm%pt(i,j,k) = qn1(i,k)/(1.+zvir*Atm%q(i,j,k,sphum)) diff --git a/tools/external_sst.F90 b/tools/external_sst.F90 index 96b531928..d67f62391 100644 --- a/tools/external_sst.F90 +++ b/tools/external_sst.F90 @@ -10,7 +10,7 @@ !* (at your option) any later version. !* !* The FV3 dynamical core is distributed in the hope that it will be -!* useful, but WITHOUT ANYWARRANTY; without even the implied warranty +!* useful, but WITHOUT ANY WARRANTY; without even the implied warranty !* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. !* See the GNU General Public License for more details. !* @@ -18,6 +18,7 @@ !* License along with the FV3 dynamical core. !* If not, see . !*********************************************************************** + module external_sst_mod #ifdef NO_GFDL_SHARED diff --git a/GFDL_tools/fv_diag_column.F90 b/tools/fv_diag_column.F90 similarity index 91% rename from GFDL_tools/fv_diag_column.F90 rename to tools/fv_diag_column.F90 index 284277710..0ece9fd6f 100644 --- a/GFDL_tools/fv_diag_column.F90 +++ b/tools/fv_diag_column.F90 @@ -1,3 +1,24 @@ +!*********************************************************************** +!* GNU Lesser General Public License +!* +!* This file is part of the FV3 dynamical core. +!* +!* The FV3 dynamical core is free software: you can redistribute it +!* and/or modify it under the terms of the +!* GNU Lesser General Public License as published by the +!* Free Software Foundation, either version 3 of the License, or +!* (at your option) any later version. +!* +!* The FV3 dynamical core is distributed in the hope that it will be +!* useful, but WITHOUT ANY WARRANTY; without even the implied warranty +!* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. +!* See the GNU General Public License for more details. +!* +!* You should have received a copy of the GNU Lesser General Public +!* License along with the FV3 dynamical core. +!* If not, see . +!*********************************************************************** + module fv_diag_column_mod use fv_arrays_mod, only: fv_atmos_type, fv_grid_type, fv_diag_type, fv_grid_bounds_type, & @@ -38,6 +59,8 @@ module fv_diag_column_mod character(10) :: init_str real, parameter :: rad2deg = 180./pi + logical :: m_calendar + public :: do_diag_debug_dyn, debug_column, debug_column_dyn, fv_diag_column_init, sounding_column @@ -50,15 +73,17 @@ module fv_diag_column_mod contains - subroutine fv_diag_column_init(Atm, yr_init, mo_init, dy_init, hr_init, do_diag_debug_out, do_diag_sonde_out, sound_freq_out) + subroutine fv_diag_column_init(Atm, yr_init, mo_init, dy_init, hr_init, do_diag_debug_out, do_diag_sonde_out, sound_freq_out, m_calendar_in) type(fv_atmos_type), intent(inout), target :: Atm integer, intent(IN) :: yr_init, mo_init, dy_init, hr_init + logical, intent(IN) :: m_calendar_in logical, intent(OUT) :: do_diag_debug_out, do_diag_sonde_out integer, intent(OUT) :: sound_freq_out - integer :: ios, nlunit - logical :: exists + integer :: ios + + m_calendar = m_calendar_in call write_version_number ( 'FV_DIAG_COLUMN_MOD', version ) @@ -100,7 +125,6 @@ subroutine fv_diag_column_init(Atm, yr_init, mo_init, dy_init, hr_init, do_diag_ do_diag_sonde_out = do_diag_sonde sound_freq_out = sound_freq - end subroutine fv_diag_column_init @@ -287,10 +311,9 @@ subroutine find_diagnostic_column(diag_class, diag_names, diag_i, diag_j, diag_t if (point_found) then !Initialize output file - diag_units(m) = get_unit() write(filename, 202) trim(diag_names(m)), trim(diag_class) 202 format(A, '.', A, '.out') - open(diag_units(m), file=trim(filename), action='WRITE', position='rewind', iostat=io) + open(newunit=diag_units(m), file=trim(filename), action='WRITE', position='rewind', iostat=io) if(io/=0) call mpp_error(FATAL, ' find_diagnostic_column: Error in opening file '//trim(filename)) !Print debug message write(*,'(A, 1x, A, 1x, 1x, A, 2F8.3, 2I5, I3, I04)') trim(diag_class), 'point: ', diag_names(m), diag_lon(m), diag_lat(m), diag_i(m), diag_j(m), diag_tile(m), mpp_pe() @@ -321,7 +344,7 @@ subroutine debug_column(pt, delp, delz, u, v, w, q, npz, ncnst, sphum, nwat, zvi rdg = -rdgas/grav - do n=1,size(diag_debug_i) + do n=1,size(diag_debug_units) i=diag_debug_i(n) j=diag_debug_j(n) @@ -342,8 +365,13 @@ subroutine debug_column(pt, delp, delz, u, v, w, q, npz, ncnst, sphum, nwat, zvi write(unit, *) "DEBUG POINT ", diag_debug_names(n) write(unit, *) - call get_date(Time, yr, mon, dd, hr, mn, seconds) - write(unit, '(A, I6, A12, 4I4)') " Time: ", yr, month_name(mon), dd, hr, mn, seconds + if (m_calendar) then + call get_date(Time, yr, mon, dd, hr, mn, seconds) + write(unit, '(A, I6, A12, 4I4)') " Time: ", yr, month_name(mon), dd, hr, mn, seconds + else + call get_time (Time, seconds, days) + write(unit, '(A, I6, I6)') " Time: ", days, seconds + endif write(unit, *) write(unit, '(A, F8.3, A, F8.3)') ' longitude = ', diag_debug_lon(n), ' latitude = ', diag_debug_lat(n) write(unit, '(A, I8, A, I6, A, I6, A, I3)') ' on processor # ', mpp_pe(), ' : local i = ', i, ', local j = ', j, ' tile = ', diag_debug_tile(n) @@ -380,7 +408,9 @@ subroutine debug_column(pt, delp, delz, u, v, w, q, npz, ncnst, sphum, nwat, zvi write(unit, *) '===================================================================' write(unit, *) - flush(unit) + + call flush(unit) + enddo @@ -412,7 +442,7 @@ subroutine debug_column_dyn(pt, delp, delz, u, v, w, q, heat_source, cappa, akap rdg = -rdgas/grav cv_air = cp_air - rdgas - do n=1,size(diag_debug_i) + do n=1,size(diag_debug_units) i=diag_debug_i(n) j=diag_debug_j(n) @@ -423,8 +453,13 @@ subroutine debug_column_dyn(pt, delp, delz, u, v, w, q, heat_source, cappa, akap write(unit, *) "DEBUG POINT ", diag_debug_names(n) write(unit, *) - call get_date(Time, yr, mon, dd, hr, mn, seconds) - write(unit, '(A, I6, A12, 4I4)') " Time: ", yr, month_name(mon), dd, hr, mn, seconds + if (m_calendar) then + call get_date(Time, yr, mon, dd, hr, mn, seconds) + write(unit, '(A, I6, A12, 4I4)') " Time: ", yr, month_name(mon), dd, hr, mn, seconds + else + call get_time (Time, seconds, dd) + write(unit, '(A, I6, I6)') " Time: ", dd, seconds + endif write(unit,*) 'k_split = ', k_step, ', n_split = ', n_step write(unit, *) write(unit, '(A, F8.3, A, F8.3)') ' longitude = ', diag_debug_lon(n), ' latitude = ', diag_debug_lat(n) @@ -471,6 +506,8 @@ subroutine debug_column_dyn(pt, delp, delz, u, v, w, q, heat_source, cappa, akap write(unit, *) '===================================================================' write(unit, *) + call flush(unit) + enddo end subroutine debug_column_dyn @@ -503,9 +540,13 @@ subroutine sounding_column( pt, delp, delz, u, v, q, peln, pkz, thetae, phis, & integer :: i, j, k, n, unit integer :: yr_v, mo_v, dy_v, hr_v, mn_v, sec_v ! need to get numbers for these - call get_date(Time, yr_v, mo_v, dy_v, hr_v, mn_v, sec_v) + if (m_calendar) then + call get_date(Time, yr_v, mo_v, dy_v, hr_v, mn_v, sec_v) + else + call get_time (Time, sec_v, dy_v) + endif - do n=1,size(diag_sonde_i) + do n=1,size(diag_sonde_units) i=diag_sonde_i(n) j=diag_sonde_j(n) @@ -515,11 +556,13 @@ subroutine sounding_column( pt, delp, delz, u, v, q, peln, pkz, thetae, phis, & if (j < bd%js .or. j > bd%je) cycle + if (m_calendar) then write(unit,600) & trim(diag_sonde_names(n)), yr_v, mo_v, dy_v, hr_v, init_str, trim(runname) 600 format(A,'.v', I4, I2.2, I2.2, I2.2, '.i', A10, '.', A, '.dat########################################################') write(unit,601) trim(diag_sonde_names(n)), yr_v, mo_v, dy_v, hr_v, init_str(1:8),init_str(9:10) 601 format(3x, A16, ' Valid ', I4, I2.2, I2.2, '.', I2.2, 'Z Init ', A8, '.', A2, 'Z') + endif write(unit,'(5x, A, 2F8.3)') trim(runname), diag_sonde_lon(n), diag_sonde_lat(n) write(unit,*) write(unit,*) '-------------------------------------------------------------------------------' @@ -564,6 +607,8 @@ subroutine sounding_column( pt, delp, delz, u, v, q, peln, pkz, thetae, phis, & enddo endif + call flush(unit) + enddo diff --git a/tools/fv_diagnostics.F90 b/tools/fv_diagnostics.F90 index ac40d2c88..1d59c63c9 100644 --- a/tools/fv_diagnostics.F90 +++ b/tools/fv_diagnostics.F90 @@ -10,7 +10,7 @@ !* (at your option) any later version. !* !* The FV3 dynamical core is distributed in the hope that it will be -!* useful, but WITHOUT ANYWARRANTY; without even the implied warranty +!* useful, but WITHOUT ANY WARRANTY; without even the implied warranty !* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. !* See the GNU General Public License for more details. !* @@ -24,8 +24,9 @@ module fv_diagnostics_mod - use constants_mod, only: grav, rdgas, rvgas, pi=>pi_8, radius, kappa, WTMAIR, WTMCO2, & - omega, hlv, cp_air, cp_vapor, TFREEZE + use constants_mod, only: grav, rdgas, rvgas, pi=>pi_8, kappa, WTMAIR, WTMCO2, & + hlv, cp_air, cp_vapor, TFREEZE + use fv_arrays_mod, only: radius ! scaled for small earth use fms_mod, only: write_version_number use time_manager_mod, only: time_type, get_date, get_time use mpp_domains_mod, only: domain2d, mpp_update_domains, DGRID_NE, NORTH, EAST @@ -47,9 +48,10 @@ module fv_diagnostics_mod use mpp_mod, only: mpp_error, FATAL, stdlog, mpp_pe, mpp_root_pe, mpp_sum, mpp_max, NOTE, input_nml_file use sat_vapor_pres_mod, only: compute_qs, lookup_es - use fv_arrays_mod, only: max_step - use gfdl_mp_mod, only: wqs1, qsmith_init, c_liq + use fv_arrays_mod, only: max_step + use gfdl_mp_mod, only: wqs1, qsmith_init, c_liq + use rad_ref_mod, only: rad_ref use fv_diag_column_mod, only: fv_diag_column_init, sounding_column, debug_column implicit none @@ -91,12 +93,14 @@ module fv_diagnostics_mod real :: sphum_ll_fix = 0. real :: qcly0 ! initial value for terminator test - public :: fv_diag_init, fv_time, fv_diag, prt_mxm, prt_maxmin, range_check!, id_divg, id_te + logical :: is_ideal_case = .false. + public :: fv_diag_init, fv_time, fv_diag, prt_mxm, prt_maxmin, range_check + public :: prt_mass, prt_minmax, ppme, fv_diag_init_gn, z_sum, sphum_ll_fix, eqv_pot, qcly0, gn - public :: prt_height, prt_gb_nh_sh, interpolate_vertical, rh_calc, get_height_field, dbzcalc - public :: max_vv, get_vorticity, max_uh - public :: max_vorticity, max_vorticity_hy1, bunkers_vector, helicity_relative_CAPS - public :: cs3_interpolator, get_height_given_pressure + public :: prt_height, prt_gb_nh_sh, interpolate_vertical, rh_calc, get_height_field, get_height_given_pressure + public :: cs3_interpolator, get_vorticity, is_ideal_case +! needed by fv_nggps_diag + public :: max_vv, max_uh, bunkers_vector, helicity_relative_CAPS integer, parameter :: MAX_PLEVS = 31 #ifdef FEWER_PLEVS @@ -112,7 +116,7 @@ module fv_diagnostics_mod integer :: yr_init, mo_init, dy_init, hr_init, mn_init, sec_init integer :: id_dx, id_dy - real :: vrange(2), vsrange(2), wrange(2), trange(2), slprange(2), rhrange(2) + real :: vrange(2), vsrange(2), wrange(2), trange(2), slprange(2), rhrange(2), psrange(2), skrange(2) ! integer :: id_d_grid_ucomp, id_d_grid_vcomp ! D grid winds ! integer :: id_c_grid_ucomp, id_c_grid_vcomp ! C grid winds @@ -146,7 +150,7 @@ subroutine fv_diag_init(Atm, axes, Time, npx, npy, npz, p_ref) integer :: id_hyam, id_hybm integer :: id_plev, id_plev_ave_edges, id_plev_ave integer :: i, j, k, m, n, ntileMe, id_xt, id_yt, id_x, id_y, id_xe, id_ye, id_xn, id_yn - integer :: isc, iec, jsc, jec + integer :: isd, ied, jsd, jed, isc, iec, jsc, jec logical :: used @@ -160,12 +164,18 @@ subroutine fv_diag_init(Atm, axes, Time, npx, npy, npz, p_ref) integer :: axe_ave(3) character(len=64) :: errmsg +#ifdef GFS_PHYS + character(len=*), parameter :: massdef_str = " (GFS moist-mass)" +#else + character(len=*), parameter :: massdef_str = "" +#endif logical :: exists integer :: nlunit, ios real, allocatable :: dx(:,:), dy(:,:) call write_version_number ( 'FV_DIAGNOSTICS_MOD', version ) + idiag => Atm(1)%idiag ! For total energy diagnostics: @@ -201,6 +211,12 @@ subroutine fv_diag_init(Atm, axes, Time, npx, npy, npz, p_ref) trange = (/ 100., 350. /) ! temperature #endif slprange = (/800., 1200./) ! sea-level-pressure + skrange = (/ -10000000.0, 10000000.0 /) ! dissipation estimate for SKEB +#ifdef SW_DYNAMICS + psrange = (/.01, 1.e7 /) +#else + psrange = (/40000.0, 110000.0/) +#endif ginv = 1./GRAV if (Atm(1)%grid_number == 1) fv_time = Time @@ -234,6 +250,9 @@ subroutine fv_diag_init(Atm, axes, Time, npx, npy, npz, p_ref) isc = Atm(n)%bd%isc; iec = Atm(n)%bd%iec jsc = Atm(n)%bd%jsc; jec = Atm(n)%bd%jec + isd = Atm(n)%bd%isd; ied = Atm(n)%bd%ied + jsd = Atm(n)%bd%jsd; jed = Atm(n)%bd%jed + ! Send diag_manager the grid informtaion call diag_grid_init(DOMAIN=Atm(n)%domain, & & GLO_LON=rad2deg*Atm(n)%gridstruct%grid(isc:iec+1,jsc:jec+1,1), & @@ -333,20 +352,7 @@ subroutine fv_diag_init(Atm, axes, Time, npx, npy, npz, p_ref) #endif levs_ave = 0 levs_ave(1:4) = (/50,400,850,1000/) -#ifdef INTERNAL_FILE_NML read(input_nml_file, nml=fv_diag_plevs_nml,iostat=ios) -#else - inquire (file=trim(Atm(n)%nml_filename), exist=exists) - if (.not. exists) then - write(errmsg,*) 'fv_diag_plevs_nml: namelist file ',trim(Atm(n)%nml_filename),' does not exist' - call mpp_error(FATAL, errmsg) - else - open (unit=nlunit, file=Atm(n)%nml_filename, READONLY, status='OLD', iostat=ios) - endif - rewind(nlunit) - read (nlunit, nml=fv_diag_plevs_nml, iostat=ios) - close (nlunit) -#endif if (nplev > MAX_PLEVS) then if (is_master()) then print*, ' fv_diagnostics: nplev = ', nplev, ' is too large' @@ -426,7 +432,7 @@ subroutine fv_diag_init(Atm, axes, Time, npx, npy, npz, p_ref) 'dy', 'm') #ifndef DYNAMICS_ZS id_zsurf = register_static_field ( trim(field), 'zsurf', axes(1:2), & - 'surface height', 'm' ) + 'surface height', 'm', interp_method='conserve_order1' ) #endif id_zs = register_static_field ( trim(field), 'zs', axes(1:2), & 'Original Mean Terrain', 'm' ) @@ -565,13 +571,13 @@ subroutine fv_diag_init(Atm, axes, Time, npx, npy, npz, p_ref) #ifdef DYNAMICS_ZS id_zsurf = register_diag_field ( trim(field), 'zsurf', axes(1:2), Time, & - 'surface height', 'm') + 'surface height', 'm', interp_method='conserve_order1') #endif !------------------- ! Surface pressure !------------------- id_ps = register_diag_field ( trim(field), 'ps', axes(1:2), Time, & - 'surface pressure', 'Pa', missing_value=missing_value ) + 'surface pressure', 'Pa', missing_value=missing_value, range=psrange) !------------------- ! Mountain torque @@ -589,6 +595,8 @@ subroutine fv_diag_init(Atm, axes, Time, npx, npy, npz, p_ref) !------------------- ! Precipitation from GFDL MP !------------------- + id_prec = register_diag_field ( trim(field), 'prec', axes(1:2), Time, & + 'total precipitation', 'mm/day', missing_value=missing_value ) id_prer = register_diag_field ( trim(field), 'prer', axes(1:2), Time, & 'rain precipitation', 'mm/day', missing_value=missing_value ) id_prei = register_diag_field ( trim(field), 'prei', axes(1:2), Time, & @@ -623,7 +631,7 @@ subroutine fv_diag_init(Atm, axes, Time, npx, npy, npz, p_ref) id_liq_wat_dt_gfdlmp = register_diag_field ( trim(field), 'liq_wat_dt_gfdlmp', axes(1:3), Time, & 'liquid water tracer tendency from GFDL MP', 'kg/kg/s', missing_value=missing_value ) if (id_liq_wat_dt_gfdlmp > 0) allocate(Atm(n)%inline_mp%liq_wat_dt(isc:iec,jsc:jec,npz)) - id_ice_wat_dt_gfdlmp = register_diag_field ( trim(field), 'ice_dt_wat_gfdlmp', axes(1:3), Time, & + id_ice_wat_dt_gfdlmp = register_diag_field ( trim(field), 'ice_wat_dt_gfdlmp', axes(1:3), Time, & 'ice water tracer tendency from GFDL MP', 'kg/kg/s', missing_value=missing_value ) if (id_ice_wat_dt_gfdlmp > 0) allocate(Atm(n)%inline_mp%ice_wat_dt(isc:iec,jsc:jec,npz)) @@ -687,13 +695,28 @@ subroutine fv_diag_init(Atm, axes, Time, npx, npy, npz, p_ref) idiag%id_T_dt_sg = register_diag_field ( trim(field), 'T_dt_sg', axes(1:3), Time, & 'temperature tendency from 2dz subgrid mixing', 'K/s', missing_value=missing_value ) + if ((idiag%id_t_dt_sg > 0) .and. (.not. allocated(Atm(n)%sg_diag%t_dt))) then + allocate (Atm(n)%sg_diag%t_dt(isc:iec,jsc:jec,1:npz)) + Atm(n)%sg_diag%t_dt = 0.0 + endif idiag%id_u_dt_sg = register_diag_field ( trim(field), 'u_dt_sg', axes(1:3), Time, & 'zonal wind tendency from 2dz subgrid mixing', 'm/s/s', missing_value=missing_value ) + if ((idiag%id_u_dt_sg > 0) .and. (.not. allocated(Atm(n)%sg_diag%u_dt))) then + allocate (Atm(n)%sg_diag%u_dt(isc:iec,jsc:jec,1:npz)) + Atm(n)%sg_diag%u_dt = 0.0 + endif idiag%id_v_dt_sg = register_diag_field ( trim(field), 'v_dt_sg', axes(1:3), Time, & 'meridional wind tendency from 2dz subgrid mixing', 'm/s/s', missing_value=missing_value ) + if ((idiag%id_v_dt_sg > 0) .and. (.not. allocated(Atm(n)%sg_diag%v_dt))) then + allocate (Atm(n)%sg_diag%v_dt(isc:iec,jsc:jec,1:npz)) + Atm(n)%sg_diag%v_dt = 0.0 + endif idiag%id_qv_dt_sg = register_diag_field ( trim(field), 'qv_dt_sg', axes(1:3), Time, & 'water vapor tendency from 2dz subgrid mixing', 'kg/kg/s', missing_value=missing_value ) - + if ((idiag%id_qv_dt_sg > 0) .and. (.not. allocated(Atm(n)%sg_diag%qv_dt))) then + allocate (Atm(n)%sg_diag%qv_dt(isc:iec,jsc:jec,1:npz)) + Atm(n)%sg_diag%qv_dt = 0.0 + endif ! Nudging tendencies id_t_dt_nudge = register_diag_field('dynamics', & @@ -736,6 +759,7 @@ subroutine fv_diag_init(Atm, axes, Time, npx, npy, npz, p_ref) allocate (Atm(n)%nudge_diag%nudge_v_dt(isc:iec,jsc:jec,npz)) Atm(n)%nudge_diag%nudge_v_dt(isc:iec,jsc:jec,1:npz) = 0.0 endif + endif ! @@ -766,8 +790,13 @@ subroutine fv_diag_init(Atm, axes, Time, npx, npy, npz, p_ref) 'zonal wind', 'm/sec', missing_value=missing_value, range=vrange ) id_v_plev = register_diag_field ( trim(field), 'v_plev', axe2(1:3), Time, & 'meridional wind', 'm/sec', missing_value=missing_value, range=vrange ) - id_t_plev = register_diag_field ( trim(field), 't_plev', axe2(1:3), Time, & - 'temperature', 'K', missing_value=missing_value, range=trange ) + if (is_ideal_case) then + id_t_plev = register_diag_field ( trim(field), 't_plev', axe2(1:3), Time, & + 'temperature', 'K', missing_value=missing_value ) + else + id_t_plev = register_diag_field ( trim(field), 't_plev', axe2(1:3), Time, & + 'temperature', 'K', missing_value=missing_value, range=trange ) + endif id_h_plev = register_diag_field ( trim(field), 'h_plev', axe2(1:3), Time, & 'height', 'm', missing_value=missing_value ) id_q_plev = register_diag_field ( trim(field), 'q_plev', axe2(1:3), Time, & @@ -776,7 +805,6 @@ subroutine fv_diag_init(Atm, axes, Time, npx, npy, npz, p_ref) 'omega', 'Pa/s', missing_value=missing_value ) endif - !Layer averages for temperature, moisture, etc. id_t_plev_ave = register_diag_field(trim(field), 't_plev_ave', axe_ave(1:3), Time, & 'layer-averaged temperature', 'K', missing_value=missing_value) @@ -794,6 +822,7 @@ subroutine fv_diag_init(Atm, axes, Time, npx, npy, npz, p_ref) id_t_dt_phys_plev_ave = register_diag_field ( trim(field), 't_dt_phys_plev_ave', axe_ave(1:3), Time, & 'layer-averaged temperature tendency from physics', 'K/s', missing_value=missing_value ) if (id_t_dt_phys_plev_ave > 0 .and. .not. allocated(Atm(n)%phys_diag%phys_t_dt) ) allocate(Atm(n)%phys_diag%phys_t_dt(isc:iec,jsc:jec,npz)) + ! flag for calculation of geopotential if ( any(id_h > 0) .or. id_h_plev>0 .or. id_hght3d>0) then id_any_hght = 1 @@ -856,9 +885,13 @@ subroutine fv_diag_init(Atm, axes, Time, npx, npy, npz, p_ref) if ( .not. Atm(n)%flagstruct%hydrostatic ) & id_w = register_diag_field ( trim(field), 'w', axes(1:3), Time, & 'vertical wind', 'm/sec', missing_value=missing_value, range=wrange ) - - id_pt = register_diag_field ( trim(field), 'temp', axes(1:3), Time, & - 'temperature', 'K', missing_value=missing_value, range=trange ) + if (is_ideal_case) then + id_pt = register_diag_field ( trim(field), 'temp', axes(1:3), Time, & + 'temperature', 'K', missing_value=missing_value ) + else + id_pt = register_diag_field ( trim(field), 'temp', axes(1:3), Time, & + 'temperature', 'K', missing_value=missing_value, range=trange ) + endif id_ppt = register_diag_field ( trim(field), 'ppt', axes(1:3), Time, & 'potential temperature perturbation', 'K', missing_value=missing_value ) id_theta_e = register_diag_field ( trim(field), 'theta_e', axes(1:3), Time, & @@ -867,6 +900,9 @@ subroutine fv_diag_init(Atm, axes, Time, npx, npy, npz, p_ref) 'omega', 'Pa/s', missing_value=missing_value ) idiag%id_divg = register_diag_field ( trim(field), 'divg', axes(1:3), Time, & 'mean divergence', '1/s', missing_value=missing_value ) +! diagnotic output for skeb testing + id_diss = register_diag_field ( trim(field), 'diss_est', axes(1:3), Time, & + 'random', 'none', missing_value=missing_value, range=skrange ) id_hght3d = register_diag_field( trim(field), 'hght', axes(1:3), Time, & 'height', 'm', missing_value=missing_value ) @@ -875,16 +911,18 @@ subroutine fv_diag_init(Atm, axes, Time, npx, npy, npz, p_ref) 'Relative Humidity', '%', missing_value=missing_value ) ! 'Relative Humidity', '%', missing_value=missing_value, range=rhrange ) id_delp = register_diag_field ( trim(field), 'delp', axes(1:3), Time, & - 'pressure thickness', 'pa', missing_value=missing_value ) + 'pressure thickness'//massdef_str, 'pa', missing_value=missing_value ) if ( .not. Atm(n)%flagstruct%hydrostatic ) & id_delz = register_diag_field ( trim(field), 'delz', axes(1:3), Time, & 'height thickness', 'm', missing_value=missing_value ) if( Atm(n)%flagstruct%hydrostatic ) then id_pfhy = register_diag_field ( trim(field), 'pfhy', axes(1:3), Time, & - 'hydrostatic pressure', 'pa', missing_value=missing_value ) + 'hydrostatic pressure'//massdef_str, 'pa', missing_value=missing_value ) else id_pfnh = register_diag_field ( trim(field), 'pfnh', axes(1:3), Time, & - 'non-hydrostatic pressure', 'pa', missing_value=missing_value ) + 'non-hydrostatic pressure'//massdef_str, 'pa', missing_value=missing_value ) + id_ppnh = register_diag_field ( trim(field), 'ppnh', axes(1:3), Time, & + 'non-hydrostatic pressure perturbation', 'pa', missing_value=missing_value ) endif !-------------------- ! 3D Condensate @@ -916,14 +954,6 @@ subroutine fv_diag_init(Atm, axes, Time, npx, npy, npz, p_ref) id_pv550K = register_diag_field ( trim(field), 'pv550K', axes(1:2), Time, & '550-K potential vorticity; needs x550 scaling', '(K m**2) / (kg s)', missing_value=missing_value) - ! ------------------- - ! Vertical flux correlation terms (good for averages) - ! ------------------- - id_uw = register_diag_field ( trim(field), 'uw', axes(1:3), Time, & - 'vertical zonal momentum flux', 'N/m**2', missing_value=missing_value ) - id_vw = register_diag_field ( trim(field), 'vw', axes(1:3), Time, & - 'vertical meridional momentum flux', 'N/m**', missing_value=missing_value ) - !-------------------- ! 3D flux terms !-------------------- @@ -956,6 +986,7 @@ subroutine fv_diag_init(Atm, axes, Time, npx, npy, npz, p_ref) id_ww = register_diag_field ( trim(field), 'ww', axes(1:3), Time, & 'vertical flux of vertical wind', '(m/sec)^2', missing_value=missing_value ) endif + !-------------------- ! vertical integral of 3D flux terms !-------------------- @@ -1040,6 +1071,10 @@ subroutine fv_diag_init(Atm, axes, Time, npx, npy, npz, p_ref) 'Convective available potential energy (surface-based)', 'J/kg' , missing_value=missing_value ) id_cin = register_diag_field( trim(field), 'cin', axes(1:2), Time, & 'Convective inhibition (surface-based)', 'J/kg' , missing_value=missing_value ) + id_brn = register_diag_field( trim(field), 'BRN', axes(1:2), Time, & + 'Bulk Richardson Number', 'nondim' , missing_value=missing_value ) + id_shear06 = register_diag_field( trim(field), 'shear06', axes(1:2), Time, & + '0--6 km shear', 'm/s' , missing_value=missing_value ) !-------------------------- ! Vertically integrated tracers for GFDL MP !-------------------------- @@ -1056,14 +1091,12 @@ subroutine fv_diag_init(Atm, axes, Time, npx, npy, npz, p_ref) id_intqg = register_diag_field ( trim(field), 'intqg', axes(1:2), Time, & 'Vertically Integrated Graupel', 'kg/m**2', missing_value=missing_value ) -#ifdef HIWPP id_acl = register_diag_field ( trim(field), 'acl', axes(1:2), Time, & 'Column-averaged Cl mixing ratio', 'kg/kg', missing_value=missing_value ) id_acl2 = register_diag_field ( trim(field), 'acl2', axes(1:2), Time, & 'Column-averaged Cl2 mixing ratio', 'kg/kg', missing_value=missing_value ) id_acly = register_diag_field ( trim(field), 'acly', axes(1:2), Time, & 'Column-averaged total chlorine mixing ratio', 'kg/kg', missing_value=missing_value ) -#endif !-------------------------- ! 850-mb vorticity @@ -1288,14 +1321,8 @@ subroutine fv_diag_init(Atm, axes, Time, npx, npy, npz, p_ref) ! end do -#ifdef TEST_TRACER - call prt_mass(npz, Atm(n)%ncnst, isc, iec, jsc, jec, Atm(n)%ng, max(1,Atm(n)%flagstruct%nwat), & - Atm(n)%ps, Atm(n)%delp, Atm(n)%q, Atm(n)%gridstruct%area_64, Atm(n)%domain) -#else call prt_mass(npz, Atm(n)%ncnst, isc, iec, jsc, jec, Atm(n)%ng, Atm(n)%flagstruct%nwat, & Atm(n)%ps, Atm(n)%delp, Atm(n)%q, Atm(n)%gridstruct%area_64, Atm(n)%domain) -#endif - !Model initialization time (not necessarily the time this simulation is started, ! conceivably a restart could be done @@ -1312,8 +1339,7 @@ subroutine fv_diag_init(Atm, axes, Time, npx, npy, npz, p_ref) if(id_theta_e >0 ) call qsmith_init #endif - call fv_diag_column_init(Atm(n), yr_init, mo_init, dy_init, hr_init, do_diag_debug, do_diag_sonde, sound_freq) - + call fv_diag_column_init(Atm(n), yr_init, mo_init, dy_init, hr_init, do_diag_debug, do_diag_sonde, sound_freq, m_calendar) end subroutine fv_diag_init @@ -1513,6 +1539,7 @@ subroutine fv_diag(Atm, zvir, Time, print_freq) call prt_maxmin('PS', Atm(n)%ps, isc, iec, jsc, jec, ngc, 1, 0.01) #ifdef HIWPP + if (.not. Atm(n)%gridstruct%bounded_domain ) then allocate(var2(isc:iec,jsc:jec)) !hemispheric max/min pressure do j=jsc,jec @@ -1531,15 +1558,11 @@ subroutine fv_diag(Atm, zvir, Time, print_freq) call prt_maxmin('SH PS', var2, isc, iec, jsc, jec, 0, 1, 0.01) deallocate(var2) + endif #endif -#ifdef TEST_TRACER - call prt_mass(npz, nq, isc, iec, jsc, jec, ngc, max(1,Atm(n)%flagstruct%nwat), & - Atm(n)%ps, Atm(n)%delp, Atm(n)%q, Atm(n)%gridstruct%area_64, Atm(n)%domain) -#else call prt_mass(npz, nq, isc, iec, jsc, jec, ngc, Atm(n)%flagstruct%nwat, & Atm(n)%ps, Atm(n)%delp, Atm(n)%q, Atm(n)%gridstruct%area_64, Atm(n)%domain) -#endif #ifndef SW_DYNAMICS if (Atm(n)%flagstruct%consv_te > 1.e-5) then @@ -1599,15 +1622,16 @@ subroutine fv_diag(Atm, zvir, Time, print_freq) call range_check('VA', Atm(n)%va, isc, iec, jsc, jec, ngc, npz, Atm(n)%gridstruct%agrid, & -250., 250., bad_range, Time) #ifndef SW_DYNAMICS - call range_check('TA', Atm(n)%pt, isc, iec, jsc, jec, ngc, npz, Atm(n)%gridstruct%agrid, & -#ifdef HIWPP - 130., 350., bad_range, Time) !DCMIP ICs have very low temperatures -#else + if (is_ideal_case) then + call range_check('TA', Atm(n)%pt, isc, iec, jsc, jec, ngc, npz, Atm(n)%gridstruct%agrid, & + 100., 500., bad_range, Time) !DCMIP ICs have very wide range of temperatures + else + call range_check('TA', Atm(n)%pt, isc, iec, jsc, jec, ngc, npz, Atm(n)%gridstruct%agrid, & 150., 350., bad_range, Time) -#endif -#endif + endif call range_check('Qv', Atm(n)%q(:,:,:,sphum), isc, iec, jsc, jec, ngc, npz, Atm(n)%gridstruct%agrid, & -1.e-8, 1.e20, bad_range, Time) +#endif endif @@ -1631,14 +1655,28 @@ subroutine fv_diag(Atm, zvir, Time, print_freq) ! if (id_c_grid_vcomp > 0) used = send_data(id_c_grid_vcomp, Atm(n)%vc(isc:iec,jsc:jec+1,1:npz), Time) #ifdef DYNAMICS_ZS + !This is here for idealized test cases that modify the topography in time + do j=jsc,jec + do i=isc,iec + zsurf(i,j) = ginv * Atm(n)%phis(i,j) + enddo + enddo + if(id_zsurf > 0) used=send_data(id_zsurf, zsurf, Time) #endif if(id_ps > 0) used=send_data(id_ps, Atm(n)%ps(isc:iec,jsc:jec), Time) + if(id_prec > 0) used=send_data(id_prec, Atm(n)%inline_mp%prer(isc:iec,jsc:jec)+ & + Atm(n)%inline_mp%prei(isc:iec,jsc:jec)+ & + Atm(n)%inline_mp%pres(isc:iec,jsc:jec)+Atm(n)%inline_mp%preg(isc:iec,jsc:jec), Time) if(id_prer > 0) used=send_data(id_prer, Atm(n)%inline_mp%prer(isc:iec,jsc:jec), Time) if(id_prei > 0) used=send_data(id_prei, Atm(n)%inline_mp%prei(isc:iec,jsc:jec), Time) if(id_pres > 0) used=send_data(id_pres, Atm(n)%inline_mp%pres(isc:iec,jsc:jec), Time) if(id_preg > 0) used=send_data(id_preg, Atm(n)%inline_mp%preg(isc:iec,jsc:jec), Time) + if(id_cond > 0) used=send_data(id_cond, Atm(n)%inline_mp%cond(isc:iec,jsc:jec), Time) + if(id_dep > 0) used=send_data(id_dep, Atm(n)%inline_mp%dep(isc:iec,jsc:jec), Time) + if(id_reevap > 0) used=send_data(id_reevap, Atm(n)%inline_mp%reevap(isc:iec,jsc:jec), Time) + if(id_sub > 0) used=send_data(id_sub, Atm(n)%inline_mp%sub(isc:iec,jsc:jec), Time) if (id_qv_dt_gfdlmp > 0) used=send_data(id_qv_dt_gfdlmp, Atm(n)%inline_mp%qv_dt(isc:iec,jsc:jec,1:npz), Time) if (id_ql_dt_gfdlmp > 0) used=send_data(id_ql_dt_gfdlmp, Atm(n)%inline_mp%ql_dt(isc:iec,jsc:jec,1:npz), Time) @@ -1670,6 +1708,11 @@ subroutine fv_diag(Atm, zvir, Time, print_freq) if (id_u_dt_nudge > 0) used=send_data(id_u_dt_nudge, Atm(n)%nudge_diag%nudge_u_dt(isc:iec,jsc:jec,1:npz), Time) if (id_v_dt_nudge > 0) used=send_data(id_v_dt_nudge, Atm(n)%nudge_diag%nudge_v_dt(isc:iec,jsc:jec,1:npz), Time) + if (idiag%id_t_dt_sg > 0) used=send_data(idiag%id_t_dt_sg, Atm(n)%sg_diag%t_dt(isc:iec,jsc:jec,1:npz), Time) + if (idiag%id_u_dt_sg > 0) used=send_data(idiag%id_u_dt_sg, Atm(n)%sg_diag%u_dt(isc:iec,jsc:jec,1:npz), Time) + if (idiag%id_v_dt_sg > 0) used=send_data(idiag%id_v_dt_sg, Atm(n)%sg_diag%v_dt(isc:iec,jsc:jec,1:npz), Time) + if (idiag%id_qv_dt_sg > 0) used=send_data(idiag%id_qv_dt_sg, Atm(n)%sg_diag%qv_dt(isc:iec,jsc:jec,1:npz), Time) + if(id_c15>0 .or. id_c25>0 .or. id_c35>0 .or. id_c45>0) then call wind_max(isc, iec, jsc, jec ,isd, ied, jsd, jed, Atm(n)%ua(isc:iec,jsc:jec,npz), & Atm(n)%va(isc:iec,jsc:jec,npz), ws_max, Atm(n)%domain) @@ -1846,7 +1889,7 @@ subroutine fv_diag(Atm, zvir, Time, print_freq) allocate ( a3(isc:iec,jsc:jec,npz+1) ) ! Modified pv_entropy to get potential temperature at layer interfaces (last variable) ! The values are needed for interpolate_z - ! Note: this is expensive computation. + ! Note: this is expensive computation. call pv_entropy(isc, iec, jsc, jec, ngc, npz, wk, & Atm(n)%gridstruct%f0, Atm(n)%pt, Atm(n)%pkz, Atm(n)%delp, grav, a3) if ( id_pv > 0) then @@ -2454,7 +2497,7 @@ subroutine fv_diag(Atm, zvir, Time, print_freq) enddo used = send_data(id_tq, a2*ginv, Time) endif -#ifdef HIWPP + Cl = get_tracer_index (MODEL_ATMOS, 'Cl') Cl2 = get_tracer_index (MODEL_ATMOS, 'Cl2') if (Cl > 0 .and. Cl2 > 0) then @@ -2549,7 +2592,7 @@ subroutine fv_diag(Atm, zvir, Time, print_freq) deallocate(var2) endif -#endif + if ( id_iw>0 ) then a2 = 0. if (ice_wat > 0) then @@ -2862,7 +2905,9 @@ subroutine fv_diag(Atm, zvir, Time, print_freq) #ifdef GFS_PHYS - if(id_delp > 0 .or. id_cape > 0 .or. id_cin > 0 .or. ((.not. Atm(n)%flagstruct%hydrostatic) .and. id_pfnh > 0)) then + if(id_delp > 0 .or. id_cape > 0 .or. id_cin > 0 .or. & + ((.not. Atm(n)%flagstruct%hydrostatic) .and. (id_pfnh > 0 .or. id_ppnh > 0)) .or. & + id_brn > 0 .or. id_shear06 > 0) then do k=1,npz do j=jsc,jec do i=isc,iec @@ -2872,49 +2917,66 @@ subroutine fv_diag(Atm, zvir, Time, print_freq) enddo if (id_delp > 0) used=send_data(id_delp, wk, Time) endif - - if( ( (.not. Atm(n)%flagstruct%hydrostatic) .and. id_pfnh > 0) .or. id_cape > 0 .or. id_cin > 0) then - do k=1,npz - do j=jsc,jec - do i=isc,iec - wk(i,j,k) = -wk(i,j,k)/(Atm(n)%delz(i,j,k)*grav)*rdgas* & - Atm(n)%pt(i,j,k)*(1.+zvir*Atm(n)%q(i,j,k,sphum)) - enddo - enddo - enddo -! if (prt_minmax) then -! call prt_maxmin(' PFNH (mb)', wk(isc:iec,jsc:jec,1), isc, iec, jsc, jec, 0, npz, 1.E-2) -! endif - used=send_data(id_pfnh, wk, Time) - endif #else if(id_delp > 0) used=send_data(id_delp, Atm(n)%delp(isc:iec,jsc:jec,:), Time) +#endif + if( ( (.not. Atm(n)%flagstruct%hydrostatic) .and. (id_pfnh > 0 .or. id_ppnh > 0)) .or. id_cape > 0 .or. id_cin > 0 .or. & + id_brn > 0 .or. id_shear06 > 0) then - if( (.not. Atm(n)%flagstruct%hydrostatic) .and. (id_pfnh > 0 .or. id_cape > 0 .or. id_cin > 0)) then - do k=1,npz + do k=1,npz do j=jsc,jec do i=isc,iec +#ifdef GFS_PHYS + wk(i,j,k) = -wk(i,j,k)/(Atm(n)%delz(i,j,k)*grav)*rdgas* & + Atm(n)%pt(i,j,k)*(1.+zvir*Atm(n)%q(i,j,k,sphum)) +#else wk(i,j,k) = -Atm(n)%delp(i,j,k)/(Atm(n)%delz(i,j,k)*grav)*rdgas* & Atm(n)%pt(i,j,k)*(1.+zvir*Atm(n)%q(i,j,k,sphum)) + +#endif enddo enddo enddo +! if (prt_minmax) then +! call prt_maxmin(' PFNH (mb)', wk(isc:iec,jsc:jec,1), isc, iec, jsc, jec, 0, npz, 1.E-2) +! endif used=send_data(id_pfnh, wk, Time) - endif + if (id_ppnh > 0) then + do k=1,npz + do j=jsc,jec + do i=isc,iec + !wk(i,j,k) = wk(i,j,k) - a3(i,j,k) +#ifdef GFS_PHYS + wk(i,j,k) = wk(i,j,k)/(1.-sum(Atm(n)%q(i,j,k,2:Atm(n)%flagstruct%nwat))) !Need to correct #endif + tmp = Atm(n)%delp(i,j,k)/(Atm(n)%peln(i,k+1,j)-Atm(n)%peln(i,k,j)) + wk(i,j,k) = wk(i,j,k) - tmp + enddo + enddo + enddo + if (id_ppnh > 0) used=send_data(id_ppnh, wk, Time) + endif + +! if (allocated(a3)) deallocate(a3) + + endif - if( Atm(n)%flagstruct%hydrostatic .and. (id_pfhy > 0 .or. id_cape > 0 .or. id_cin > 0) ) then + if( Atm(n)%flagstruct%hydrostatic .and. (id_pfhy > 0 .or. id_cape > 0 .or. id_cin > 0 .or. id_brn > 0 .or. id_shear06 > 0) ) then do k=1,npz do j=jsc,jec do i=isc,iec - wk(i,j,k) = 0.5 *(Atm(n)%pe(i,k,j)+Atm(n)%pe(i,k+1,j)) +#ifdef GFS_PHYS + wk(i,j,k) = 0.5 *(Atm(n)%pe(i,k,j)+Atm(n)%pe(i,k+1,j)) +#else + wk(i,j,k) = Atm(n)%delp(i,j,k)/(Atm(n)%peln(i,k+1,j)-Atm(n)%peln(i,k,j)) +#endif enddo enddo enddo used=send_data(id_pfhy, wk, Time) endif - if (id_cape > 0 .or. id_cin > 0) then + if (id_cape > 0 .or. id_cin > 0 .or. id_brn > 0 .or. id_shear06 > 0) then !wk here contains layer-mean pressure allocate(var2(isc:iec,jsc:jec)) @@ -2946,6 +3008,10 @@ subroutine fv_diag(Atm, zvir, Time, print_freq) used=send_data(id_cin, var2, Time) endif + if (id_brn > 0 .or. id_shear06 > 0) then + call compute_brn(Atm(n)%ua,Atm(n)%va,Atm(n)%delp,Atm(n)%delz,a2,Atm(n)%bd,npz,Time) + endif + deallocate(var2) deallocate(a3) @@ -3064,10 +3130,10 @@ subroutine fv_diag(Atm, zvir, Time, print_freq) if (.not. allocated(a3)) allocate(a3(isc:iec,jsc:jec,npz)) -! call dbzcalc_smithxue(Atm(n)%q, Atm(n)%pt, Atm(n)%delp, Atm(n)%peln, Atm(n)%delz, & - call dbzcalc(Atm(n)%q, Atm(n)%pt, Atm(n)%delp, Atm(n)%peln, Atm(n)%delz, & + call rad_ref(Atm(n)%q, Atm(n)%pt, Atm(n)%delp, Atm(n)%peln, Atm(n)%delz, & a3, a2, allmax, Atm(n)%bd, npz, Atm(n)%ncnst, Atm(n)%flagstruct%hydrostatic, & - zvir, .false., .false., .false., .true., Atm(n)%flagstruct%do_inline_mp ) ! GFDL MP has constant N_0 intercept + zvir, .false., .false., .false., .true., Atm(n)%flagstruct%do_inline_mp, & + sphum, liq_wat, ice_wat, rainwat, snowwat, graupel, mp_top) ! GFDL MP has constant N_0 intercept if (id_dbz > 0) used=send_data(id_dbz, a3, time) if (id_maxdbz > 0) used=send_data(id_maxdbz, a2, time) @@ -3248,19 +3314,19 @@ subroutine fv_diag(Atm, zvir, Time, print_freq) enddo if ( id_t_plev_ave > 0) then do j=jsc,jec - call mappm(npz, Atm(n)%peln(isc:iec,1:npz+1,j), Atm(n)%pt(isc:iec,j,:), nplev_ave, a2, a3(isc:iec,j,:), isc, iec, 1, 4, ptop) + call mappm(npz, Atm(n)%peln(isc:iec,1:npz+1,j), Atm(n)%pt(isc:iec,j,:), nplev_ave, a2, a3(isc:iec,j,:), isc, iec, 1, 4) enddo if (id_t_plev_ave > 0) used=send_data(id_t_plev_ave, a3, Time) endif if ( id_t_dt_gfdlmp_plev_ave > 0 ) then do j=jsc,jec - call mappm(npz, Atm(n)%peln(isc:iec,1:npz+1,j), Atm(n)%inline_mp%t_dt(isc:iec,j,:), nplev_ave, a2, a3(isc:iec,j,:), isc, iec, 1, 4, ptop) + call mappm(npz, Atm(n)%peln(isc:iec,1:npz+1,j), Atm(n)%inline_mp%t_dt(isc:iec,j,:), nplev_ave, a2, a3(isc:iec,j,:), isc, iec, 1, 4) enddo if (id_t_dt_gfdlmp_plev_ave > 0) used=send_data(id_t_dt_gfdlmp_plev_ave, a3, Time) endif if ( id_t_dt_phys_plev_ave > 0 ) then do j=jsc,jec - call mappm(npz, Atm(n)%peln(isc:iec,1:npz+1,j), Atm(n)%phys_diag%phys_t_dt(isc:iec,j,:), nplev_ave, a2, a3(isc:iec,j,:), isc, iec, 1, 4, ptop) + call mappm(npz, Atm(n)%peln(isc:iec,1:npz+1,j), Atm(n)%phys_diag%phys_t_dt(isc:iec,j,:), nplev_ave, a2, a3(isc:iec,j,:), isc, iec, 1, 4) enddo if (id_t_dt_phys_plev_ave > 0) used=send_data(id_t_dt_phys_plev_ave, a3, Time) endif @@ -3271,19 +3337,19 @@ subroutine fv_diag(Atm, zvir, Time, print_freq) enddo if ( id_q_plev_ave > 0 ) then do j=jsc,jec - call mappm(npz, Atm(n)%pe(isc:iec,1:npz+1,j), Atm(n)%q(isc:iec,j,:,sphum), nplev_ave, a2, a3(isc:iec,j,:), isc, iec, 0, 8, ptop) + call mappm(npz, Atm(n)%pe(isc:iec,1:npz+1,j), Atm(n)%q(isc:iec,j,:,sphum), nplev_ave, a2, a3(isc:iec,j,:), isc, iec, 0, 8) enddo if (id_q_plev_ave > 0) used=send_data(id_q_plev_ave, a3, Time) endif if ( id_qv_dt_gfdlmp_plev_ave > 0 ) then do j=jsc,jec - call mappm(npz, Atm(n)%pe(isc:iec,1:npz+1,j), Atm(n)%inline_mp%qv_dt(isc:iec,j,:), nplev_ave, a2, a3(isc:iec,j,:), isc, iec, 0, 8, ptop) + call mappm(npz, Atm(n)%pe(isc:iec,1:npz+1,j), Atm(n)%inline_mp%qv_dt(isc:iec,j,:), nplev_ave, a2, a3(isc:iec,j,:), isc, iec, 0, 8) enddo if (id_qv_dt_gfdlmp_plev_ave > 0) used=send_data(id_qv_dt_gfdlmp_plev_ave, a3, Time) endif if ( id_qv_dt_phys_plev_ave > 0 ) then do j=jsc,jec - call mappm(npz, Atm(n)%pe(isc:iec,1:npz+1,j), Atm(n)%phys_diag%phys_qv_dt(isc:iec,j,:), nplev_ave, a2, a3(isc:iec,j,:), isc, iec, 0, 8, ptop) + call mappm(npz, Atm(n)%pe(isc:iec,1:npz+1,j), Atm(n)%phys_diag%phys_qv_dt(isc:iec,j,:), nplev_ave, a2, a3(isc:iec,j,:), isc, iec, 0, 8) enddo if (id_qv_dt_phys_plev_ave > 0) used=send_data(id_qv_dt_phys_plev_ave, a3, Time) endif @@ -3369,6 +3435,7 @@ subroutine fv_diag(Atm, zvir, Time, print_freq) if(id_pt > 0) used=send_data(id_pt , Atm(n)%pt (isc:iec,jsc:jec,:), Time) if(id_omga > 0) used=send_data(id_omga, Atm(n)%omga(isc:iec,jsc:jec,:), Time) + if(id_diss > 0) used=send_data(id_diss, Atm(n)%diss_est(isc:iec,jsc:jec,:), Time) allocate( a3(isc:iec,jsc:jec,npz) ) if(id_theta_e > 0 ) then @@ -3458,8 +3525,6 @@ subroutine fv_diag(Atm, zvir, Time, print_freq) deallocate ( pt1 ) endif - -#ifndef SW_DYNAMICS do itrac=1, Atm(n)%ncnst call get_tracer_names (MODEL_ATMOS, itrac, tname) if (id_tracer(itrac) > 0 .and. itrac.gt.nq) then @@ -3613,6 +3678,7 @@ subroutine fv_diag(Atm, zvir, Time, print_freq) endif endif +#ifndef SW_DYNAMICS ! terms related with vertical wind ( Atm(n)%w ): if(.not.Atm(n)%flagstruct%hydrostatic) then ! vertical moisture flux @@ -3693,6 +3759,7 @@ subroutine fv_diag(Atm, zvir, Time, print_freq) endif deallocate ( a4 ) +#endif ! Maximum overlap cloud fraction if ( .not. Atm(n)%gridstruct%bounded_domain ) then @@ -3710,7 +3777,6 @@ subroutine fv_diag(Atm, zvir, Time, print_freq) endif endif -#endif if (do_diag_debug) then call debug_column(Atm(n)%pt, Atm(n)%delp, Atm(n)%delz, Atm(n)%u, Atm(n)%v, Atm(n)%w, Atm(n)%q, & @@ -3883,9 +3949,16 @@ subroutine range_check_3d(qname, q, is, ie, js, je, n_g, km, pos, q_low, q_hi, b if( qminq_hi ) then if(master) write(*,*) 'Range_check Warning:', qname, ' max = ', qmax, ' min = ', qmin if (present(Time)) then - call get_date(Time, year, month, day, hour, minute, second) - if (master) write(*,999) year, month, day, hour, minute, second -999 format(' Range violation on: ', I4, '/', I02, '/', I02, ' ', I02, ':', I02, ':', I02) + if (m_calendar) then + call get_date(Time, year, month, day, hour, minute, second) + if (master) write(*,999) year, month, day, hour, minute, second +999 format(' Range violation on: ', I4, '/', I02, '/', I02, ' ', I02, ':', I02, ':', I02) + else + call get_time(Time, second, day) + year = 0 ; month = 0 ; hour = 0 ; minute = 0 + if (master) write(*,996) day, second +996 format(' Range violation on: ', I6, ' days ', I05, ' seconds') + endif endif if ( present(bad_range) ) then bad_range = .true. @@ -4419,11 +4492,11 @@ subroutine cs3_interpolator(is, ie, js, je, km, qin, kd, pout, wz, pe, id, qout, real, parameter:: gcp = grav / cp_air real:: qe(is:ie,km+1) real, dimension(is:ie,km):: q2, dp - real:: s0, a6 + real:: s0, a6, alpha, pbot, ts, t0, tmp integer:: i,j,k, n, k1 !$OMP parallel do default(none) shared(iv,id,is,ie,js,je,km,kd,pout,qin,qout,pe,wz) & -!$OMP private(k1,s0,a6,q2,dp,qe) +!$OMP private(k1,s0,a6,q2,dp,qe,pbot,alpha,ts,t0,tmp) do j=js,je do i=is,ie @@ -4445,11 +4518,32 @@ subroutine cs3_interpolator(is, ie, js, je, km, qin, kd, pout, wz, pe, id, qout, elseif ( pout(n) >= pe(i,km+1,j) ) then ! lower than the bottom surface: if ( iv==1 ) then ! Temperature +!----------------------------------------------------------------------- +! Linjiong Zhou: this idea is good, but the formula is wrong. ! lower than the bottom surface: ! mean (hydro) potential temp based on lowest 2-3 layers (NCEP method) ! temp = ptm * p**cappa = ptm * exp(cappa*log(pout)) - qout(i,j,n) = gcp*exp(kappa*pout(n)) * (wz(i,j,km-2) - wz(i,j,km)) / & - ( exp(kappa*pe(i,km,j)) - exp(kappa*pe(i,km-2,j)) ) +! qout(i,j,n) = gcp*exp(kappa*pout(n)) * (wz(i,j,km-2) - wz(i,j,km)) / & +! ( exp(kappa*pe(i,km,j)) - exp(kappa*pe(i,km-2,j)) ) +!----------------------------------------------------------------------- +! ECMWF Method: Trenberth et al., 1993 + alpha = 0.0065*rdgas/grav + pbot = (exp(pe(i,km+1,j))-exp(pe(i,km,j)))/(pe(i,km+1,j)-pe(i,km,j)) + ts = (q2(i,km)+alpha*q2(i,km)*(exp(pe(i,km+1,j))/pbot-1)) + t0 = ts+0.0065*wz(i,j,km+1) + tmp = min(t0,298.0) + if (wz(i,j,km+1).ge.2000.0) then + if (wz(i,j,km+1).le.2500.0) then + tmp = 0.002*((2500-wz(i,j,km+1))*t0+(wz(i,j,km+1)-2000)*tmp) + endif + if (tmp-ts.lt.0) then + alpha = 0 + else + alpha = rdgas*(tmp-ts)/(wz(i,j,km+1)*grav) + endif + endif + qout(i,j,n) = ts*exp(alpha*(pout(n)-pe(i,km+1,j))) +!----------------------------------------------------------------------- else qout(i,j,n) = qe(i,km+1) endif @@ -5086,27 +5180,27 @@ subroutine ppme(p,qe,delp,im,km) km1 = km - 1 do k=2,km - do i=1,im - a6(i,k) = delp(i,k-1) + delp(i,k) - enddo + do i=1,im + a6(i,k) = delp(i,k-1) + delp(i,k) + enddo enddo do k=1,km1 - do i=1,im - delq(i,k) = p(i,k+1) - p(i,k) - enddo + do i=1,im + delq(i,k) = p(i,k+1) - p(i,k) + enddo enddo do k=2,km1 - do i=1,im - c1 = (delp(i,k-1)+0.5*delp(i,k))/a6(i,k+1) - c2 = (delp(i,k+1)+0.5*delp(i,k))/a6(i,k) - tmp = delp(i,k)*(c1*delq(i,k) + c2*delq(i,k-1)) / & + do i=1,im + c1 = (delp(i,k-1)+0.5*delp(i,k))/a6(i,k+1) + c2 = (delp(i,k+1)+0.5*delp(i,k))/a6(i,k) + tmp = delp(i,k)*(c1*delq(i,k) + c2*delq(i,k-1)) / & (a6(i,k)+delp(i,k+1)) - qmax = max(p(i,k-1),p(i,k),p(i,k+1)) - p(i,k) - qmin = p(i,k) - min(p(i,k-1),p(i,k),p(i,k+1)) - dc(i,k) = sign(min(abs(tmp),qmax,qmin), tmp) - enddo + qmax = max(p(i,k-1),p(i,k),p(i,k+1)) - p(i,k) + qmin = p(i,k) - min(p(i,k-1),p(i,k),p(i,k+1)) + dc(i,k) = sign(min(abs(tmp),qmax,qmin), tmp) + enddo enddo !****6***0*********0*********0*********0*********0*********0**********72 @@ -5450,210 +5544,78 @@ subroutine nh_total_energy(is, ie, js, je, isd, ied, jsd, jed, km, & end subroutine nh_total_energy + subroutine compute_brn(ua, va, delp, delz, cape, bd, npz, Time) - subroutine dbzcalc(q, pt, delp, peln, delz, & - dbz, maxdbz, allmax, bd, npz, ncnst, & - hydrostatic, zvir, in0r, in0s, in0g, iliqskin, do_inline_mp) + type(fv_grid_bounds_type), intent(IN) :: bd + integer, intent(IN) :: npz + type(time_type), intent(in) :: Time + real, dimension(bd%isd:bd%ied,bd%jsd:bd%jed, npz), intent(IN) :: ua, va, delp + real, dimension(bd%isc:bd%iec,bd%jsc:bd%jec, npz), intent(IN) :: delz + real, dimension(bd%isc:bd%iec,bd%jsc:bd%jec), intent(IN) :: cape + real, dimension(bd%isc:bd%iec,bd%jsc:bd%jec) :: brn, shear06 - !Code from Mark Stoelinga's dbzcalc.f from the RIP package. - !Currently just using values taken directly from that code, which is - ! consistent for the MM5 Reisner-2 microphysics. From that file: + real, dimension(bd%isc:bd%iec,bd%jsc:bd%jec) :: u06, u005, v06, v005, ht, m06, m005 + real :: tmp1, tmp2 + logical :: used -! This routine computes equivalent reflectivity factor (in dBZ) at -! each model grid point. In calculating Ze, the RIP algorithm makes -! assumptions consistent with those made in an early version -! (ca. 1996) of the bulk mixed-phase microphysical scheme in the MM5 -! model (i.e., the scheme known as "Resiner-2"). For each species: -! -! 1. Particles are assumed to be spheres of constant density. The -! densities of rain drops, snow particles, and graupel particles are -! taken to be rho_r = rho_l = 1000 kg m^-3, rho_s = 100 kg m^-3, and -! rho_g = 400 kg m^-3, respectively. (l refers to the density of -! liquid water.) -! -! 2. The size distribution (in terms of the actual diameter of the -! particles, rather than the melted diameter or the equivalent solid -! ice sphere diameter) is assumed to follow an exponential -! distribution of the form N(D) = N_0 * exp( lambda*D ). -! -! 3. If in0X=0, the intercept parameter is assumed constant (as in -! early Reisner-2), with values of 8x10^6, 2x10^7, and 4x10^6 m^-4, -! for rain, snow, and graupel, respectively. Various choices of -! in0X are available (or can be added). Currently, in0X=1 gives the -! variable intercept for each species that is consistent with -! Thompson, Rasmussen, and Manning (2004, Monthly Weather Review, -! Vol. 132, No. 2, pp. 519-542.) -! -! 4. If iliqskin=1, frozen particles that are at a temperature above -! freezing are assumed to scatter as a liquid particle. -! -! More information on the derivation of simulated reflectivity in RIP -! can be found in Stoelinga (2005, unpublished write-up). Contact -! Mark Stoelinga (stoeling@atmos.washington.edu) for a copy. - -! 22sep16: Modifying to use the GFDL MP parameters. If doing so remember -! that the GFDL MP assumes a constant intercept (in0X = .false.) -! Ferrier-Aligo has an option for fixed slope (rather than fixed intercept). -! Thompson presumably is an extension of Reisner MP. - - use gfdl_cloud_microphys_mod, only : do_hail, rhor, rhos, rhog, rhoh, rnzr, rnzs, rnzg, rnzh - use gfdl_mp_mod, only: do_hail_inline => do_hail ! assuming same densities and numbers in both inline and traditional GFDL MP - implicit none - - type(fv_grid_bounds_type), intent(IN) :: bd - integer, intent(IN) :: npz, ncnst - real, intent(IN), dimension(bd%isd:bd%ied, bd%jsd:bd%jed, npz) :: pt, delp - real, intent(IN), dimension(bd%is:, bd%js:, 1:) :: delz - real, intent(IN), dimension(bd%isd:bd%ied, bd%jsd:bd%jed, npz, ncnst) :: q - real, intent(IN), dimension(bd%is :bd%ie, npz+1, bd%js:bd%je) :: peln - real, intent(OUT), dimension(bd%is :bd%ie, bd%js :bd%je , npz) :: dbz - real, intent(OUT), dimension(bd%is :bd%ie, bd%js :bd%je) :: maxdbz - logical, intent(IN) :: hydrostatic, in0r, in0s, in0g, iliqskin, do_inline_mp - real, intent(IN) :: zvir - real, intent(OUT) :: allmax - - !Parameters for constant intercepts (in0[rsg] = .false.) - !Using GFDL MP values - real(kind=R_GRID), parameter:: vconr = 2503.23638966667 - real(kind=R_GRID), parameter:: vcong = 87.2382675 - real(kind=R_GRID), parameter:: vcons = 6.6280504 - real(kind=R_GRID), parameter:: vconh = vcong - real(kind=R_GRID), parameter:: normr = 25132741228.7183 - real(kind=R_GRID), parameter:: normg = 5026548245.74367 - real(kind=R_GRID), parameter:: normh = pi*rhoh*rnzh - real(kind=R_GRID), parameter:: norms = 942477796.076938 - - !Constants for variable intercepts - !Will need to be changed based on MP scheme - real, parameter :: r1=1.e-15 - real, parameter :: ron=8.e6 - real, parameter :: ron2=1.e10 - real, parameter :: son=2.e7 - real, parameter :: gon=5.e7 - real, parameter :: ron_min = 8.e6 - real, parameter :: ron_qr0 = 0.00010 - real, parameter :: ron_delqr0 = 0.25*ron_qr0 - real, parameter :: ron_const1r = (ron2-ron_min)*0.5 - real, parameter :: ron_const2r = (ron2+ron_min)*0.5 - - !Other constants - real, parameter :: gamma_seven = 720. - real, parameter :: alpha = 0.224 - real(kind=R_GRID), parameter :: factor_s = gamma_seven * 1.e18 * (1./(pi*rhos))**1.75 & - * (rhos/rhor)**2 * alpha - real, parameter :: qmin = 1.E-12 - real, parameter :: tice = 273.16 - -! Double precision - real(kind=R_GRID), dimension(bd%is:bd%ie) :: rhoair, denfac, z_e - real(kind=R_GRID):: qr1, qs1, qg1, t1, t2, t3, rwat, vtr, vtg, vts - real(kind=R_GRID):: factorb_s, factorb_g - real(kind=R_GRID):: temp_c, pres, sonv, gonv, ronv - - real :: rhogh, vcongh, normgh + integer :: i,j,k - integer :: i,j,k - integer :: is, ie, js, je - - is = bd%is - ie = bd%ie - js = bd%js - je = bd%je - if (rainwat < 1) return - - dbz(:,:,1:mp_top) = -20. - maxdbz(:,:) = -20. !Minimum value - allmax = -20. - - if ((do_hail .and. .not. do_inline_mp) .or. (do_hail_inline .and. do_inline_mp)) then - rhogh = rhoh - vcongh = vconh - normgh = normh - else - rhogh = rhog - vcongh = vcong - normgh = normg - endif - -!$OMP parallel do default(shared) private(rhoair,t1,t2,t3,denfac,vtr,vtg,vts,z_e) - do k=mp_top+1, npz - do j=js, je - if (hydrostatic) then - do i=is, ie - rhoair(i) = delp(i,j,k)/( (peln(i,k+1,j)-peln(i,k,j)) * rdgas * pt(i,j,k) * ( 1. + zvir*q(i,j,k,sphum) ) ) - denfac(i) = sqrt(min(10., 1.2/rhoair(i))) - z_e(i) = 0. - enddo - else - do i=is, ie - rhoair(i) = -delp(i,j,k)/(grav*delz(i,j,k)) ! moist air density - denfac(i) = sqrt(min(10., 1.2/rhoair(i))) - z_e(i) = 0. - enddo - endif - if (rainwat > 0) then - do i=is, ie -! The following form vectorizes better & more consistent with GFDL_MP -! SJL notes: Marshall-Palmer, dBZ = 200*precip**1.6, precip = 3.6e6*t1/rhor*vtr ! [mm/hr] -! GFDL_MP terminal fall speeds are used -! Date modified 20170701 -! Account for excessively high cloud water -> autoconvert (diag only) excess cloud water - t1 = rhoair(i)*max(qmin, q(i,j,k,rainwat)+dim(q(i,j,k,liq_wat), 1.0e-3)) - vtr = max(1.e-3, vconr*denfac(i)*exp(0.2 *log(t1/normr))) - z_e(i) = 200.*exp(1.6*log(3.6e6*t1/rhor*vtr)) - ! z_e = 200.*(exp(1.6*log(3.6e6*t1/rhor*vtr)) + exp(1.6*log(3.6e6*t3/rhogh*vtg)) + exp(1.6*log(3.6e6*t2/rhos*vts))) - enddo - endif - if (graupel > 0) then - do i=is, ie - t3 = rhoair(i)*max(qmin, q(i,j,k,graupel)) - vtg = max(1.e-3, vcongh*denfac(i)*exp(0.125 *log(t3/normgh))) - z_e(i) = z_e(i) + 200.*exp(1.6*log(3.6e6*t3/rhogh*vtg)) - enddo - endif - if (snowwat > 0) then - do i=is, ie - t2 = rhoair(i)*max(qmin, q(i,j,k,snowwat)) - ! vts = max(1.e-3, vcons*denfac*exp(0.0625*log(t2/norms))) - z_e(i) = z_e(i) + (factor_s/alpha)*t2*exp(0.75*log(t2/rnzs)) - ! z_e = 200.*(exp(1.6*log(3.6e6*t1/rhor*vtr)) + exp(1.6*log(3.6e6*t3/rhogh*vtg)) + exp(1.6*log(3.6e6*t2/rhos*vts))) - enddo - endif - do i=is,ie - dbz(i,j,k) = 10.*log10( max(0.01, z_e(i)) ) - enddo - enddo - enddo + integer :: isc, iec, jsc, jec + integer :: isd, ied, jsd, jed -!$OMP parallel do default(shared) - do j=js, je - do k=mp_top+1, npz - do i=is, ie - maxdbz(i,j) = max(dbz(i,j,k), maxdbz(i,j)) - enddo - enddo - enddo + isc = bd%is + iec = bd%ie + jsc = bd%js + jec = bd%je + isd = bd%isd + ied = bd%ied + jsd = bd%jsd + jed = bd%jed - do j=js, je - do i=is, ie - allmax = max(maxdbz(i,j), allmax) - enddo - enddo - end subroutine dbzcalc + !Bulk-Richardson number: CAPE / 0.5* (U_{0--6km} - U_{0--500m})**2 + do j=jsc,jec + do i=isc,iec + u06(i,j) = 0. + u005(i,j) = 0. + v06(i,j) = 0. + v005(i,j) = 0. + m06(i,j) = 0. + m005(i,j) = 0. + ht(i,j) = -delz(i,j,npz)*0.5 + enddo + enddo + do k=npz,2,-1 + do j=jsc,jec + do i=isc,iec + if (ht(i,j) <= 6000.) then + u06(i,j) = u06(i,j) + delp(i,j,k)*ua(i,j,k) + v06(i,j) = v06(i,j) + delp(i,j,k)*va(i,j,k) + m06(i,j) = m06(i,j) + delp(i,j,k) + endif + if (ht(i,j) <= 500.) then + u005(i,j) = u005(i,j) + delp(i,j,k)*ua(i,j,k) + v005(i,j) = v005(i,j) + delp(i,j,k)*va(i,j,k) + m005(i,j) = m005(i,j) + delp(i,j,k) + endif + ht(i,j) = ht(i,j) - 0.5*(delz(i,j,k) + delz(i,j,k-1)) + enddo + enddo + enddo + do j=jsc,jec + do i=isc,iec + tmp1 = u005(i,j)/m005(i,j) - u06(i,j)/m06(i,j) + tmp2 = v005(i,j)/m005(i,j) - v06(i,j)/m06(i,j) + shear06(i,j) = sqrt(tmp1*tmp1 + tmp2*tmp2) + brn(i,j) = cape(i,j)/(0.5*max(0.1,shear06(i,j)*shear06(i,j))) + enddo + enddo - subroutine max_vorticity_hy1(is, ie, js, je, km, vort, maxvorthy1) - integer, intent(in):: is, ie, js, je, km - real, intent(in), dimension(is:ie,js:je,km):: vort - real, intent(inout), dimension(is:ie,js:je):: maxvorthy1 - integer i, j, k + if (id_brn > 0) used=send_data(id_brn, brn, Time) + if (id_shear06 > 0) used=send_data(id_shear06, shear06, Time) - do j=js,je - do i=is,ie - maxvorthy1(i,j)=max(maxvorthy1(i,j),vort(i,j,km)) - enddo ! i-loop - enddo ! j-loop - end subroutine max_vorticity_hy1 + + end subroutine compute_brn subroutine max_vorticity(is, ie, js, je, ng, km, zvir, sphum, delz, q, hydrostatic, & pt, peln, phis, grav, vort, maxvort, z_bot, z_top) diff --git a/tools/fv_diagnostics.h b/tools/fv_diagnostics.h index ac73e99af..099d4c290 100644 --- a/tools/fv_diagnostics.h +++ b/tools/fv_diagnostics.h @@ -10,7 +10,7 @@ !* (at your option) any later version. !* !* The FV3 dynamical core is distributed in the hope that it will be -!* useful, but WITHOUT ANYWARRANTY; without even the implied warranty +!* useful, but WITHOUT ANY WARRANTY; without even the implied warranty !* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. !* See the GNU General Public License for more details. !* @@ -33,7 +33,7 @@ id_qn, id_qn200, id_qn500, id_qn850, id_qp, & id_qdt, id_acly, id_acl, id_acl2, & id_dbz, id_maxdbz, id_basedbz, id_dbz4km, id_dbztop, id_dbz_m10C, & - id_ctz, id_w1km, id_wmaxup, id_wmaxdn, id_cape, id_cin + id_ctz, id_w1km, id_wmaxup, id_wmaxdn, id_cape, id_cin, id_brn, id_shear06 ! Selected theta-level fields from 3D variables: integer :: id_pv350K, id_pv550K @@ -66,6 +66,10 @@ integer ic_ps, ic_ua, ic_va, ic_ppt integer ic_sphum integer, allocatable :: id_tracer(:) + +! dissipation estimates + integer :: id_diss + ! ESM requested diagnostics - dry mass/volume mixing ratios integer, allocatable :: id_tracer_dmmr(:) integer, allocatable :: id_tracer_dvmr(:) @@ -75,7 +79,7 @@ real, allocatable :: zsurf(:,:) real, allocatable :: pt1(:) - integer :: id_prer, id_prei, id_pres, id_preg, id_cond, id_dep, id_reevap, id_sub + integer :: id_prec, id_prer, id_prei, id_pres, id_preg, id_cond, id_dep, id_reevap, id_sub integer :: id_qv_dt_gfdlmp, id_T_dt_gfdlmp, id_ql_dt_gfdlmp, id_qi_dt_gfdlmp integer :: id_qr_dt_gfdlmp, id_qg_dt_gfdlmp, id_qs_dt_gfdlmp integer :: id_liq_wat_dt_gfdlmp, id_ice_wat_dt_gfdlmp @@ -92,7 +96,6 @@ id_iuu, id_iuv, id_iuw, id_ivv, id_ivw, id_iww ! vertically integral of momentum flux integer :: id_uw, id_vw - + integer :: id_lagrangian_tendency_of_hydrostatic_pressure integer :: id_t_dt_nudge, id_ps_dt_nudge, id_delp_dt_nudge, id_u_dt_nudge, id_v_dt_nudge - #endif _FV_DIAG__ diff --git a/tools/fv_eta.F90 b/tools/fv_eta.F90 index 426331273..3315846f1 100644 --- a/tools/fv_eta.F90 +++ b/tools/fv_eta.F90 @@ -10,7 +10,7 @@ !* (at your option) any later version. !* !* The FV3 dynamical core is distributed in the hope that it will be -!* useful, but WITHOUT ANYWARRANTY; without even the implied warranty +!* useful, but WITHOUT ANY WARRANTY; without even the implied warranty !* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. !* See the GNU General Public License for more details. !* @@ -18,6 +18,7 @@ !* License along with the FV3 dynamical core. !* If not, see . !*********************************************************************** + module fv_eta_mod use constants_mod, only: kappa, grav, cp_air, rdgas use fv_mp_mod, only: is_master @@ -40,7 +41,7 @@ subroutine set_eta(km, ks, ptop, ak, bk, npz_type) integer, intent(in):: km ! vertical dimension integer, intent(out):: ks ! number of pure p layers real:: a60(61),b60(61) -! Thfollowing L63 setting is the same as NCEP GFS's L64 except the top +! The following L63 setting is the same as NCEP GFS's L64 except the top ! 3 layers data a60/300.0000, 430.00000, 558.00000, & 700.00000, 863.05803, 1051.07995, & @@ -609,6 +610,15 @@ subroutine set_eta(km, ks, ptop, ak, bk, npz_type,fv_eta_file) enddo endif + + ! xi chen's l65 + case (65) + ks = 29 + do k=1,km+1 + ak(k) = a65(k) + bk(k) = b65(k) + enddo + !-->cjg case (68) ks = 27 @@ -621,11 +631,24 @@ subroutine set_eta(km, ks, ptop, ak, bk, npz_type,fv_eta_file) ptop = 1. stretch_fac = 1.03 auto_routine = 1 - case (75) ! HS-SGO test configuration - pint = 100.E2 - ptop = 10.E2 - stretch_fac = 1.035 - auto_routine = 6 + + ! kgao: introduce EMC's L75 config + case (75) + if (trim(npz_type) == 'emc') then + ! EMC's L75 config + ks = 12 + do k=1,km+1 + ak(k) = a75(k) + bk(k) = b75(k) + enddo + else + ! HS-SGO test configuration + pint = 100.E2 + ptop = 10.E2 + stretch_fac = 1.035 + auto_routine = 6 + endif + case (79) ! N = 10, M=5 if (trim(npz_type) == 'gcrm') then pint = 100.E2 @@ -664,6 +687,14 @@ subroutine set_eta(km, ks, ptop, ak, bk, npz_type,fv_eta_file) enddo !<--cjg + ! kgao L88 + case (88) + ks = 20 !19 bug fix + do k=1,km+1 + ak(k) = a88(k) + bk(k) = b88(k) + enddo + case (100) ks = 38 do k=1,km+1 @@ -693,6 +724,14 @@ subroutine set_eta(km, ks, ptop, ak, bk, npz_type,fv_eta_file) ptop = 1. stretch_fac = 1.03 auto_routine = 2 + elseif (trim(npz_type) == 'gfs') then + ks = 39 + ptop = a127(1) + pint = a127(ks+1) + do k=1,km+1 + ak(k) = a127(k) + bk(k) = b127(k) + enddo else ptop = 1. pint = 75.E2 diff --git a/tools/fv_eta.h b/tools/fv_eta.h index dbb73a235..66660fb96 100644 --- a/tools/fv_eta.h +++ b/tools/fv_eta.h @@ -10,7 +10,7 @@ !* (at your option) any later version. !* !* The FV3 dynamical core is distributed in the hope that it will be -!* useful, but WITHOUT ANYWARRANTY; without even the implied warranty +!* useful, but WITHOUT ANY WARRANTY; without even the implied warranty !* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. !* See the GNU General Public License for more details. !* @@ -18,6 +18,7 @@ !* License along with the FV3 dynamical core. !* If not, see . !*********************************************************************** + #ifndef _FV_ETA_ #define _FV_ETA__ @@ -42,11 +43,15 @@ real a63meso(64),b63meso(64) real a64(65),b64(65) real a64gfs(65),b64gfs(65) + real a65(66),b65(66) ! kgao: L65 with enhanced surface resolution by xi chen real a68(69),b68(69) ! cjg: grid with enhanced PBL resolution real a96(97),b96(97) ! cjg: grid with enhanced PBL resolution + real a88(89),b88(89) ! kgao: grid with enhanced PBL resolution + real a75(76),b75(76) ! kgao: emc grid with enhanced PBL resolution real a100(101),b100(101) real a104(105),b104(105) real a125(126),b125(126) + real a127(128),b127(128) !----------------------------------------------- ! GFDL AM2-L24: modified by SJL at the model top @@ -501,7 +506,7 @@ 1.0000000000e+00 / ! This is activated by USE_GFSL63 -! Thfollowing L63 setting is the same as NCEP GFS's L64 except the top +! The following L63 setting is the same as NCEP GFS's L64 except the top ! 3 layers data a63/64.247, 137.790, 221.958, & 318.266, 428.434, 554.424, & @@ -682,6 +687,51 @@ 0.87352, 0.91502, 0.95235, & 0.98511, 1.00000 / + data a65/1.00000000, 5.13470268, 14.04240036, & + 30.72783852, 53.79505539, 82.45489502, & + 117.05598450, 158.62843323, 208.79000854, & + 270.02725220, 345.50848389, 438.41940308, & + 551.85266113, 689.25054932, 854.40936279, & + 1051.47802734, 1284.95031738, 1559.65148926, & + 1880.71691895, 2253.56542969, 2683.86547852, & + 3177.49560547, 3740.49951172, 4379.03613281, & + 5099.32617188, 5907.59326172, 6810.00781250, & + 7812.62353516, 8921.31933594, 10141.73632812,& + 11285.93066406, 12188.79101562, 12884.30078125,& + 13400.11523438, 13758.84960938, 13979.10351562,& + 14076.26074219, 14063.13085938, 13950.45507812,& + 13747.31445312, 13461.45410156, 13099.54199219,& + 12667.38183594, 12170.08203125, 11612.18847656,& + 10997.79980469, 10330.65039062, 9611.05468750, & + 8843.30371094, 8045.85009766, 7236.31152344, & + 6424.55712891, 5606.50927734, 4778.05908203, & + 3944.97241211, 3146.77514648, 2416.63354492, & + 1778.22607422, 1246.21462402, 826.51950684, & + 511.21385254, 290.74072876, 150.00000000, & + 68.89300000, 14.99899865, 0.00000000 / + + data b65/0.00000000, 0.00000000, 0.00000000, & + 0.00000000, 0.00000000, 0.00000000, & + 0.00000000, 0.00000000, 0.00000000, & + 0.00000000, 0.00000000, 0.00000000, & + 0.00000000, 0.00000000, 0.00000000, & + 0.00000000, 0.00000000, 0.00000000, & + 0.00000000, 0.00000000, 0.00000000, & + 0.00000000, 0.00000000, 0.00000000, & + 0.00000000, 0.00000000, 0.00000000, & + 0.00000000, 0.00000000, 0.00000000, & + 0.00193294, 0.00749994, 0.01640714, & + 0.02841953, 0.04334756, 0.06103661, & + 0.08135860, 0.10420541, 0.12948355, & + 0.15711005, 0.18700911, 0.21910952, & + 0.25334257, 0.28964061, 0.32793567, & + 0.36815873, 0.41023913, 0.45429301, & + 0.50016892, 0.54688859, 0.59356427, & + 0.63976413, 0.68518244, 0.72950502, & + 0.77231618, 0.81251526, 0.84921405, & + 0.88174411, 0.90978803, 0.93327247, & + 0.95249488, 0.96783525, 0.97980107, & + 0.98896214, 0.99575002, 1.00000000 / !-->cjg data a68/1.00000, 2.68881, 5.15524, & 8.86683, 14.20349, 22.00278, & @@ -799,6 +849,129 @@ 0.97918, 0.98723, 0.99460, & 1.00000 / !<--cjg + +!---> kgao: remove top layers from l96 + data a88/65.28397, & + 95.48274, 137.90344, 196.76073, & + 277.45330, 386.81095, 533.37018, & + 727.67600, 982.60677, 1313.71685, & + 1739.59104, 2282.20281, 2967.26766, & + 3824.58158, 4888.33404, 6197.38450, & + 7795.49158, 9731.48414, 11969.71024, & + 14502.88894, 17304.52434, 20134.76139, & + 22536.63814, 24252.54459, 25230.65591, & + 25585.72044, 25539.91412, 25178.87141, & + 24644.84493, 23978.98781, 23245.49366, & + 22492.11600, 21709.93990, 20949.64473, & + 20225.94258, 19513.31158, 18829.32485, & + 18192.62250, 17589.39396, 17003.45386, & + 16439.01774, 15903.91204, 15396.39758, & + 14908.02140, 14430.65897, 13967.88643, & + 13524.16667, 13098.30227, 12687.56457, & + 12287.08757, 11894.41553, 11511.54106, & + 11139.22483, 10776.01912, 10419.75711, & + 10067.11881, 9716.63489, 9369.61967, & + 9026.69066, 8687.29884, 8350.04978, & + 8013.20925, 7677.12187, 7343.12994, & + 7011.62844, 6681.98102, 6353.09764, & + 6025.10535, 5699.10089, 5375.54503, & + 5053.63074, 4732.62740, 4413.38037, & + 4096.62775, 3781.79777, 3468.45371, & + 3157.19882, 2848.25306, 2541.19150, & + 2236.21942, 1933.50628, 1632.83741, & + 1334.35954, 1038.16655, 744.22318, & + 452.71094, 194.91899, 0.00000, & + 0.00000 / + + data b88/0.00000, & + 0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00000, & + 0.00000, 0.00000, 0.00193, & + 0.00974, 0.02538, 0.04876, & + 0.07817, 0.11081, 0.14514, & + 0.18007, 0.21486, 0.24866, & + 0.28088, 0.31158, 0.34030, & + 0.36701, 0.39210, 0.41554, & + 0.43733, 0.45774, 0.47707, & + 0.49540, 0.51275, 0.52922, & + 0.54495, 0.56007, 0.57459, & + 0.58850, 0.60186, 0.61471, & + 0.62715, 0.63922, 0.65095, & + 0.66235, 0.67348, 0.68438, & + 0.69510, 0.70570, 0.71616, & + 0.72651, 0.73675, 0.74691, & + 0.75700, 0.76704, 0.77701, & + 0.78690, 0.79672, 0.80649, & + 0.81620, 0.82585, 0.83542, & + 0.84492, 0.85437, 0.86375, & + 0.87305, 0.88229, 0.89146, & + 0.90056, 0.90958, 0.91854, & + 0.92742, 0.93623, 0.94497, & + 0.95364, 0.96223, 0.97074, & + 0.97918, 0.98723, 0.99460, & + 1.00000 / +!<--- kgao: end of a88/b88 + +!---> kgao: EMC L75 config + + data a75/200.0, 572.419, 1104.437, & + 1760.239, 2499.052, 3300.438, & + 4161.36, 5090.598, 6114.272, & + 7241.963, 8489.481, 9855.825, & + 11338.34, 12682.56, 13688.97, & + 14422.61, 14934.2, 15263.88, & + 15443.77, 15499.9, 15453.61, & + 15322.6, 15121.64, 14863.23, & + 14557.97, 14214.93, 13841.91, & + 13445.62, 13031.86, 12605.65, & + 12171.31, 11732.57, 11292.65, & + 10854.29, 10419.82, 9991.243, & + 9570.207, 9158.088, 8756.019, & + 8364.893, 7985.424, 7618.15, & + 7263.452, 6921.581, 6592.674, & + 6276.763, 5963.31, 5652.806, & + 5345.765, 5042.658, 4743.966, & + 4450.172, 4161.769, 3879.194, & + 3602.911, 3333.365, 3071.016, & + 2816.274, 2569.556, 2331.264, & + 2101.816, 1881.57, 1670.887, & + 1470.119, 1279.627, 1099.702, & + 930.651, 772.757, 626.305, & + 491.525, 368.641, 257.862, & + 159.399, 73.396, 0.001, & + 0.0/ + data b75/0.0, 0.0, 0.0, & + 0.0, 0.0, 0.0, & + 0.0, 0.0, 0.0, & + 0.0, 0.0, 0.0, & + 0.0, 0.00250213, 0.00944449,& + 0.02010732, 0.03390246, 0.0503391, & + 0.06899972, 0.08952269, 0.1115907, & + 0.134922, 0.1592647, 0.1843923, & + 0.2101002, 0.2362043, 0.2625384, & + 0.2889538, 0.3153166, 0.3415084, & + 0.3674242, 0.3929729, 0.4180741, & + 0.4426602, 0.4666739, 0.4900666, & + 0.5127994, 0.5348418, 0.5561699, & + 0.5767674, 0.5966232, 0.6157322, & + 0.6340936, 0.6517111, 0.668592, & + 0.6847468, 0.7007225, 0.7164985, & + 0.7320531, 0.7473667, 0.7624187, & + 0.7771889, 0.7916558, 0.8058007, & + 0.819604, 0.8330461, 0.8461072, & + 0.8587694, 0.8710147, 0.8828254, & + 0.8941834, 0.9050727, 0.9154776, & + 0.9253828, 0.9347721, 0.9436326, & + 0.9519511, 0.9597148, 0.966911, & + 0.9735298, 0.9795609, 0.9849954, & + 0.9898235, 0.9940391, 0.9976355, & + 1.0/ +! <--- kgao: end of a75/b75 + ! ! Ultra high troposphere resolution data a100/100.00000, 300.00000, 800.00000, & @@ -873,79 +1046,79 @@ 0.99223, 1.00000 / data a104/ & - 1.8827062944e-01, 7.7977549145e-01, 2.1950593583e+00, & - 4.9874566624e+00, 9.8041418997e+00, 1.7019717163e+01, & - 2.7216579591e+01, 4.0518628401e+01, 5.6749646818e+01, & - 7.5513868331e+01, 9.6315093333e+01, 1.1866706195e+02, & - 1.4216835396e+02, 1.6653733709e+02, 1.9161605772e+02, & - 2.1735580129e+02, 2.4379516604e+02, 2.7103771847e+02, & - 2.9923284173e+02, 3.2856100952e+02, 3.5922338766e+02, & - 3.9143507908e+02, 4.2542117983e+02, 4.6141487902e+02, & - 4.9965698106e+02, 5.4039638379e+02, 5.8389118154e+02, & - 6.3041016829e+02, 6.8023459505e+02, 7.3366009144e+02, & - 7.9099869949e+02, 8.5258099392e+02, 9.1875827946e+02, & - 9.8990486716e+02, 1.0664204381e+03, 1.1487325074e+03, & - 1.2372990044e+03, 1.3326109855e+03, 1.4351954993e+03, & - 1.5456186222e+03, 1.6644886848e+03, 1.7924597105e+03, & - 1.9302350870e+03, 2.0785714934e+03, 2.2382831070e+03, & - 2.4102461133e+03, 2.5954035462e+03, 2.7947704856e+03, & - 3.0094396408e+03, 3.2405873512e+03, 3.4894800360e+03, & - 3.7574811281e+03, 4.0460585279e+03, 4.3567926151e+03, & - 4.6913848588e+03, 5.0516670674e+03, 5.4396113207e+03, & - 5.8573406270e+03, 6.3071403487e+03, 6.7914704368e+03, & - 7.3129785102e+03, 7.8745138115e+03, 8.4791420557e+03, & - 9.1301611750e+03, 9.8311179338e+03, 1.0585825354e+04, & - 1.1398380836e+04, 1.2273184781e+04, 1.3214959424e+04, & - 1.4228767429e+04, 1.5320029596e+04, 1.6494540743e+04, & - 1.7758482452e+04, 1.9118430825e+04, 2.0422798801e+04, & - 2.1520147587e+04, 2.2416813461e+04, 2.3118184510e+04, & - 2.3628790785e+04, 2.3952411814e+04, 2.4092209011e+04, & - 2.4050892106e+04, 2.3830930156e+04, 2.3434818358e+04, & - 2.2865410898e+04, 2.2126326004e+04, 2.1222420323e+04, & - 2.0160313690e+04, 1.8948920926e+04, 1.7599915822e+04, & - 1.6128019809e+04, 1.4550987232e+04, 1.2889169132e+04, & - 1.1164595563e+04, 9.4227665517e+03, 7.7259097899e+03, & - 6.1538244381e+03, 4.7808126007e+03, 3.5967415552e+03, & - 2.5886394104e+03, 1.7415964865e+03, 1.0393721271e+03, & - 4.6478852032e+02, 7.0308342481e-13, 0.0000000000e+00 / + 1.8827062944e-01, 7.7977549145e-01, 2.1950593583e+00, & + 4.9874566624e+00, 9.8041418997e+00, 1.7019717163e+01, & + 2.7216579591e+01, 4.0518628401e+01, 5.6749646818e+01, & + 7.5513868331e+01, 9.6315093333e+01, 1.1866706195e+02, & + 1.4216835396e+02, 1.6653733709e+02, 1.9161605772e+02, & + 2.1735580129e+02, 2.4379516604e+02, 2.7103771847e+02, & + 2.9923284173e+02, 3.2856100952e+02, 3.5922338766e+02, & + 3.9143507908e+02, 4.2542117983e+02, 4.6141487902e+02, & + 4.9965698106e+02, 5.4039638379e+02, 5.8389118154e+02, & + 6.3041016829e+02, 6.8023459505e+02, 7.3366009144e+02, & + 7.9099869949e+02, 8.5258099392e+02, 9.1875827946e+02, & + 9.8990486716e+02, 1.0664204381e+03, 1.1487325074e+03, & + 1.2372990044e+03, 1.3326109855e+03, 1.4351954993e+03, & + 1.5456186222e+03, 1.6644886848e+03, 1.7924597105e+03, & + 1.9302350870e+03, 2.0785714934e+03, 2.2382831070e+03, & + 2.4102461133e+03, 2.5954035462e+03, 2.7947704856e+03, & + 3.0094396408e+03, 3.2405873512e+03, 3.4894800360e+03, & + 3.7574811281e+03, 4.0460585279e+03, 4.3567926151e+03, & + 4.6913848588e+03, 5.0516670674e+03, 5.4396113207e+03, & + 5.8573406270e+03, 6.3071403487e+03, 6.7914704368e+03, & + 7.3129785102e+03, 7.8745138115e+03, 8.4791420557e+03, & + 9.1301611750e+03, 9.8311179338e+03, 1.0585825354e+04, & + 1.1398380836e+04, 1.2273184781e+04, 1.3214959424e+04, & + 1.4228767429e+04, 1.5320029596e+04, 1.6494540743e+04, & + 1.7758482452e+04, 1.9118430825e+04, 2.0422798801e+04, & + 2.1520147587e+04, 2.2416813461e+04, 2.3118184510e+04, & + 2.3628790785e+04, 2.3952411814e+04, 2.4092209011e+04, & + 2.4050892106e+04, 2.3830930156e+04, 2.3434818358e+04, & + 2.2865410898e+04, 2.2126326004e+04, 2.1222420323e+04, & + 2.0160313690e+04, 1.8948920926e+04, 1.7599915822e+04, & + 1.6128019809e+04, 1.4550987232e+04, 1.2889169132e+04, & + 1.1164595563e+04, 9.4227665517e+03, 7.7259097899e+03, & + 6.1538244381e+03, 4.7808126007e+03, 3.5967415552e+03, & + 2.5886394104e+03, 1.7415964865e+03, 1.0393721271e+03, & + 4.6478852032e+02, 7.0308342481e-13, 0.0000000000e+00 / data b104/ & - 0.0000000000e+00, 0.0000000000e+00, 0.0000000000e+00, & - 0.0000000000e+00, 0.0000000000e+00, 0.0000000000e+00, & - 0.0000000000e+00, 0.0000000000e+00, 0.0000000000e+00, & - 0.0000000000e+00, 0.0000000000e+00, 0.0000000000e+00, & - 0.0000000000e+00, 0.0000000000e+00, 0.0000000000e+00, & - 0.0000000000e+00, 0.0000000000e+00, 0.0000000000e+00, & - 0.0000000000e+00, 0.0000000000e+00, 0.0000000000e+00, & - 0.0000000000e+00, 0.0000000000e+00, 0.0000000000e+00, & - 0.0000000000e+00, 0.0000000000e+00, 0.0000000000e+00, & - 0.0000000000e+00, 0.0000000000e+00, 0.0000000000e+00, & - 0.0000000000e+00, 0.0000000000e+00, 0.0000000000e+00, & - 0.0000000000e+00, 0.0000000000e+00, 0.0000000000e+00, & - 0.0000000000e+00, 0.0000000000e+00, 0.0000000000e+00, & - 0.0000000000e+00, 0.0000000000e+00, 0.0000000000e+00, & - 0.0000000000e+00, 0.0000000000e+00, 0.0000000000e+00, & - 0.0000000000e+00, 0.0000000000e+00, 0.0000000000e+00, & - 0.0000000000e+00, 0.0000000000e+00, 0.0000000000e+00, & - 0.0000000000e+00, 0.0000000000e+00, 0.0000000000e+00, & - 0.0000000000e+00, 0.0000000000e+00, 0.0000000000e+00, & - 0.0000000000e+00, 0.0000000000e+00, 0.0000000000e+00, & - 0.0000000000e+00, 0.0000000000e+00, 0.0000000000e+00, & - 0.0000000000e+00, 0.0000000000e+00, 0.0000000000e+00, & - 0.0000000000e+00, 0.0000000000e+00, 0.0000000000e+00, & - 0.0000000000e+00, 0.0000000000e+00, 0.0000000000e+00, & - 0.0000000000e+00, 0.0000000000e+00, 1.5648447298e-03, & - 6.2617046389e-03, 1.4104157933e-02, 2.5118187415e-02, & - 3.9340510972e-02, 5.6816335609e-02, 7.7596328431e-02, & - 1.0173255472e-01, 1.2927309709e-01, 1.6025505622e-01, & - 1.9469566981e-01, 2.3258141217e-01, 2.7385520518e-01, & - 3.1840233814e-01, 3.6603639170e-01, 4.1648734767e-01, & - 4.6939496013e-01, 5.2431098738e-01, 5.8071350676e-01, & - 6.3803478105e-01, 6.9495048840e-01, 7.4963750338e-01, & - 7.9975208897e-01, 8.4315257576e-01, 8.8034012292e-01, & - 9.1184389721e-01, 9.3821231526e-01, 9.6000677644e-01, & - 9.7779792223e-01, 9.9216315122e-01, 1.0000000000e+00 / + 0.0000000000e+00, 0.0000000000e+00, 0.0000000000e+00, & + 0.0000000000e+00, 0.0000000000e+00, 0.0000000000e+00, & + 0.0000000000e+00, 0.0000000000e+00, 0.0000000000e+00, & + 0.0000000000e+00, 0.0000000000e+00, 0.0000000000e+00, & + 0.0000000000e+00, 0.0000000000e+00, 0.0000000000e+00, & + 0.0000000000e+00, 0.0000000000e+00, 0.0000000000e+00, & + 0.0000000000e+00, 0.0000000000e+00, 0.0000000000e+00, & + 0.0000000000e+00, 0.0000000000e+00, 0.0000000000e+00, & + 0.0000000000e+00, 0.0000000000e+00, 0.0000000000e+00, & + 0.0000000000e+00, 0.0000000000e+00, 0.0000000000e+00, & + 0.0000000000e+00, 0.0000000000e+00, 0.0000000000e+00, & + 0.0000000000e+00, 0.0000000000e+00, 0.0000000000e+00, & + 0.0000000000e+00, 0.0000000000e+00, 0.0000000000e+00, & + 0.0000000000e+00, 0.0000000000e+00, 0.0000000000e+00, & + 0.0000000000e+00, 0.0000000000e+00, 0.0000000000e+00, & + 0.0000000000e+00, 0.0000000000e+00, 0.0000000000e+00, & + 0.0000000000e+00, 0.0000000000e+00, 0.0000000000e+00, & + 0.0000000000e+00, 0.0000000000e+00, 0.0000000000e+00, & + 0.0000000000e+00, 0.0000000000e+00, 0.0000000000e+00, & + 0.0000000000e+00, 0.0000000000e+00, 0.0000000000e+00, & + 0.0000000000e+00, 0.0000000000e+00, 0.0000000000e+00, & + 0.0000000000e+00, 0.0000000000e+00, 0.0000000000e+00, & + 0.0000000000e+00, 0.0000000000e+00, 0.0000000000e+00, & + 0.0000000000e+00, 0.0000000000e+00, 0.0000000000e+00, & + 0.0000000000e+00, 0.0000000000e+00, 1.5648447298e-03, & + 6.2617046389e-03, 1.4104157933e-02, 2.5118187415e-02, & + 3.9340510972e-02, 5.6816335609e-02, 7.7596328431e-02, & + 1.0173255472e-01, 1.2927309709e-01, 1.6025505622e-01, & + 1.9469566981e-01, 2.3258141217e-01, 2.7385520518e-01, & + 3.1840233814e-01, 3.6603639170e-01, 4.1648734767e-01, & + 4.6939496013e-01, 5.2431098738e-01, 5.8071350676e-01, & + 6.3803478105e-01, 6.9495048840e-01, 7.4963750338e-01, & + 7.9975208897e-01, 8.4315257576e-01, 8.8034012292e-01, & + 9.1184389721e-01, 9.3821231526e-01, 9.6000677644e-01, & + 9.7779792223e-01, 9.9216315122e-01, 1.0000000000e+00 / ! IFS-like L125(top 12 levels removed from IFSL137) data a125/ 64., & @@ -994,5 +1167,74 @@ 0.984542, 0.988500, 0.991984, 0.995003, 0.997630, 1.000000 / + data a127/ & + 0.99900, 1.60500, 2.53200, 3.92400, & + 5.97600, 8.94700, 13.17700, 19.09600, & + 27.24300, 38.27600, 52.98400, 72.29300, & + 97.26900, 129.11000, 169.13500, 218.76700, & + 279.50600, 352.89400, 440.48100, 543.78200, & + 664.23600, 803.16400, 961.73400, 1140.93100, & + 1341.53800, 1564.11900, 1809.02800, 2076.41500, & + 2366.25200, 2678.37200, 3012.51000, 3368.36300, & + 3745.64600, 4144.16400, 4563.88100, 5004.99500, & + 5468.01700, 5953.84800, 6463.86400, 7000.00000, & + 7563.49400, 8150.66100, 8756.52900, 9376.14100, & + 10004.55300, 10636.85100, 11268.15700, 11893.63900, & + 12508.51900, 13108.09100, 13687.72700, 14242.89000, & + 14769.15300, 15262.20200, 15717.85900, 16132.09000, & + 16501.01800, 16820.93800, 17088.32400, 17299.85200, & + 17453.08400, 17548.35000, 17586.77100, 17569.69700, & + 17498.69700, 17375.56100, 17202.29900, 16981.13700, & + 16714.50400, 16405.02000, 16055.48500, 15668.86000, & + 15248.24700, 14796.86800, 14318.04000, 13815.15000, & + 13291.62900, 12750.92400, 12196.46800, 11631.65900, & + 11059.82700, 10484.20800, 9907.92700, 9333.96700, & + 8765.15500, 8204.14200, 7653.38700, 7115.14700, & + 6591.46800, 6084.17600, 5594.87600, 5124.94900, & + 4675.55400, 4247.63300, 3841.91800, 3458.93300, & + 3099.01000, 2762.29700, 2448.76800, 2158.23800, & + 1890.37500, 1644.71200, 1420.66100, 1217.52800, & + 1034.52400, 870.77800, 725.34800, 597.23500, & + 485.39200, 388.73400, 306.14900, 236.50200, & + 178.65100, 131.44700, 93.74000, 64.39200, & + 42.27400, 26.27400, 15.30200, 8.28700, & + 4.19000, 1.99400, 0.81000, 0.23200, & + 0.02900, 0.00000, 0.00000, 0.00000 / + + + data b127/ & + 0.000000000, 0.000000000, 0.000000000, 0.000000000, & + 0.000000000, 0.000000000, 0.000000000, 0.000000000, & + 0.000000000, 0.000000000, 0.000000000, 0.000000000, & + 0.000000000, 0.000000000, 0.000000000, 0.000000000, & + 0.000000000, 0.000000000, 0.000000000, 0.000000000, & + 0.000000000, 0.000000000, 0.000000000, 0.000000000, & + 0.000000000, 0.000000000, 0.000000000, 0.000000000, & + 0.000000000, 0.000000000, 0.000000000, 0.000000000, & + 0.000000000, 0.000000000, 0.000000000, 0.000000000, & + 0.000000000, 0.000000000, 0.000000000, 0.000000000, & + 0.000010180, 0.000081410, 0.000274690, 0.000650780, & + 0.001270090, 0.002192480, 0.003477130, 0.005182280, & + 0.007365040, 0.010081200, 0.013384920, 0.017328570, & + 0.021962390, 0.027334280, 0.033489540, 0.040470560, & + 0.048316610, 0.057063580, 0.066743720, 0.077385480, & + 0.089006290, 0.101593970, 0.115126180, 0.129576220, & + 0.144912940, 0.161100800, 0.178099890, 0.195866050, & + 0.214351120, 0.233503070, 0.253266330, 0.273582160, & + 0.294388980, 0.315622900, 0.337218050, 0.359107230, & + 0.381222370, 0.403495070, 0.425857160, 0.448241260, & + 0.470581260, 0.492812960, 0.514874340, 0.536706210, & + 0.558252450, 0.579460500, 0.600281540, 0.620670740, & + 0.640587510, 0.659995680, 0.678863350, 0.697163110, & + 0.714872000, 0.731971260, 0.748446460, 0.764287110, & + 0.779486660, 0.794042170, 0.807954130, 0.821226300, & + 0.833865170, 0.845880090, 0.857282640, 0.868086640, & + 0.878307700, 0.887963240, 0.897071780, 0.905653240, & + 0.913728360, 0.921318710, 0.928446350, 0.935133760, & + 0.941403690, 0.947278860, 0.952782090, 0.957935990, & + 0.962762950, 0.967285100, 0.971524000, 0.975500880, & + 0.979236420, 0.982750770, 0.986062530, 0.989185090, & + 0.992129920, 0.994907680, 0.997528200, 1.000000000 / + #endif _FV_ETA_ diff --git a/tools/fv_grid_tools.F90 b/tools/fv_grid_tools.F90 index 0e8d5393b..bd20be904 100644 --- a/tools/fv_grid_tools.F90 +++ b/tools/fv_grid_tools.F90 @@ -10,7 +10,7 @@ !* (at your option) any later version. !* !* The FV3 dynamical core is distributed in the hope that it will be -!* useful, but WITHOUT ANYWARRANTY; without even the implied warranty +!* useful, but WITHOUT ANY WARRANTY; without even the implied warranty !* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. !* See the GNU General Public License for more details. !* @@ -18,9 +18,12 @@ !* License along with the FV3 dynamical core. !* If not, see . !*********************************************************************** + module fv_grid_tools_mod - use constants_mod, only: grav, omega, pi=>pi_8, cnst_radius=>radius, small_fac + use constants_mod, only: grav, pi=>pi_8 + use fv_arrays_mod, only: radius, omega ! scaled for small earth +! use test_cases_mod, only: small_earth_scale use fv_arrays_mod, only: fv_atmos_type, fv_grid_type, fv_grid_bounds_type, R_GRID use fv_grid_utils_mod, only: gnomonic_grids, great_circle_dist, & mid_pt_sphere, spherical_angle, & @@ -29,7 +32,7 @@ module fv_grid_tools_mod spherical_linear_interpolation, big_number use fv_timing_mod, only: timing_on, timing_off use fv_mp_mod, only: is_master, fill_corners, XDir, YDir - use fv_mp_mod, only: mp_bcst, mp_reduce_max, mp_stop, grids_master_procs + use fv_mp_mod, only: grids_master_procs use sorted_index_mod, only: sorted_inta, sorted_intb use mpp_mod, only: mpp_error, FATAL, get_unit, mpp_chksum, mpp_pe, stdout, & mpp_send, mpp_recv, mpp_sync_self, EVENT_RECV, mpp_npes, & @@ -59,8 +62,6 @@ module fv_grid_tools_mod private #include - real(kind=R_GRID), parameter:: radius = cnst_radius - real(kind=R_GRID) , parameter:: todeg = 180.0d0/pi ! convert to degrees real(kind=R_GRID) , parameter:: torad = pi/180.0d0 ! convert to radians real(kind=R_GRID) , parameter:: missing = 1.d25 @@ -604,7 +605,7 @@ subroutine init_grid(Atm, grid_name, grid_file, npx, npy, npz, ndims, nregions, call setup_aligned_nest(Atm) else - if( trim(grid_file) == 'INPUT/grid_spec.nc' .or. Atm%flagstruct%grid_type < 0 ) then + if( trim(grid_file) == 'INPUT/grid_spec.nc' .or. Atm%flagstruct%grid_type < 0 ) then call read_grid(Atm, grid_file, ndims, nregions, ng) ! Here if we are reading from grid_spec and the grid has a nest we need to assemble @@ -626,19 +627,6 @@ subroutine init_grid(Atm, grid_name, grid_file, npx, npy, npz, ndims, nregions, grid(isection_s:isection_e,jsection_s:jsection_e,1),grid_global(1-ng:npx+ng,1-ng:npy+ng,1,1),is_master(),ng,ng) call mpp_gather(isection_s,isection_e,jsection_s,jsection_e,atm%pelist, & grid(isection_s:isection_e,jsection_s:jsection_e,2),grid_global(1-ng:npx+ng,1-ng:npy+ng,2,1),is_master(),ng,ng) - !do we need the haloes?! - !do j=jsd,jed - !do i=isd,ied - !grid_global(i,j,1,1)=grid(i,j,1) - !grid_global(i,j,2,1)=grid(i,j,2) - !enddo - !enddo - !do j=1,npy - !do i=1,npx - !call mpp_max(grid_global(i,j,1,1),atm%pelist) - !call mpp_max(grid_global(i,j,2,1),atm%pelist) - !enddo - !enddo endif else @@ -939,38 +927,6 @@ subroutine init_grid(Atm, grid_name, grid_file, npx, npy, npz, ndims, nregions, enddo endif - if ( sw_corner ) then - i=1; j=1 - p1(1:2) = grid(i,j,1:2) - call mid_pt_sphere(grid(i,j,1:2), grid(i+1,j,1:2), p2) - p3(1:2) = agrid(i,j,1:2) - call mid_pt_sphere(grid(i,j,1:2), grid(i,j+1,1:2), p4) - area_c(i,j) = 3.*get_area(p1, p4, p2, p3, radius) - endif - if ( se_corner ) then - i=npx; j=1 - call mid_pt_sphere(grid(i-1,j,1:2), grid(i,j,1:2), p1) - p2(1:2) = grid(i,j,1:2) - call mid_pt_sphere(grid(i,j,1:2), grid(i,j+1,1:2), p3) - p4(1:2) = agrid(i,j,1:2) - area_c(i,j) = 3.*get_area(p1, p4, p2, p3, radius) - endif - if ( ne_corner ) then - i=npx; j=npy - p1(1:2) = agrid(i-1,j-1,1:2) - call mid_pt_sphere(grid(i,j-1,1:2), grid(i,j,1:2), p2) - p3(1:2) = grid(i,j,1:2) - call mid_pt_sphere(grid(i-1,j,1:2), grid(i,j,1:2), p4) - area_c(i,j) = 3.*get_area(p1, p4, p2, p3, radius) - endif - if ( nw_corner ) then - i=1; j=npy - call mid_pt_sphere(grid(i,j-1,1:2), grid(i,j,1:2), p1) - p2(1:2) = agrid(i,j-1,1:2) - call mid_pt_sphere(grid(i,j,1:2), grid(i+1,j,1:2), p3) - p4(1:2) = grid(i,j,1:2) - area_c(i,j) = 3.*get_area(p1, p4, p2, p3, radius) - endif endif !----------------- @@ -1113,7 +1069,7 @@ subroutine init_grid(Atm, grid_name, grid_file, npx, npy, npz, ndims, nregions, dxAV = dxAV / ( (ceiling(npy/2.0))*(ceiling(npx/2.0)) ) aspAV = aspAV / ( (ceiling(npy/2.0))*(ceiling(npx/2.0)) ) write(*,* ) '' - write(*,*) ' Radius is ', radius, ', omega is ', omega, ' small_fac = ', small_fac + write(*,*) ' Radius is ', radius, ', omega is ', omega!, ' small_earth_scale = ', small_earth_scale write(*,* ) ' Cubed-Sphere Grid Stats : ', npx,'x',npy,'x',nregions print*, dxN, dxM, dxAV, dxN, dxM write(*,'(A,f11.2,A,f11.2,A,f11.2,A,f11.2)') ' Grid Length : min: ', dxN,' max: ', dxM,' avg: ', dxAV, ' min/max: ',dxN/dxM @@ -2449,8 +2405,13 @@ subroutine grid_area(nx, ny, ndims, nregions, bounded_domain, gridstruct, domain minarea = mpp_global_min(domain, area) if (is_master()) write(*,209) 'MAX AREA (m*m):', maxarea, ' MIN AREA (m*m):', minarea - if (is_master()) write(*,209) 'GLOBAL AREA (m*m):', globalarea, ' IDEAL GLOBAL AREA (m*m):', 4.0*pi*radius**2 + if (bounded_domain) then + if (is_master()) write(*,210) 'REGIONAL AREA (m*m):', globalarea + else + if (is_master()) write(*,209) 'GLOBAL AREA (m*m):', globalarea, ' IDEAL GLOBAL AREA (m*m):', 4.0*pi*radius**2 + endif 209 format(A,e21.14,A,e21.14) + 210 format(A,e21.14) if (bounded_domain) then nh = ng-1 !cannot get rarea_c on boundary directly diff --git a/tools/fv_iau_mod.F90 b/tools/fv_iau_mod.F90 new file mode 100644 index 000000000..fd8125716 --- /dev/null +++ b/tools/fv_iau_mod.F90 @@ -0,0 +1,528 @@ +!*********************************************************************** +!* GNU Lesser General Public License +!* +!* This file is part of the FV3 dynamical core. +!* +!* The FV3 dynamical core is free software: you can redistribute it +!* and/or modify it under the terms of the +!* GNU Lesser General Public License as published by the +!* Free Software Foundation, either version 3 of the License, or +!* (at your option) any later version. +!* +!* The FV3 dynamical core is distributed in the hope that it will be +!* useful, but WITHOUT ANY WARRANTY; without even the implied warranty +!* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. +!* See the GNU General Public License for more details. +!* +!* You should have received a copy of the GNU Lesser General Public +!* License along with the FV3 dynamical core. +!* If not, see . +!*********************************************************************** + +!------------------------------------------------------------------------------- +!> @brief incremental analysis update module +!> @author Xi.Chen - author of fv_treat_da_inc.F90 +!> @author Philip Pegion +!> @date 09/13/2017 +! +!> REVISION HISTORY: +!> 09/13/2017 - Initial Version based on fv_treat_da_inc.F90 +!------------------------------------------------------------------------------- + +#ifdef OVERLOAD_R4 +#define _GET_VAR1 get_var1_real +#else +#define _GET_VAR1 get_var1_double +#endif + +module fv_iau_mod + + use fms_mod, only: file_exist + use mpp_mod, only: mpp_error, FATAL, NOTE, mpp_pe + use mpp_domains_mod, only: domain2d + + use constants_mod, only: pi=>pi_8 + use fv_arrays_mod, only: fv_atmos_type, & + fv_grid_type, & + fv_grid_bounds_type, & + R_GRID + use fv_mp_mod, only: is_master + use sim_nc_mod, only: open_ncfile, & + close_ncfile, & + get_ncdim1, & + get_var1_double, & + get_var3_r4, & + get_var1_real, check_var_exists +#ifdef GFS_PHYS + use IPD_typedefs, only: IPD_init_type, IPD_control_type, & + kind_phys +#endif + use block_control_mod, only: block_control_type + use fv_treat_da_inc_mod, only: remap_coef + use tracer_manager_mod, only: get_tracer_names,get_tracer_index, get_number_tracers + use field_manager_mod, only: MODEL_ATMOS + implicit none + + private + +#ifndef GFS_PHYS + integer, parameter :: kind_phys = 8 +#endif + + real,allocatable::s2c(:,:,:) +! real:: s2c(Atm(1)%bd%is:Atm(1)%bd%ie,Atm(1)%bd%js:Atm(1)%bd%je,4) +! integer, dimension(Atm(1)%bd%is:Atm(1)%bd%ie,Atm(1)%bd%js:Atm(1)%bd%je):: & +! id1, id2, jdc + integer,allocatable,dimension(:,:) :: id1,id2,jdc + + real :: deg2rad,dt,rdt + integer :: im,jm,km,nfiles,ncid + integer :: is, ie, js, je + integer :: npz,ntracers + character(len=32), allocatable :: tracer_names(:) + integer, allocatable :: tracer_indicies(:) + + real(kind=4), allocatable:: wk3(:,:,:) + type iau_internal_data_type + real,allocatable :: ua_inc(:,:,:) + real,allocatable :: va_inc(:,:,:) + real,allocatable :: temp_inc(:,:,:) + real,allocatable :: delp_inc(:,:,:) + real,allocatable :: delz_inc(:,:,:) + real,allocatable :: tracer_inc(:,:,:,:) + end type iau_internal_data_type + type iau_external_data_type + real,allocatable :: ua_inc(:,:,:) + real,allocatable :: va_inc(:,:,:) + real,allocatable :: temp_inc(:,:,:) + real,allocatable :: delp_inc(:,:,:) + real,allocatable :: delz_inc(:,:,:) + real,allocatable :: tracer_inc(:,:,:,:) + logical :: in_interval = .false. + logical :: drymassfixer = .false. + end type iau_external_data_type + type iau_state_type + type(iau_internal_data_type):: inc1 + type(iau_internal_data_type):: inc2 + real(kind=kind_phys) :: hr1 + real(kind=kind_phys) :: hr2 + real(kind=kind_phys) :: wt + real(kind=kind_phys) :: wt_normfact + end type iau_state_type + type(iau_state_type) :: IAU_state + + public iau_external_data_type + +#ifdef GFS_PHYS + public IAU_initialize, getiauforcing + +contains +subroutine IAU_initialize (IPD_Control, IAU_Data,Init_parm) + type (IPD_control_type), intent(in) :: IPD_Control + type (IAU_external_data_type), intent(inout) :: IAU_Data + type (IPD_init_type), intent(in) :: Init_parm + ! local + + character(len=128) :: fname + real, dimension(:,:,:), allocatable:: u_inc, v_inc + real, allocatable:: lat(:), lon(:),agrid(:,:,:) + real(kind=kind_phys) sx,wx,wt,normfact,dtp + + integer:: i, j, k, nstep, kstep + integer:: i1, i2, j1 + integer:: jbeg, jend + + logical:: found + integer nfilesall + integer, allocatable :: idt(:) + + is = IPD_Control%isc + ie = is + IPD_Control%nx-1 + js = IPD_Control%jsc + je = js + IPD_Control%ny-1 + call get_number_tracers(MODEL_ATMOS, num_tracers=ntracers) + allocate (tracer_names(ntracers)) + allocate (tracer_indicies(ntracers)) + do i = 1, ntracers + call get_tracer_names(MODEL_ATMOS, i, tracer_names(i)) + tracer_indicies(i) = get_tracer_index(MODEL_ATMOS,tracer_names(i)) + enddo + allocate(s2c(is:ie,js:je,4)) + allocate(id1(is:ie,js:je)) + allocate(id2(is:ie,js:je)) + allocate(jdc(is:ie,js:je)) + allocate(agrid(is:ie,js:je,2)) +! determine number of increment files to read, and the valid forecast hours + + nfilesall = size(IPD_Control%iau_inc_files) + nfiles = 0 + if (is_master()) print*,'in iau_init',trim(IPD_Control%iau_inc_files(1)),IPD_Control%iaufhrs(1) + do k=1,nfilesall + if (trim(IPD_Control%iau_inc_files(k)) .eq. '' .or. IPD_Control%iaufhrs(k) .lt. 0) exit + if (is_master()) then + print *,k,trim(adjustl(IPD_Control%iau_inc_files(k))) + endif + nfiles = nfiles + 1 + enddo + if (is_master()) print *,'nfiles = ',nfiles + if (nfiles < 1) then + return + endif + if (nfiles > 1) then + allocate(idt(nfiles-1)) + idt = IPD_Control%iaufhrs(2:nfiles)-IPD_Control%iaufhrs(1:nfiles-1) + do k=1,nfiles-1 + if (idt(k) .ne. IPD_Control%iaufhrs(2)-IPD_Control%iaufhrs(1)) then + print *,'forecast intervals in iaufhrs must be constant' + call mpp_error (FATAL,' forecast intervals in iaufhrs must be constant') + endif + enddo + deallocate(idt) + endif + if (is_master()) print *,'iau interval = ',IPD_Control%iau_delthrs,' hours' + dt = (IPD_Control%iau_delthrs*3600.) + rdt = 1.0/dt + +! set up interpolation weights to go from GSI's gaussian grid to cubed sphere + deg2rad = pi/180. + + npz = IPD_Control%levs + fname = 'INPUT/'//trim(IPD_Control%iau_inc_files(1)) + + if( file_exist(fname) ) then + call open_ncfile( fname, ncid ) ! open the file + call get_ncdim1( ncid, 'lon', im) + call get_ncdim1( ncid, 'lat', jm) + call get_ncdim1( ncid, 'lev', km) + + if (km.ne.npz) then + if (is_master()) print *, 'km = ', km + call mpp_error(FATAL, & + '==> Error in IAU_initialize: km is not equal to npz') + endif + + if(is_master()) write(*,*) fname, ' DA increment dimensions:', im,jm,km + + allocate ( lon(im) ) + allocate ( lat(jm) ) + + call _GET_VAR1 (ncid, 'lon', im, lon ) + call _GET_VAR1 (ncid, 'lat', jm, lat ) + call close_ncfile(ncid) + + ! Convert to radians + do i=1,im + lon(i) = lon(i) * deg2rad + enddo + do j=1,jm + lat(j) = lat(j) * deg2rad + enddo + + else + call mpp_error(FATAL,'==> Error in IAU_initialize: Expected file '& + //trim(fname)//' for DA increment does not exist') + endif + + ! Initialize lat-lon to Cubed bi-linear interpolation coeff: + ! populate agrid +! print*,'is,ie,js,je=',is,ie,js,ie +! print*,'size xlon=',size(Init_parm%xlon(:,1)),size(Init_parm%xlon(1,:)) +! print*,'size agrid=',size(agrid(:,1,1)),size(agrid(1,:,1)),size(agrid(1,1,:)) + do j = 1,size(Init_parm%xlon,2) + do i = 1,size(Init_parm%xlon,1) +! print*,i,j,is-1+j,js-1+j + agrid(is-1+i,js-1+j,1)=Init_parm%xlon(i,j) + agrid(is-1+i,js-1+j,2)=Init_parm%xlat(i,j) + enddo + enddo + call remap_coef( is, ie, js, je, is, ie, js, je, & + im, jm, lon, lat, id1, id2, jdc, s2c, & + agrid) + deallocate ( lon, lat,agrid ) + + allocate(IAU_Data%ua_inc(is:ie, js:je, km)) + allocate(IAU_Data%va_inc(is:ie, js:je, km)) + allocate(IAU_Data%temp_inc(is:ie, js:je, km)) + allocate(IAU_Data%delp_inc(is:ie, js:je, km)) + allocate(IAU_Data%delz_inc(is:ie, js:je, km)) + allocate(IAU_Data%tracer_inc(is:ie, js:je, km,ntracers)) +! allocate arrays that will hold iau state + allocate (iau_state%inc1%ua_inc(is:ie, js:je, km)) + allocate (iau_state%inc1%va_inc(is:ie, js:je, km)) + allocate (iau_state%inc1%temp_inc (is:ie, js:je, km)) + allocate (iau_state%inc1%delp_inc (is:ie, js:je, km)) + allocate (iau_state%inc1%delz_inc (is:ie, js:je, km)) + allocate (iau_state%inc1%tracer_inc(is:ie, js:je, km,ntracers)) + + iau_state%hr1=IPD_Control%iaufhrs(1) + iau_state%wt = 1.0 ! IAU increment filter weights (default 1.0) + iau_state%wt_normfact = 1.0 + if (IPD_Control%iau_filter_increments) then + ! compute increment filter weights, sum to obtain normalization factor + dtp=IPD_control%dtp + nstep = 0.5*IPD_Control%iau_delthrs*3600/dtp + ! compute normalization factor for filter weights + normfact = 0. + do k=1,2*nstep+1 + kstep = k-1-nstep + sx = acos(-1.)*kstep/nstep + wx = acos(-1.)*kstep/(nstep+1) + if (kstep .ne. 0) then + wt = sin(wx)/wx*sin(sx)/sx + else + wt = 1.0 + endif + normfact = normfact + wt + if (is_master()) print *,'filter wts',k,kstep,wt + enddo + iau_state%wt_normfact = (2*nstep+1)/normfact + endif + call read_iau_forcing(IPD_Control,iau_state%inc1,'INPUT/'//trim(IPD_Control%iau_inc_files(1))) + if (nfiles.EQ.1) then ! only need to get incrments once since constant forcing over window + call setiauforcing(IPD_Control,IAU_Data,iau_state%wt) + endif + + if (nfiles.GT.1) then !have multiple files, but only read in 2 at a time and interpoalte between them + allocate (iau_state%inc2%ua_inc(is:ie, js:je, km)) + allocate (iau_state%inc2%va_inc(is:ie, js:je, km)) + allocate (iau_state%inc2%temp_inc (is:ie, js:je, km)) + allocate (iau_state%inc2%delp_inc (is:ie, js:je, km)) + allocate (iau_state%inc2%delz_inc (is:ie, js:je, km)) + allocate (iau_state%inc2%tracer_inc(is:ie, js:je, km,ntracers)) + iau_state%hr2=IPD_Control%iaufhrs(2) + call read_iau_forcing(IPD_Control,iau_state%inc2,'INPUT/'//trim(IPD_Control%iau_inc_files(2))) + endif +! print*,'in IAU init',dt,rdt + IAU_data%drymassfixer = IPD_control%iau_drymassfixer + +end subroutine IAU_initialize + +subroutine getiauforcing(IPD_Control,IAU_Data) + + implicit none + type (IPD_control_type), intent(in) :: IPD_Control + type(IAU_external_data_type), intent(inout) :: IAU_Data + real(kind=kind_phys) t1,t2,sx,wx,wt,dtp + integer n,i,j,k,sphum,kstep,nstep,itnext + + IAU_Data%in_interval=.false. + if (nfiles.LE.0) then + return + endif + + if (nfiles .eq. 1) then + t1 = IPD_Control%iaufhrs(1)-0.5*IPD_Control%iau_delthrs + t2 = IPD_Control%iaufhrs(1)+0.5*IPD_Control%iau_delthrs + else + t1 = IPD_Control%iaufhrs(1) + t2 = IPD_Control%iaufhrs(nfiles) + endif + if (IPD_Control%iau_filter_increments) then + ! compute increment filter weight + ! t1 is beginning of window, t2 end of window + ! IPD_Control%fhour current time + ! in window kstep=-nstep,nstep (2*nstep+1 total) + ! time step IPD_control%dtp + dtp=IPD_control%dtp + nstep = 0.5*IPD_Control%iau_delthrs*3600/dtp + ! compute normalized filter weight + kstep = ((IPD_Control%fhour-t1) - 0.5*IPD_Control%iau_delthrs)*3600./dtp + if (IPD_Control%fhour >= t1 .and. IPD_Control%fhour < t2) then + sx = acos(-1.)*kstep/nstep + wx = acos(-1.)*kstep/(nstep+1) + if (kstep .ne. 0) then + wt = (sin(wx)/wx*sin(sx)/sx) + else + wt = 1. + endif + iau_state%wt = iau_state%wt_normfact*wt + !if (is_master()) print *,'kstep,t1,t,t2,filter wt=',kstep,t1,IPD_Control%fhour,t2,iau_state%wt/iau_state%wt_normfact + else + iau_state%wt = 0. + endif + endif + + if (nfiles.EQ.1) then +! on check to see if we are in the IAU window, no need to update the +! tendencies since they are fixed over the window + if ( IPD_Control%fhour < t1 .or. IPD_Control%fhour >= t2 ) then +! if (is_master()) print *,'no iau forcing',t1,IPD_Control%fhour,t2 + IAU_Data%in_interval=.false. + else + if (IPD_Control%iau_filter_increments) call setiauforcing(IPD_Control,IAU_Data,iau_state%wt) + if (is_master()) print *,'apply iau forcing t1,t,t2,filter wt=',t1,IPD_Control%fhour,t2,iau_state%wt/iau_state%wt_normfact + IAU_Data%in_interval=.true. + endif + return + endif + + if (nfiles > 1) then + itnext=2 + if (IPD_Control%fhour < t1 .or. IPD_Control%fhour >= t2) then +! if (is_master()) print *,'no iau forcing',IPD_Control%iaufhrs(1),IPD_Control%fhour,IPD_Control%iaufhrs(nfiles) + IAU_Data%in_interval=.false. + else + if (is_master()) print *,'apply iau forcing t1,t,t2,filter wt=',t1,IPD_Control%fhour,t2,iau_state%wt/iau_state%wt_normfact + IAU_Data%in_interval=.true. + do k=nfiles,1,-1 + if (IPD_Control%iaufhrs(k) > IPD_Control%fhour) then + itnext=k + endif + enddo +! if (is_master()) print *,'itnext=',itnext + if (IPD_Control%fhour >= iau_state%hr2) then ! need to read in next increment file + iau_state%hr1=iau_state%hr2 + iau_state%hr2=IPD_Control%iaufhrs(itnext) + iau_state%inc1=iau_state%inc2 + if (is_master()) print *,'reading next increment file',trim(IPD_Control%iau_inc_files(itnext)) + call read_iau_forcing(IPD_Control,iau_state%inc2,'INPUT/'//trim(IPD_Control%iau_inc_files(itnext))) + endif + call updateiauforcing(IPD_Control,IAU_Data,iau_state%wt) + endif + endif + sphum=get_tracer_index(MODEL_ATMOS,'sphum') + end subroutine getiauforcing + +subroutine updateiauforcing(IPD_Control,IAU_Data,wt) + + implicit none + type (IPD_control_type), intent(in) :: IPD_Control + type(IAU_external_data_type), intent(inout) :: IAU_Data + real(kind_phys) delt,wt + integer i,j,k,l + +! if (is_master()) print *,'in updateiauforcing',nfiles,IPD_Control%iaufhrs(1:nfiles) + delt = (iau_state%hr2-(IPD_Control%fhour))/(IAU_state%hr2-IAU_state%hr1) + do j = js,je + do i = is,ie + do k = 1,npz + IAU_Data%ua_inc(i,j,k) =(delt*IAU_state%inc1%ua_inc(i,j,k) + (1.-delt)* IAU_state%inc2%ua_inc(i,j,k))*rdt*wt + IAU_Data%va_inc(i,j,k) =(delt*IAU_state%inc1%va_inc(i,j,k) + (1.-delt)* IAU_state%inc2%va_inc(i,j,k))*rdt*wt + IAU_Data%temp_inc(i,j,k) =(delt*IAU_state%inc1%temp_inc(i,j,k) + (1.-delt)* IAU_state%inc2%temp_inc(i,j,k))*rdt*wt + IAU_Data%delp_inc(i,j,k) =(delt*IAU_state%inc1%delp_inc(i,j,k) + (1.-delt)* IAU_state%inc2%delp_inc(i,j,k))*rdt*wt + IAU_Data%delz_inc(i,j,k) =(delt*IAU_state%inc1%delz_inc(i,j,k) + (1.-delt)* IAU_state%inc2%delz_inc(i,j,k))*rdt*wt + do l=1,ntracers + IAU_Data%tracer_inc(i,j,k,l) =(delt*IAU_state%inc1%tracer_inc(i,j,k,l) + (1.-delt)* IAU_state%inc2%tracer_inc(i,j,k,l))*rdt*wt + enddo + enddo + enddo + enddo + end subroutine updateiauforcing + + + subroutine setiauforcing(IPD_Control,IAU_Data,wt) + + implicit none + type (IPD_control_type), intent(in) :: IPD_Control + type(IAU_external_data_type), intent(inout) :: IAU_Data + real(kind_phys) delt, dt,wt + integer i,j,k,l,sphum +! this is only called if using 1 increment file + if (is_master()) print *,'in setiauforcing',rdt + do j = js,je + do i = is,ie + do k = 1,npz + IAU_Data%ua_inc(i,j,k) =wt*IAU_state%inc1%ua_inc(i,j,k)*rdt + IAU_Data%va_inc(i,j,k) =wt*IAU_state%inc1%va_inc(i,j,k)*rdt + IAU_Data%temp_inc(i,j,k) =wt*IAU_state%inc1%temp_inc(i,j,k)*rdt + IAU_Data%delp_inc(i,j,k) =wt*IAU_state%inc1%delp_inc(i,j,k)*rdt + IAU_Data%delz_inc(i,j,k) =wt*IAU_state%inc1%delz_inc(i,j,k)*rdt + do l = 1,ntracers + IAU_Data%tracer_inc(i,j,k,l) =wt*IAU_state%inc1%tracer_inc(i,j,k,l)*rdt + enddo + enddo + enddo + enddo + sphum=get_tracer_index(MODEL_ATMOS,'sphum') + end subroutine setiauforcing + +subroutine read_iau_forcing(IPD_Control,increments,fname) + type (IPD_control_type), intent(in) :: IPD_Control + type(iau_internal_data_type), intent(inout):: increments + character(len=*), intent(in) :: fname +!locals + real, dimension(:,:,:), allocatable:: u_inc, v_inc + + integer:: i, j, k, l, npz + integer:: i1, i2, j1 + integer:: jbeg, jend + real(kind=R_GRID), dimension(2):: p1, p2, p3 + real(kind=R_GRID), dimension(3):: e1, e2, ex, ey + + logical:: found + integer :: is, ie, js, je + + is = IPD_Control%isc + ie = is + IPD_Control%nx-1 + js = IPD_Control%jsc + je = js + IPD_Control%ny-1 + + deg2rad = pi/180. + + npz = IPD_Control%levs + + if( file_exist(fname) ) then + call open_ncfile( fname, ncid ) ! open the file + else + call mpp_error(FATAL,'==> Error in read_iau_forcing: Expected file '& + //trim(fname)//' for DA increment does not exist') + endif + + ! Find bounding latitudes: + jbeg = jm-1; jend = 2 + do j=js,je + do i=is,ie + j1 = jdc(i,j) + jbeg = min(jbeg, j1) + jend = max(jend, j1+1) + enddo + enddo + + allocate ( wk3(1:im,jbeg:jend, 1:km) ) + ! read in 1 time level + call interp_inc('T_inc',increments%temp_inc(:,:,:),jbeg,jend) + call interp_inc('delp_inc',increments%delp_inc(:,:,:),jbeg,jend) + call interp_inc('delz_inc',increments%delz_inc(:,:,:),jbeg,jend) + call interp_inc('u_inc',increments%ua_inc(:,:,:),jbeg,jend) ! can these be treated as scalars? + call interp_inc('v_inc',increments%va_inc(:,:,:),jbeg,jend) + do l=1,ntracers + call interp_inc(trim(tracer_names(l))//'_inc',increments%tracer_inc(:,:,:,l),jbeg,jend) + enddo + call close_ncfile(ncid) + deallocate (wk3) + + +end subroutine read_iau_forcing + +subroutine interp_inc(field_name,var,jbeg,jend) +! interpolate increment from GSI gaussian grid to cubed sphere +! everying is on the A-grid, earth relative + character(len=*), intent(in) :: field_name + real, dimension(is:ie,js:je,1:km), intent(inout) :: var + integer, intent(in) :: jbeg,jend + integer:: i1, i2, j1, k,j,i,ierr + call check_var_exists(ncid, field_name, ierr) + if (ierr == 0) then + call get_var3_r4( ncid, field_name, 1,im, jbeg,jend, 1,km, wk3 ) + else + if (is_master()) print *,'warning: no increment for ',trim(field_name),' found, assuming zero' + wk3 = 0. + endif + do k=1,km + do j=js,je + do i=is,ie + i1 = id1(i,j) + i2 = id2(i,j) + j1 = jdc(i,j) + var(i,j,k) = s2c(i,j,1)*wk3(i1,j1 ,k) + s2c(i,j,2)*wk3(i2,j1 ,k)+& + s2c(i,j,3)*wk3(i2,j1+1,k) + s2c(i,j,4)*wk3(i1,j1+1,k) + enddo + enddo + enddo +end subroutine interp_inc + +#endif + +end module fv_iau_mod + + diff --git a/tools/fv_io.F90 b/tools/fv_io.F90 index 6770b6e9e..fd4eb58dc 100644 --- a/tools/fv_io.F90 +++ b/tools/fv_io.F90 @@ -10,7 +10,7 @@ !* (at your option) any later version. !* !* The FV3 dynamical core is distributed in the hope that it will be -!* useful, but WITHOUT ANYWARRANTY; without even the implied warranty +!* useful, but WITHOUT ANY WARRANTY; without even the implied warranty !* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. !* See the GNU General Public License for more details. !* @@ -18,6 +18,7 @@ !* License along with the FV3 dynamical core. !* If not, see . !*********************************************************************** + !!!NOTE: Merging in the seasonal forecast initialization code !!!! has proven problematic in the past, since many conflicts !!!! occur. Leaving this for now --- lmh 10aug15 @@ -125,7 +126,9 @@ subroutine fv_io_register_axis(file_obj, numx, xpos, numy, ypos, numz, zsize) call register_axis(file_obj, axisname, 'X', domain_position=xpos(i)) if (.not. file_obj%is_readonly) then !if writing file call register_field(file_obj, axisname, "double", (/axisname/)) - call register_variable_attribute(file_obj,axisname, "axis", "X", str_len=1) + call register_variable_attribute(file_obj,axisname, "long_name", axisname, str_len=len(axisname)) + call register_variable_attribute(file_obj,axisname, "units", "none", str_len=len("none")) + call register_variable_attribute(file_obj,axisname, "cartesian_axis", "X", str_len=1) call get_global_io_domain_indices(file_obj, axisname, is, ie, buffer) call write_data(file_obj, axisname, buffer) endif @@ -139,7 +142,9 @@ subroutine fv_io_register_axis(file_obj, numx, xpos, numy, ypos, numz, zsize) call register_axis(file_obj, axisname, 'Y', domain_position=ypos(i)) if (.not. file_obj%is_readonly) then !if writing file call register_field(file_obj, axisname, "double", (/axisname/)) - call register_variable_attribute(file_obj,axisname, "axis", "Y", str_len=1) + call register_variable_attribute(file_obj,axisname, "long_name", axisname, str_len=len(axisname)) + call register_variable_attribute(file_obj,axisname, "units", "none", str_len=len("none")) + call register_variable_attribute(file_obj,axisname, "cartesian_axis", "Y", str_len=1) call get_global_io_domain_indices(file_obj, axisname, is, ie, buffer) call write_data(file_obj, axisname, buffer) endif @@ -153,7 +158,9 @@ subroutine fv_io_register_axis(file_obj, numx, xpos, numy, ypos, numz, zsize) call register_axis(file_obj, axisname, zsize(i)) if (.not. file_obj%is_readonly) then !if writing file call register_field(file_obj, axisname, "double", (/axisname/)) - call register_variable_attribute(file_obj,axisname, "axis", "Z", str_len=1) + call register_variable_attribute(file_obj,axisname, "long_name", axisname, str_len=len(axisname)) + call register_variable_attribute(file_obj,axisname, "units", "none", str_len=len("none")) + call register_variable_attribute(file_obj,axisname, "cartesian_axis", "Z", str_len=1) if (allocated(buffer)) deallocate(buffer) allocate(buffer(zsize(i))) do j = 1, zsize(i) @@ -168,11 +175,11 @@ subroutine fv_io_register_axis(file_obj, numx, xpos, numy, ypos, numz, zsize) call register_axis(file_obj, "Time", unlimited) if (.not. file_obj%is_readonly) then !if writing file call register_field(file_obj, "Time", "double", (/"Time"/)) - call register_variable_attribute(file_obj, "Time", "cartesian_axis", "T", str_len=1) - call register_variable_attribute(file_obj, "Time", "units", "time level", & - str_len=len("time level")) call register_variable_attribute(file_obj, "Time", "long_name", "Time", & str_len=len("Time")) + call register_variable_attribute(file_obj, "Time", "units", "time level", & + str_len=len("time level")) + call register_variable_attribute(file_obj, "Time", "cartesian_axis", "T", str_len=1) call write_data(file_obj, "Time", 1) endif @@ -234,23 +241,31 @@ subroutine fv_io_register_restart(Atm) call register_axis(Atm%Fv_restart, "xaxis_1", size(Atm%ak(:), 1)) call register_axis(Atm%Fv_restart, "Time", unlimited) if (.not. Atm%Fv_restart%is_readonly) then !if writing file - call register_field(Atm%Fv_restart, "xaxis_1", "double", (/"xaxis_1"/)) - call register_variable_attribute(Atm%Fv_restart,"xaxis_1", "axis", "X", str_len=1) + call register_field(Atm%Fv_restart, dim_names_2d(1), "double", (/dim_names_2d(1)/)) + call register_variable_attribute(Atm%Fv_restart, dim_names_2d(1), "long_name", dim_names_2d(1), str_len=len(dim_names_2d(1))) + call register_variable_attribute(Atm%Fv_restart, dim_names_2d(1), "units", "none", str_len=len("none")) + call register_variable_attribute(Atm%Fv_restart, dim_names_2d(1), "cartesian_axis", "X", str_len=1) if (allocated(buffer)) deallocate(buffer) allocate(buffer(size(Atm%ak(:), 1))) do j = 1, size(Atm%ak(:), 1) buffer(j) = j end do - call write_data(Atm%Fv_restart, "xaxis_1", buffer) + call write_data(Atm%Fv_restart, dim_names_2d(1), buffer) deallocate(buffer) - call register_field(Atm%Fv_restart, "Time", "double", (/"Time"/)) - call register_variable_attribute(Atm%Fv_restart, dim_names_2d(2), "cartesian_axis", "T", str_len=1) - call register_variable_attribute(Atm%Fv_restart, dim_names_2d(2), "units", "time level", str_len=len("time level")) + call register_field(Atm%Fv_restart, dim_names_2d(2), "double", (/dim_names_2d(2)/)) call register_variable_attribute(Atm%Fv_restart, dim_names_2d(2), "long_name", dim_names_2d(2), str_len=len(dim_names_2d(2))) - call write_data(Atm%Fv_restart, "Time", 1) + call register_variable_attribute(Atm%Fv_restart, dim_names_2d(2), "units", "time level", str_len=len("time level")) + call register_variable_attribute(Atm%Fv_restart, dim_names_2d(2), "cartesian_axis", "T", str_len=1) + call write_data(Atm%Fv_restart, dim_names_2d(2), 1) endif call register_restart_field (Atm%Fv_restart, 'ak', Atm%ak(:), dim_names_2d) call register_restart_field (Atm%Fv_restart, 'bk', Atm%bk(:), dim_names_2d) + if (.not. Atm%Fv_restart%is_readonly) then !if writing file + call register_variable_attribute(Atm%Fv_restart, 'ak', "long_name", "ak", str_len=len("ak")) + call register_variable_attribute(Atm%Fv_restart, 'ak', "units", "none", str_len=len("none")) + call register_variable_attribute(Atm%Fv_restart, 'bk', "long_name", "bk", str_len=len("bk")) + call register_variable_attribute(Atm%Fv_restart, 'bk', "units", "none", str_len=len("none")) + endif ! fname= 'fv_core.res'//trim(stile_name)//'.nc' elseif (Atm%Fv_restart_tile_is_open) then @@ -279,11 +294,42 @@ subroutine fv_io_register_restart(Atm) call register_restart_field(Atm%Fv_restart_tile, 'phis', Atm%phis, dim_names_3d) !--- include agrid winds in restarts for use in data assimilation - if (Atm%flagstruct%agrid_vel_rst) then + if (Atm%flagstruct%agrid_vel_rst) then call register_restart_field(Atm%Fv_restart_tile, 'ua', Atm%ua, dim_names_4d3) call register_restart_field(Atm%Fv_restart_tile, 'va', Atm%va, dim_names_4d3) endif + if (.not. Atm%Fv_restart_tile%is_readonly) then !if writing file + call register_variable_attribute(Atm%Fv_restart_tile, 'u', "long_name", "u", str_len=len("u")) + call register_variable_attribute(Atm%Fv_restart_tile, 'u', "units", "none", str_len=len("none")) + call register_variable_attribute(Atm%Fv_restart_tile, 'v', "long_name", "v", str_len=len("v")) + call register_variable_attribute(Atm%Fv_restart_tile, 'v', "units", "none", str_len=len("none")) + if (variable_exists(Atm%Fv_restart_tile, 'W')) then + call register_variable_attribute(Atm%Fv_restart_tile, 'W', "long_name", "W", str_len=len("W")) + call register_variable_attribute(Atm%Fv_restart_tile, 'W', "units", "none", str_len=len("none")) + endif + if (variable_exists(Atm%Fv_restart_tile, 'DZ')) then + call register_variable_attribute(Atm%Fv_restart_tile, 'DZ', "long_name", "DZ", str_len=len("DZ")) + call register_variable_attribute(Atm%Fv_restart_tile, 'DZ', "units", "none", str_len=len("none")) + endif + if ( Atm%flagstruct%hybrid_z .and. variable_exists(Atm%Fv_restart_tile, 'ZEO')) then + call register_variable_attribute(Atm%Fv_restart_tile, 'ZE0', "long_name", "ZE0", str_len=len("ZEO")) + call register_variable_attribute(Atm%Fv_restart_tile, 'ZEO', "units", "none", str_len=len("none")) + endif + call register_variable_attribute(Atm%Fv_restart_tile, 'T', "long_name", "T", str_len=len("T")) + call register_variable_attribute(Atm%Fv_restart_tile, 'T', "units", "none", str_len=len("none")) + call register_variable_attribute(Atm%Fv_restart_tile, 'delp', "long_name", "delp", str_len=len("delp")) + call register_variable_attribute(Atm%Fv_restart_tile, 'delp', "units", "none", str_len=len("none")) + call register_variable_attribute(Atm%Fv_restart_tile, 'phis', "long_name", "phis", str_len=len("phis")) + call register_variable_attribute(Atm%Fv_restart_tile, 'phis', "units", "none", str_len=len("none")) + if (Atm%flagstruct%agrid_vel_rst) then + call register_variable_attribute(Atm%Fv_restart_tile, 'ua', "long_name", "ua", str_len=len("ua")) + call register_variable_attribute(Atm%Fv_restart_tile, 'ua', "units", "none", str_len=len("none")) + call register_variable_attribute(Atm%Fv_restart_tile, 'va', "long_name", "va", str_len=len("va")) + call register_variable_attribute(Atm%Fv_restart_tile, 'va', "units", "none", str_len=len("none")) + endif + endif + ! fname = 'fv_srf_wnd.res'//trim(stile_name)//'.nc elseif (Atm%Rsf_restart_is_open) then call fv_io_register_axis(Atm%Rsf_restart, numx=numx, numy=numy, xpos=xpos, ypos=ypos) @@ -292,16 +338,35 @@ subroutine fv_io_register_restart(Atm) #ifdef SIM_PHYS call register_restart_field(Atm%Rsf_restart, 'ts', Atm%ts, dim_names_3d2) #endif + if (.not. Atm%Rsf_restart%is_readonly) then !if writing file + call register_variable_attribute(Atm%Rsf_restart, 'u_srf', "long_name", "u_srf", str_len=len("u_srf")) + call register_variable_attribute(Atm%Rsf_restart, 'u_srf', "units", "none", str_len=len("none")) + call register_variable_attribute(Atm%Rsf_restart, 'v_srf', "long_name", "v_srf", str_len=len("v_srf")) + call register_variable_attribute(Atm%Rsf_restart, 'v_srf', "units", "none", str_len=len("none")) +#ifdef SIM_PHYS + call register_variable_attribute(Atm%Rsf_restart, 'ts', "long_name", "ts", str_len=len("ts")) + call register_variable_attribute(Atm%Rsf_restart, 'ts', "units", "none", str_len=len("none")) +#endif + endif + ! fname = 'mg_drag.res'//trim(stile_name)//'.nc' elseif (Atm%Mg_restart_is_open) then call fv_io_register_axis(Atm%Mg_restart, numx=numx, numy=numy, xpos=xpos, ypos=ypos) call register_restart_field (Atm%Mg_restart, 'ghprime', Atm%sgh, dim_names_3d2) + if (.not. Atm%Mg_restart%is_readonly) then !if writing file + call register_variable_attribute(Atm%Mg_restart, 'ghprime', "long_name", "ghprime", str_len=len("ghprime")) + call register_variable_attribute(Atm%Mg_restart, 'ghprime', "units", "none", str_len=len("none")) + endif ! fname = 'fv_land.res'//trim(stile_name)//'.nc' elseif (Atm%Lnd_restart_is_open) then call fv_io_register_axis(Atm%Lnd_restart, numx=numx, numy=numy, xpos=xpos, ypos=ypos) call register_restart_field (Atm%Lnd_restart, 'oro', Atm%oro, dim_names_3d2) + if (.not. Atm%Lnd_restart%is_readonly) then !if writing file + call register_variable_attribute(Atm%Lnd_restart, 'oro', "long_name", "oro", str_len=len("oro")) + call register_variable_attribute(Atm%Lnd_restart, 'oro', "units", "none", str_len=len("none")) + endif ! fname = 'fv_tracer.res'//trim(stile_name)//'.nc' elseif (Atm%Tra_restart_is_open) then @@ -309,21 +374,21 @@ subroutine fv_io_register_restart(Atm) call fv_io_register_axis(Atm%Tra_restart, numx=numx, numy=numy, xpos=xpos, ypos=ypos, numz=numz, zsize=zsize) do nt = 1, ntprog call get_tracer_names(MODEL_ATMOS, nt, tracer_name) - if(Atm%Tra_restart%is_readonly) then !if reading file (don't do this if writing) - ! set all tracers to an initial profile value - call set_tracer_profile (MODEL_ATMOS, nt, Atm%q(:,:,:,nt) ) - endif call register_restart_field(Atm%Tra_restart, tracer_name, Atm%q(:,:,:,nt), & dim_names_4d, is_optional=.true.) + if (variable_exists(Atm%Tra_restart, tracer_name) .and. .not. Atm%Tra_restart%is_readonly) then + call register_variable_attribute(Atm%Tra_restart, tracer_name, "long_name", tracer_name, str_len=len(tracer_name)) + call register_variable_attribute(Atm%Tra_restart, tracer_name, "units", "none", str_len=len("none")) + endif enddo do nt = ntprog+1, ntracers call get_tracer_names(MODEL_ATMOS, nt, tracer_name) - if(Atm%Tra_restart%is_readonly) then !if reading file (don't do this if writing) - ! set all tracers to an initial profile value - call set_tracer_profile (MODEL_ATMOS, nt, Atm%qdiag(:,:,:,nt) ) - endif call register_restart_field(Atm%Tra_restart, tracer_name, Atm%qdiag(:,:,:,nt), & dim_names_4d, is_optional=.true.) + if (variable_exists(Atm%Tra_restart, tracer_name) .and. .not. Atm%Tra_restart%is_readonly) then + call register_variable_attribute(Atm%Tra_restart, tracer_name, "long_name", tracer_name, str_len=len(tracer_name)) + call register_variable_attribute(Atm%Tra_restart, tracer_name, "units", "none", str_len=len("none")) + endif enddo endif end subroutine fv_io_register_restart @@ -336,9 +401,11 @@ end subroutine fv_io_register_restart ! ! Write the fv core restart quantities ! - subroutine fv_io_read_restart(fv_domain,Atm) + subroutine fv_io_read_restart(fv_domain,Atm,prefix,directory) type(domain2d), intent(inout) :: fv_domain type(fv_atmos_type), intent(inout) :: Atm(:) + character(len=*), optional, intent(in) :: prefix + character(len=*), optional, intent(in) :: directory character(len=64) :: tracer_name integer :: isc, iec, jsc, jec, n, nt, nk, ntracers @@ -346,17 +413,21 @@ subroutine fv_io_read_restart(fv_domain,Atm) integer :: ks, ntiles real :: ptop + character (len=:), allocatable :: dir, pre, suffix, fname character(len=128) :: tracer_longname, tracer_units - character(len=120) :: fname - character(len=20) :: suffix character(len=1) :: tile_num integer, allocatable, dimension(:) :: pes !< Array of the pes in the current pelist + pre = '' + if (present(prefix)) pre = ''//trim(prefix)//'.' + dir = 'INPUT' + if (present(directory)) dir = trim(directory) + allocate(pes(mpp_npes())) call mpp_get_current_pelist(pes) suffix = '' - fname = 'INPUT/fv_core.res.nc' + fname = ''//trim(dir)//'/'//trim(pre)//'fv_core.res.nc' Atm(1)%Fv_restart_is_open = open_file(Atm(1)%Fv_restart,fname,"read", is_restart=.true., pelist=pes) if (Atm(1)%Fv_restart_is_open) then call fv_io_register_restart(Atm(1)) @@ -381,21 +452,21 @@ subroutine fv_io_read_restart(fv_domain,Atm) suffix = ''//trim(suffix)//'.tile1' endif - fname = 'INPUT/fv_core.res'//trim(suffix)//'.nc' + fname = ''//trim(dir)//'/'//trim(pre)//'fv_core.res'//trim(suffix)//'.nc' Atm(1)%Fv_restart_tile_is_open = open_file(Atm(1)%Fv_restart_tile, fname, "read", fv_domain, is_restart=.true.) if (Atm(1)%Fv_restart_tile_is_open) then call fv_io_register_restart(Atm(1)) - call read_restart(Atm(1)%Fv_restart_tile) + call read_restart(Atm(1)%Fv_restart_tile, ignore_checksum=Atm(1)%flagstruct%ignore_rst_cksum) call close_file(Atm(1)%Fv_restart_tile) Atm(1)%Fv_restart_tile_is_open = .false. endif !--- restore data for fv_tracer - if it exists - fname = 'INPUT/fv_tracer.res'//trim(suffix)//'.nc' + fname = ''//trim(dir)//'/'//trim(pre)//'fv_tracer.res'//trim(suffix)//'.nc' Atm(1)%Tra_restart_is_open = open_file(Atm(1)%Tra_restart, fname, "read", fv_domain, is_restart=.true.) if (Atm(1)%Tra_restart_is_open) then call fv_io_register_restart(Atm(1)) - call read_restart(Atm(1)%Tra_restart) + call read_restart(Atm(1)%Tra_restart, ignore_checksum=Atm(1)%flagstruct%ignore_rst_cksum) call close_file(Atm(1)%Tra_restart) Atm(1)%Tra_restart_is_open = .false. else @@ -403,12 +474,12 @@ subroutine fv_io_read_restart(fv_domain,Atm) endif !--- restore data for surface winds - if it exists - fname = 'INPUT/fv_srf_wnd.res'//trim(suffix)//'.nc' + fname = ''//trim(dir)//'/'//trim(pre)//'fv_srf_wnd.res'//trim(suffix)//'.nc' Atm(1)%Rsf_restart_is_open = open_file(Atm(1)%Rsf_restart, fname, "read", fv_domain, is_restart=.true.) if (Atm(1)%Rsf_restart_is_open) then Atm(1)%flagstruct%srf_init = .true. call fv_io_register_restart(Atm(1)) - call read_restart(Atm(1)%Rsf_restart) + call read_restart(Atm(1)%Rsf_restart, ignore_checksum=Atm(1)%flagstruct%ignore_rst_cksum) call close_file(Atm(1)%Rsf_restart) Atm(1)%Rsf_restart_is_open = .false. else @@ -418,22 +489,22 @@ subroutine fv_io_read_restart(fv_domain,Atm) if ( Atm(1)%flagstruct%fv_land ) then !--- restore data for mg_drag - if it exists - fname = 'INPUT/mg_drag.res'//trim(suffix)//'.nc' + fname = ''//trim(dir)//'/'//trim(pre)//'mg_drag.res'//trim(suffix)//'.nc' Atm(1)%Mg_restart_is_open = open_file(Atm(1)%Mg_restart, fname, "read", fv_domain, is_restart=.true.) if (Atm(1)%Mg_restart_is_open) then call fv_io_register_restart(Atm(1)) - call read_restart(Atm(1)%Mg_restart) + call read_restart(Atm(1)%Mg_restart, ignore_checksum=Atm(1)%flagstruct%ignore_rst_cksum) call close_file(Atm(1)%Mg_restart) Atm(1)%Mg_restart_is_open = .false. else call mpp_error(NOTE,'==> Warning from fv_read_restart: Expected file '//trim(fname)//' does not exist') endif !--- restore data for fv_land - if it exists - fname = 'INPUT/fv_land.res'//trim(suffix)//'.nc' + fname = ''//trim(dir)//'/'//trim(pre)//'/fv_land.res'//trim(suffix)//'.nc' Atm(1)%Lnd_restart_is_open = open_file(Atm(1)%Lnd_restart, fname, "read", fv_domain, is_restart=.true.) if (Atm(1)%Lnd_restart_is_open) then call fv_io_register_restart(Atm(1)) - call read_restart(Atm(1)%Lnd_restart) + call read_restart(Atm(1)%Lnd_restart, ignore_checksum=Atm(1)%flagstruct%ignore_rst_cksum) call close_file(Atm(1)%Lnd_restart) Atm(1)%Lnd_restart_is_open = .false. else @@ -448,8 +519,7 @@ end subroutine fv_io_read_restart !##################################################################### - subroutine fv_io_read_tracers(fv_domain,Atm) - type(domain2d), intent(inout) :: fv_domain + subroutine fv_io_read_tracers(Atm) type(fv_atmos_type), intent(inout) :: Atm(:) integer :: ntracers, ntprog, nt, isc, iec, jsc, jec character(len=6) :: stile_name @@ -464,7 +534,7 @@ subroutine fv_io_read_tracers(fv_domain,Atm) call get_number_tracers(MODEL_ATMOS, num_tracers=ntracers, num_prog=ntprog) ! fix for single tile runs where you need fv_core.res.nc and fv_core.res.tile1.nc - ntiles = mpp_get_ntile_count(fv_domain) + ntiles = mpp_get_ntile_count(Atm(1)%domain_for_read) if(ntiles == 1 .and. .not. Atm(1)%neststruct%nested) then stile_name = '.tile1' else @@ -473,7 +543,7 @@ subroutine fv_io_read_tracers(fv_domain,Atm) fname = 'INPUT/fv_tracer.res'//trim(stile_name)//'.nc' - if (open_file(Tra_restart_r,fname,"read",fv_domain, is_restart=.true.)) then + if (open_file(Tra_restart_r,fname,"read",Atm(1)%domain_for_read, is_restart=.true.)) then do nt = 2, ntprog call get_tracer_names(MODEL_ATMOS, nt, tracer_name) call set_tracer_profile (MODEL_ATMOS, nt, Atm(1)%q(isc:iec,jsc:jec,:,nt) ) @@ -497,10 +567,9 @@ subroutine fv_io_read_tracers(fv_domain,Atm) end subroutine fv_io_read_tracers - subroutine remap_restart(fv_domain,Atm) + subroutine remap_restart(Atm) use fv_mapz_mod, only: rst_remap - type(domain2d), intent(inout) :: fv_domain type(fv_atmos_type), intent(inout) :: Atm(:) character(len=64) :: fname, tracer_name @@ -509,6 +578,7 @@ subroutine remap_restart(fv_domain,Atm) integer :: isd, ied, jsd, jed integer :: ntiles + type(domain2d) :: fv_domain type(FmsNetcdfDomainFile_t) :: FV_tile_restart_r, Tra_restart_r type(FmsNetcdfFile_t) :: Fv_restart_r integer, allocatable, dimension(:) :: pes !< Array of the pes in the current pelist @@ -523,6 +593,7 @@ subroutine remap_restart(fv_domain,Atm) integer npz, npz_rst, ng integer i,j,k + fv_domain = Atm(1)%domain_for_read npz = Atm(1)%npz ! run time z dimension npz_rst = Atm(1)%flagstruct%npz_rst ! restart z dimension isc = Atm(1)%bd%isc; iec = Atm(1)%bd%iec; jsc = Atm(1)%bd%jsc; jec = Atm(1)%bd%jec @@ -603,7 +674,7 @@ subroutine remap_restart(fv_domain,Atm) if (Atm(1)%Rsf_restart_is_open) then Atm%flagstruct%srf_init = .true. call fv_io_register_restart(Atm(1)) - call read_restart(Atm(1)%Rsf_restart) + call read_restart(Atm(1)%Rsf_restart, ignore_checksum=Atm(1)%flagstruct%ignore_rst_cksum) call close_file(Atm(1)%Rsf_restart) Atm(1)%Rsf_restart_is_open = .false. call mpp_error(NOTE,'==> Warning from remap_restart: Expected file '//trim(fname)//' does not exist') @@ -659,8 +730,7 @@ subroutine remap_restart(fv_domain,Atm) j = (jsc + jec)/2 k = npz_rst/2 if( is_master() ) write(*,*) 'Calling read_da_inc',pt_r(i,j,k) - call read_da_inc(Atm(1), Atm(1)%domain, Atm(1)%bd, npz_rst, ntprog, & - u_r, v_r, q_r, delp_r, pt_r, isc, jsc, iec, jec ) + call read_da_inc(Atm(1), Atm(1)%domain) if( is_master() ) write(*,*) 'Back from read_da_inc',pt_r(i,j,k) endif ! ====== end PJP added DA functionailty====== @@ -706,9 +776,8 @@ subroutine fv_io_register_nudge_restart(Atm) call mpp_error(NOTE, 'READING FROM SST_restart DISABLED') end subroutine fv_io_register_nudge_restart - ! NAME="fv_io_register_nudge_restart" - + ! NAME="fv_io_register_nudge_restart" !##################################################################### ! @@ -716,15 +785,16 @@ end subroutine fv_io_register_nudge_restart ! ! Write the fv core restart quantities ! - subroutine fv_io_write_restart(Atm, timestamp) + subroutine fv_io_write_restart(Atm, prefix, directory) type(fv_atmos_type), intent(inout) :: Atm - character(len=*), optional, intent(in) :: timestamp + character(len=*), optional, intent(in) :: prefix + character(len=*), optional, intent(in) :: directory + + character (len=:), allocatable :: dir, pre, fname, suffix integer :: ntiles logical :: tile_file_exists type(domain2d) :: fv_domain - character(len=120) :: fname - character(len=20) :: suffix character(len=1) :: tile_num integer, allocatable, dimension(:) :: pes !< Array of the pes in the current pelist fv_domain = Atm%domain @@ -733,12 +803,14 @@ subroutine fv_io_write_restart(Atm, timestamp) !call save_restart(Atm%SST_restart, timestamp) endif + pre = '' + dir = 'RESTART' + if (present(prefix)) pre = ''//trim(prefix)//'.' + if (present(directory)) dir = trim(directory) + suffix = '' - if (present(timestamp)) then - fname = 'RESTART/'//trim(timestamp)//'.fv_core.res'//trim(suffix)//'.nc' - else - fname = 'RESTART/fv_core.res'//trim(suffix)//'.nc' - endif + + fname = ''//trim(dir)//'/'//trim(pre)//'fv_core.res.nc' allocate(pes(mpp_npes())) call mpp_get_current_pelist(pes) Atm%Fv_restart_is_open = open_file(Atm%Fv_restart, fname, "overwrite", is_restart=.true., pelist=pes) @@ -756,12 +828,7 @@ subroutine fv_io_write_restart(Atm, timestamp) suffix = ''//trim(suffix)//'.tile1' endif - if (present(timestamp)) then - fname = 'RESTART/'//trim(timestamp)//'.fv_core.res'//trim(suffix)//'.nc' - else - fname = 'RESTART/fv_core.res'//trim(suffix)//'.nc' - endif - + fname = ''//trim(dir)//'/'//trim(pre)//'fv_core.res'//trim(suffix)//'.nc' Atm%Fv_restart_tile_is_open = open_file(Atm%Fv_restart_tile, fname, "overwrite", fv_domain, is_restart=.true.) if (Atm%Fv_restart_tile_is_open) then call fv_io_register_restart(Atm) @@ -770,11 +837,7 @@ subroutine fv_io_write_restart(Atm, timestamp) Atm%Fv_restart_tile_is_open = .false. endif - if (present(timestamp)) then - fname = 'RESTART/'//trim(timestamp)//'.fv_srf_wnd.res'//trim(suffix)//'.nc' - else - fname = 'RESTART/fv_srf_wnd.res'//trim(suffix)//'.nc' - endif + fname = ''//trim(dir)//'/'//trim(pre)//'fv_srf_wnd.res'//trim(suffix)//'.nc' Atm%Rsf_restart_is_open = open_file(Atm%Rsf_restart, fname, "overwrite", fv_domain, is_restart=.true.) if (Atm%Rsf_restart_is_open) then call fv_io_register_restart(Atm) @@ -784,11 +847,7 @@ subroutine fv_io_write_restart(Atm, timestamp) endif if ( Atm%flagstruct%fv_land ) then - if (present(timestamp)) then - fname = 'RESTART/'//trim(timestamp)//'.mg_drag.res'//trim(suffix)//'.nc' - else - fname = 'RESTART/mg_drag.res'//trim(suffix)//'.nc' - endif + fname = ''//trim(dir)//'/'//trim(pre)//'mg_drag.res'//trim(suffix)//'.nc' Atm%Mg_restart_is_open = open_file(Atm%Mg_restart, fname, "overwrite", fv_domain, is_restart=.true.) if (Atm%Mg_restart_is_open) then call fv_io_register_restart(Atm) @@ -797,11 +856,7 @@ subroutine fv_io_write_restart(Atm, timestamp) Atm%Mg_restart_is_open = .false. endif - if (present(timestamp)) then - fname = 'RESTART'//trim(timestamp)//'./fv_land.res'//trim(suffix)//'.nc' - else - fname = 'RESTART/fv_land.res'//trim(suffix)//'.nc' - endif + fname = ''//trim(dir)//'/'//trim(pre)//'/fv_land.res'//trim(suffix)//'.nc' Atm%Lnd_restart_is_open = open_file(Atm%Lnd_restart, fname, "overwrite", fv_domain, is_restart=.true.) if (Atm%Lnd_restart_is_open) then call fv_io_register_restart(Atm) @@ -811,11 +866,7 @@ subroutine fv_io_write_restart(Atm, timestamp) endif endif - if (present(timestamp)) then - fname = 'RESTART/'//trim(timestamp)//'.fv_tracer.res'//trim(suffix)//'.nc' - else - fname = 'RESTART/fv_tracer.res'//trim(suffix)//'.nc' - endif + fname = ''//trim(dir)//'/'//trim(pre)//'fv_tracer.res'//trim(suffix)//'.nc' Atm%Tra_restart_is_open = open_file(Atm%Tra_restart, fname, "overwrite", fv_domain, is_restart=.true.) if (Atm%Tra_restart_is_open) then call fv_io_register_restart(Atm) @@ -824,7 +875,8 @@ subroutine fv_io_write_restart(Atm, timestamp) Atm%Tra_restart_is_open = .false. endif - end subroutine fv_io_write_restart + end subroutine fv_io_write_restart + subroutine register_bcs_2d(Atm, BCfile_ne, BCfile_sw, fname_ne, fname_sw, & var_name, var, var_bc, istag, jstag) @@ -887,36 +939,66 @@ subroutine register_bcs_2d(Atm, BCfile_ne, BCfile_sw, fname_ne, fname_sw, & is_root_pe = .FALSE. if (is.eq.1 .and. js.eq.1) is_root_pe = .TRUE. !register west halo data in t1 - if (present(var_bc) .and. Atm%neststruct%BCfile_sw_is_open) call register_restart_field(BCfile_sw, & - trim(var_name)//'_west_t1', & - var_bc%west_t1, & - indices, global_size, y2_pelist, & - is_root_pe, jshift=y_halo) + if (present(var_bc) .and. Atm%neststruct%BCfile_sw_is_open) then + call register_restart_field(BCfile_sw, trim(var_name)//'_west_t1', & + var_bc%west_t1, indices, global_size, & + y2_pelist, is_root_pe, jshift=y_halo) + if (.not. BCfile_sw%is_readonly) then !if writing file + call register_variable_attribute(BCfile_sw, trim(var_name)//'_west_t1', & + "long_name", trim(var_name)//'_west_t1', & + str_len=len(trim(var_name)//'_west_t1')) + call register_variable_attribute(BCfile_sw, trim(var_name)//'_west_t1', & + "units", "none", str_len=len("none")) + endif + endif !register west prognostic halo data - if (present(var) .and. Atm%neststruct%BCfile_sw_is_open) call register_restart_field(BCfile_sw, & - trim(var_name)//'_west', & - var, indices, global_size, & - y2_pelist, is_root_pe, jshift=y_halo) + if (present(var) .and. Atm%neststruct%BCfile_sw_is_open) then + call register_restart_field(BCfile_sw, trim(var_name)//'_west', & + var, indices, global_size, & + y2_pelist, is_root_pe, jshift=y_halo) + if (.not. BCfile_sw%is_readonly) then !if writing file + call register_variable_attribute(BCfile_sw, trim(var_name)//'_west', & + "long_name", trim(var_name)//'_west', & + str_len=len(trim(var_name)//'_west')) + call register_variable_attribute(BCfile_sw, trim(var_name)//'_west', & + "units", "none", str_len=len("none")) + endif + endif !define east root_pe is_root_pe = .FALSE. if (ie.eq.npx-1 .and. je.eq.npy-1) is_root_pe = .TRUE. !register east halo data in t1 - if (present(var_bc) .and. Atm%neststruct%BCfile_ne_is_open) call register_restart_field(BCfile_ne, & - trim(var_name)//'_east_t1', & - var_bc%east_t1, & - indices, global_size, y1_pelist, & - is_root_pe, jshift=y_halo) + if (present(var_bc) .and. Atm%neststruct%BCfile_ne_is_open) then + call register_restart_field(BCfile_ne, trim(var_name)//'_east_t1', & + var_bc%east_t1, indices, global_size, & + y1_pelist, is_root_pe, jshift=y_halo) + if (.not. BCfile_ne%is_readonly) then !if writing file + call register_variable_attribute(BCfile_ne, trim(var_name)//'_east_t1', & + "long_name", trim(var_name)//'_east_t1', & + str_len=len(trim(var_name)//'_east_t1')) + call register_variable_attribute(BCfile_ne, trim(var_name)//'_east_t1', & + "units", "none", str_len=len("none")) + endif + endif !reset indices for prognostic variables in the east halo indices(1) = ied-x_halo+1+i_stag indices(2) = ied+i_stag !register east prognostic halo data - if (present(var) .and. Atm%neststruct%BCfile_ne_is_open) call register_restart_field(BCfile_ne, & - trim(var_name)//'_east', & - var, indices, global_size, & - y1_pelist, is_root_pe, jshift=y_halo, & - x_halo=(size(var,1)-x_halo), ishift=-(ie+i_stag)) + if (present(var) .and. Atm%neststruct%BCfile_ne_is_open) then + call register_restart_field(BCfile_ne, trim(var_name)//'_east', & + var, indices, global_size, & + y1_pelist, is_root_pe, jshift=y_halo, & + x_halo=(size(var,1)-x_halo), ishift=-(ie+i_stag)) + if (.not. BCfile_ne%is_readonly) then !if writing file + call register_variable_attribute(BCfile_ne, trim(var_name)//'_east', & + "long_name", trim(var_name)//'_east', & + str_len=len(trim(var_name)//'_east')) + call register_variable_attribute(BCfile_ne, trim(var_name)//'_east', & + "units", "none", str_len=len("none")) + endif + endif !NORTH & SOUTH !set defaults for north/south halo regions @@ -936,36 +1018,66 @@ subroutine register_bcs_2d(Atm, BCfile_ne, BCfile_sw, fname_ne, fname_sw, & is_root_pe = .FALSE. if (is.eq.1 .and. js.eq.1) is_root_pe = .TRUE. !register south halo data in t1 - if (present(var_bc) .and. Atm%neststruct%BCfile_sw_is_open) call register_restart_field(BCfile_sw, & - trim(var_name)//'_south_t1', & - var_bc%south_t1, & - indices, global_size, x2_pelist, & - is_root_pe, x_halo=x_halo_ns) + if (present(var_bc) .and. Atm%neststruct%BCfile_sw_is_open) then + call register_restart_field(BCfile_sw, trim(var_name)//'_south_t1', & + var_bc%south_t1, indices, global_size, & + x2_pelist, is_root_pe, x_halo=x_halo_ns) + if (.not. BCfile_sw%is_readonly) then !if writing file + call register_variable_attribute(BCfile_sw, trim(var_name)//'_south_t1', & + "long_name", trim(var_name)//'_south_t1', & + str_len=len(trim(var_name)//'_south_t1')) + call register_variable_attribute(BCfile_sw, trim(var_name)//'_south_t1', & + "units", "none", str_len=len("none")) + endif + endif !register south prognostic halo data - if (present(var) .and. Atm%neststruct%BCfile_sw_is_open) call register_restart_field(BCfile_sw, & - trim(var_name)//'_south', & - var, indices, global_size, & - x2_pelist, is_root_pe, x_halo=x_halo_ns) + if (present(var) .and. Atm%neststruct%BCfile_sw_is_open) then + call register_restart_field(BCfile_sw, trim(var_name)//'_south', & + var, indices, global_size, & + x2_pelist, is_root_pe, x_halo=x_halo_ns) + if (.not. BCfile_sw%is_readonly) then !if writing file + call register_variable_attribute(BCfile_sw, trim(var_name)//'_south', & + "long_name", trim(var_name)//'_south', & + str_len=len(trim(var_name)//'_south')) + call register_variable_attribute(BCfile_sw, trim(var_name)//'_south', & + "units", "none", str_len=len("none")) + endif + endif !define north root_pe is_root_pe = .FALSE. if (ie.eq.npx-1 .and. je.eq.npy-1) is_root_pe = .TRUE. !register north halo data in t1 - if (present(var_bc) .and. Atm%neststruct%BCfile_ne_is_open) call register_restart_field(BCfile_ne, & - trim(var_name)//'_north_t1', & - var_bc%north_t1, & - indices, global_size, x1_pelist, & - is_root_pe, x_halo=x_halo_ns) + if (present(var_bc) .and. Atm%neststruct%BCfile_ne_is_open) then + call register_restart_field(BCfile_ne, trim(var_name)//'_north_t1', & + var_bc%north_t1, indices, global_size, & + x1_pelist, is_root_pe, x_halo=x_halo_ns) + if (.not. BCfile_ne%is_readonly) then !if writing file + call register_variable_attribute(BCfile_ne, trim(var_name)//'_north_t1', & + "long_name", trim(var_name)//'_north_t1', & + str_len=len(trim(var_name)//'_north_t1')) + call register_variable_attribute(BCfile_ne, trim(var_name)//'_north_t1', & + "units", "none", str_len=len("none")) + endif + endif !reset indices for prognostic variables in the north halo indices(3) = jed-y_halo+1+j_stag indices(4) = jed+j_stag !register north prognostic halo data - if (present(var) .and. Atm%neststruct%BCfile_ne_is_open) call register_restart_field(BCfile_ne, & - trim(var_name)//'_north', & - var, indices, global_size, & - x1_pelist, is_root_pe, x_halo=x_halo_ns, & - y_halo=(size(var,2)-y_halo), jshift=-(je+j_stag)) + if (present(var) .and. Atm%neststruct%BCfile_ne_is_open) then + call register_restart_field(BCfile_ne, trim(var_name)//'_north', & + var, indices, global_size, & + x1_pelist, is_root_pe, x_halo=x_halo_ns, & + y_halo=(size(var,2)-y_halo), jshift=-(je+j_stag)) + if (.not. BCfile_ne%is_readonly) then !if writing file + call register_variable_attribute(BCfile_ne, trim(var_name)//'_north', & + "long_name", trim(var_name)//'_north', & + str_len=len(trim(var_name)//'_north')) + call register_variable_attribute(BCfile_ne, trim(var_name)//'_north', & + "units", "none", str_len=len("none")) + endif + endif deallocate (x1_pelist) deallocate (y1_pelist) @@ -1042,36 +1154,71 @@ subroutine register_bcs_3d(Atm, BCfile_ne, BCfile_sw, fname_ne, fname_sw, & is_root_pe = .FALSE. if (is.eq.1 .and. js.eq.1) is_root_pe = .TRUE. !register west halo data in t1 - if (present(var_bc) .and. Atm%neststruct%BCfile_sw_is_open) call register_restart_field(BCfile_sw, & - trim(var_name)//'_west_t1', & - var_bc%west_t1, & - indices, global_size, y2_pelist, & - is_root_pe, jshift=y_halo, is_optional=.not.mandatory_flag) + if (present(var_bc) .and. Atm%neststruct%BCfile_sw_is_open) then + call register_restart_field(BCfile_sw, trim(var_name)//'_west_t1', & + var_bc%west_t1, indices, global_size, & + y2_pelist, is_root_pe, jshift=y_halo, & + is_optional=.not.mandatory_flag) + if (.not. BCfile_sw%is_readonly) then !if writing file + call register_variable_attribute(BCfile_sw, trim(var_name)//'_west_t1', & + "long_name", trim(var_name)//'_west_t1', & + str_len=len(trim(var_name)//'_west_t1')) + call register_variable_attribute(BCfile_sw, trim(var_name)//'_west_t1', & + "units", "none", str_len=len("none")) + endif + endif + !register west prognostic halo data - if (present(var) .and. Atm%neststruct%BCfile_sw_is_open) call register_restart_field(BCfile_sw, & - trim(var_name)//'_west', & - var, indices, global_size, & - y2_pelist, is_root_pe, jshift=y_halo, is_optional=.not.mandatory_flag) + if (present(var) .and. Atm%neststruct%BCfile_sw_is_open) then + call register_restart_field(BCfile_sw, trim(var_name)//'_west', & + var, indices, global_size, & + y2_pelist, is_root_pe, jshift=y_halo, & + is_optional=.not.mandatory_flag) + if (.not. BCfile_sw%is_readonly) then !if writing file + call register_variable_attribute(BCfile_sw, trim(var_name)//'_west', & + "long_name", trim(var_name)//'_west', & + str_len=len(trim(var_name)//'_west')) + call register_variable_attribute(BCfile_sw, trim(var_name)//'_west', & + "units", "none", str_len=len("none")) + endif + endif !define east root_pe is_root_pe = .FALSE. if (ie.eq.npx-1 .and. je.eq.npy-1) is_root_pe = .TRUE. !register east halo data in t1 - if (present(var_bc) .and. Atm%neststruct%BCfile_ne_is_open) call register_restart_field(BCfile_ne, & - trim(var_name)//'_east_t1', & - var_bc%east_t1, & - indices, global_size, y1_pelist, & - is_root_pe, jshift=y_halo, is_optional=.not.mandatory_flag) + if (present(var_bc) .and. Atm%neststruct%BCfile_ne_is_open) then + call register_restart_field(BCfile_ne, trim(var_name)//'_east_t1', & + var_bc%east_t1, indices, global_size, & + y1_pelist, is_root_pe, jshift=y_halo, & + is_optional=.not.mandatory_flag) + if (.not. BCfile_ne%is_readonly) then !if writing file + call register_variable_attribute(BCfile_ne, trim(var_name)//'_east_t1', & + "long_name", trim(var_name)//'_east_t1', & + str_len=len(trim(var_name)//'_east_t1')) + call register_variable_attribute(BCfile_ne, trim(var_name)//'_east_t1', & + "units", "none", str_len=len("none")) + endif + endif !reset indices for prognostic variables in the east halo indices(1) = ied-x_halo+1+i_stag indices(2) = ied+i_stag !register east prognostic halo data - if (present(var) .and. Atm%neststruct%BCfile_ne_is_open) call register_restart_field(BCfile_ne, & - trim(var_name)//'_east', & - var, indices, global_size, & - y1_pelist, is_root_pe, jshift=y_halo, & - x_halo=(size(var,1)-x_halo), ishift=-(ie+i_stag), is_optional=.not.mandatory_flag) + if (present(var) .and. Atm%neststruct%BCfile_ne_is_open) then + call register_restart_field(BCfile_ne, trim(var_name)//'_east', & + var, indices, global_size, & + y1_pelist, is_root_pe, jshift=y_halo, & + x_halo=(size(var,1)-x_halo), ishift=-(ie+i_stag), & + is_optional=.not.mandatory_flag) + if (.not. BCfile_ne%is_readonly) then !if writing file + call register_variable_attribute(BCfile_ne, trim(var_name)//'_east', & + "long_name", trim(var_name)//'_east', & + str_len=len(trim(var_name)//'_east')) + call register_variable_attribute(BCfile_ne, trim(var_name)//'_east', & + "units", "none", str_len=len("none")) + endif + endif !NORTH & SOUTH !set defaults for north/south halo regions @@ -1092,36 +1239,70 @@ subroutine register_bcs_3d(Atm, BCfile_ne, BCfile_sw, fname_ne, fname_sw, & is_root_pe = .FALSE. if (is.eq.1 .and. js.eq.1) is_root_pe = .TRUE. !register south halo data in t1 - if (present(var_bc) .and. Atm%neststruct%BCfile_sw_is_open) call register_restart_field(BCfile_sw, & - trim(var_name)//'_south_t1', & - var_bc%south_t1, & - indices, global_size, x2_pelist, & - is_root_pe, x_halo=x_halo_ns, is_optional=.not.mandatory_flag) + if (present(var_bc) .and. Atm%neststruct%BCfile_sw_is_open) then + call register_restart_field(BCfile_sw, trim(var_name)//'_south_t1', & + var_bc%south_t1, indices, global_size, & + x2_pelist, is_root_pe, x_halo=x_halo_ns, & + is_optional=.not.mandatory_flag) + if (.not. BCfile_sw%is_readonly) then !if writing file + call register_variable_attribute(BCfile_sw, trim(var_name)//'_south_t1', & + "long_name", trim(var_name)//'_south_t1', & + str_len=len(trim(var_name)//'_south_t1')) + call register_variable_attribute(BCfile_sw, trim(var_name)//'_south_t1', & + "units", "none", str_len=len("none")) + endif + endif !register south prognostic halo data - if (present(var) .and. Atm%neststruct%BCfile_sw_is_open) call register_restart_field(BCfile_sw, & - trim(var_name)//'_south', & - var, indices, global_size, & - x2_pelist, is_root_pe, x_halo=x_halo_ns, is_optional=.not.mandatory_flag) + if (present(var) .and. Atm%neststruct%BCfile_sw_is_open) then + call register_restart_field(BCfile_sw, trim(var_name)//'_south', & + var, indices, global_size, & + x2_pelist, is_root_pe, x_halo=x_halo_ns, & + is_optional=.not.mandatory_flag) + if (.not. BCfile_sw%is_readonly) then !if writing file + call register_variable_attribute(BCfile_sw, trim(var_name)//'_south', & + "long_name", trim(var_name)//'_south', & + str_len=len(trim(var_name)//'_south')) + call register_variable_attribute(BCfile_sw, trim(var_name)//'_south', & + "units", "none", str_len=len("none")) + endif + endif !define north root_pe is_root_pe = .FALSE. if (ie.eq.npx-1 .and. je.eq.npy-1) is_root_pe = .TRUE. !register north halo data in t1 - if (present(var_bc) .and. Atm%neststruct%BCfile_ne_is_open) call register_restart_field(BCfile_ne, & - trim(var_name)//'_north_t1', & - var_bc%north_t1, & - indices, global_size, x1_pelist, & - is_root_pe, x_halo=x_halo_ns, is_optional=.not.mandatory_flag) + if (present(var_bc) .and. Atm%neststruct%BCfile_ne_is_open) then + call register_restart_field(BCfile_ne, trim(var_name)//'_north_t1', & + var_bc%north_t1, indices, global_size, & + x1_pelist, is_root_pe, x_halo=x_halo_ns, & + is_optional=.not.mandatory_flag) + if (.not. BCfile_ne%is_readonly) then !if writing file + call register_variable_attribute(BCfile_ne, trim(var_name)//'_north_t1', & + "long_name", trim(var_name)//'_north_t1', & + str_len=len(trim(var_name)//'_north_t1')) + call register_variable_attribute(BCfile_ne, trim(var_name)//'_north_t1', & + "units", "none", str_len=len("none")) + endif + endif !reset indices for prognostic variables in the north halo indices(3) = jed-y_halo+1+j_stag indices(4) = jed+j_stag !register north prognostic halo data - if (present(var) .and. Atm%neststruct%BCfile_ne_is_open) call register_restart_field(BCfile_ne, & - trim(var_name)//'_north', & - var, indices, global_size, & - x1_pelist, is_root_pe, x_halo=x_halo_ns, & - y_halo=(size(var,2)-y_halo), jshift=-(je+j_stag), is_optional=.not.mandatory_flag) + if (present(var) .and. Atm%neststruct%BCfile_ne_is_open) then + call register_restart_field(BCfile_ne, trim(var_name)//'_north', & + var, indices, global_size, & + x1_pelist, is_root_pe, x_halo=x_halo_ns, & + y_halo=(size(var,2)-y_halo), jshift=-(je+j_stag), & + is_optional=.not.mandatory_flag) + if (.not. BCfile_ne%is_readonly) then !if writing file + call register_variable_attribute(BCfile_ne, trim(var_name)//'_north', & + "long_name", trim(var_name)//'_north', & + str_len=len(trim(var_name)//'_north')) + call register_variable_attribute(BCfile_ne, trim(var_name)//'_north', & + "units", "none", str_len=len("none")) + endif + endif deallocate (x1_pelist) deallocate (y1_pelist) deallocate (x2_pelist) @@ -1254,12 +1435,12 @@ subroutine fv_io_read_BCs(Atm) call fv_io_register_restart_BCs(Atm) if (Atm%neststruct%BCfile_sw_is_open) then - call read_restart_bc(Atm%neststruct%BCfile_sw) + call read_restart_bc(Atm%neststruct%BCfile_sw, ignore_checksum=Atm%flagstruct%ignore_rst_cksum) call close_file(Atm%neststruct%BCfile_sw) endif if (Atm%neststruct%BCfile_ne_is_open) then - call read_restart_bc(Atm%neststruct%BCfile_ne) + call read_restart_bc(Atm%neststruct%BCfile_ne, ignore_checksum=Atm%flagstruct%ignore_rst_cksum) call close_file(Atm%neststruct%BCfile_ne) endif diff --git a/tools/fv_mp_mod.F90 b/tools/fv_mp_mod.F90 index 79eb259ef..96d9a3e2b 100644 --- a/tools/fv_mp_mod.F90 +++ b/tools/fv_mp_mod.F90 @@ -10,7 +10,7 @@ !* (at your option) any later version. !* !* The FV3 dynamical core is distributed in the hope that it will be -!* useful, but WITHOUT ANYWARRANTY; without even the implied warranty +!* useful, but WITHOUT ANY WARRANTY; without even the implied warranty !* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. !* See the GNU General Public License for more details. !* @@ -18,6 +18,7 @@ !* License along with the FV3 dynamical core. !* If not, see . !*********************************************************************** + !------------------------------------------------------------------------------ !BOP ! @@ -32,6 +33,7 @@ module fv_mp_mod use mpp_mod, only : mpp_declare_pelist, mpp_set_current_pelist, mpp_sync use mpp_mod, only : mpp_clock_begin, mpp_clock_end, mpp_clock_id use mpp_mod, only : mpp_chksum, stdout, stderr, mpp_broadcast + use mpp_mod, only : mpp_min, mpp_max, mpp_sum use mpp_mod, only : mpp_send, mpp_recv, mpp_sync_self, EVENT_RECV, mpp_gather use mpp_domains_mod, only : GLOBAL_DATA_DOMAIN, BITWISE_EXACT_SUM, BGRID_NE, FOLD_NORTH_EDGE, CGRID_NE use mpp_domains_mod, only : MPP_DOMAIN_TIME, CYCLIC_GLOBAL_DOMAIN, NUPDATE,EUPDATE, XUPDATE, YUPDATE, SCALAR_PAIR @@ -47,7 +49,7 @@ module fv_mp_mod use mpp_domains_mod, only : mpp_group_update_initialized, mpp_do_group_update use mpp_domains_mod, only : mpp_create_group_update,mpp_reset_group_update_field use mpp_domains_mod, only : group_halo_update_type => mpp_group_update_type - use mpp_domains_mod, only: nest_domain_type + use mpp_domains_mod, only : nest_domain_type, mpp_get_io_domain_layout, mpp_get_layout, mpp_copy_domain use mpp_parameter_mod, only : WUPDATE, EUPDATE, SUPDATE, NUPDATE, XUPDATE, YUPDATE use fv_arrays_mod, only: fv_atmos_type, fv_grid_bounds_type use mpp_mod, only : mpp_get_current_pelist, mpp_set_current_pelist @@ -93,7 +95,7 @@ module fv_mp_mod type(nest_domain_type) :: global_nest_domain !ONE structure for ALL levels of nesting public mp_start, mp_assign_gid, mp_barrier, mp_stop!, npes - public domain_decomp, mp_bcst, mp_reduce_max, mp_reduce_sum, mp_gather + public domain_decomp, mp_reduce_max, mp_reduce_sum, mp_gather public mp_reduce_min public fill_corners, XDir, YDir public switch_current_domain, switch_current_Atm, broadcast_domains @@ -134,18 +136,6 @@ module fv_mp_mod MODULE PROCEDURE fill_corners_dgrid_r8 END INTERFACE - INTERFACE mp_bcst - MODULE PROCEDURE mp_bcst_i4 - MODULE PROCEDURE mp_bcst_r4 - MODULE PROCEDURE mp_bcst_r8 - MODULE PROCEDURE mp_bcst_3d_r4 - MODULE PROCEDURE mp_bcst_3d_r8 - MODULE PROCEDURE mp_bcst_4d_r4 - MODULE PROCEDURE mp_bcst_4d_r8 - MODULE PROCEDURE mp_bcst_3d_i8 - MODULE PROCEDURE mp_bcst_4d_i8 - END INTERFACE - INTERFACE mp_reduce_min MODULE PROCEDURE mp_reduce_min_r4 MODULE PROCEDURE mp_reduce_min_r8 @@ -162,8 +152,12 @@ module fv_mp_mod INTERFACE mp_reduce_sum MODULE PROCEDURE mp_reduce_sum_r4 MODULE PROCEDURE mp_reduce_sum_r4_1d + MODULE PROCEDURE mp_reduce_sum_r4_1darr + MODULE PROCEDURE mp_reduce_sum_r4_2darr MODULE PROCEDURE mp_reduce_sum_r8 MODULE PROCEDURE mp_reduce_sum_r8_1d + MODULE PROCEDURE mp_reduce_sum_r8_1darr + MODULE PROCEDURE mp_reduce_sum_r8_2darr END INTERFACE INTERFACE mp_gather !WARNING only works with one level (ldim == 1) @@ -281,7 +275,7 @@ end subroutine mp_stop ! domain_decomp :: Setup domain decomp ! subroutine domain_decomp(grid_num,npx,npy,nregions,grid_type,nested,layout,io_layout,bd,tile,square_domain,& - npes_per_tile,domain,domain_for_coupler,num_contact,pelist) + npes_per_tile,domain,domain_for_coupler,domain_for_read,num_contact,pelist) integer, intent(IN) :: grid_num integer, intent(IN) :: npx,npy,grid_type @@ -303,8 +297,9 @@ subroutine domain_decomp(grid_num,npx,npy,nregions,grid_type,nested,layout,io_la integer, intent(INOUT) :: pelist(:) integer, intent(OUT) :: num_contact, npes_per_tile logical, intent(OUT) :: square_domain - type(domain2D), intent(OUT) :: domain, domain_for_coupler + type(domain2D), intent(OUT) :: domain, domain_for_coupler, domain_for_read type(fv_grid_bounds_type), intent(INOUT) :: bd + integer :: l_layout(2) nx = npx-1 ny = npy-1 @@ -568,6 +563,17 @@ subroutine domain_decomp(grid_num,npx,npy,nregions,grid_type,nested,layout,io_la call mpp_define_io_domain(domain, io_layout) call mpp_define_io_domain(domain_for_coupler, io_layout) + !--- create a read domain that can be used to improve read performance + !--- if io_layout=(1,1) then read io_layout=layout (all read) + !--- if io_layout\=(1,1) then read io_layout=io_layout (no change) + l_layout = mpp_get_io_domain_layout(domain) + call mpp_copy_domain(domain, domain_for_read) + if (ALL(l_layout == 1)) then + call mpp_get_layout(domain, l_layout) + call mpp_define_io_domain(domain_for_read, l_layout) + else + call mpp_define_io_domain(domain_for_read, l_layout) + endif endif deallocate(pe_start,pe_end) @@ -1463,7 +1469,6 @@ subroutine mp_gather_4d_r4(q, i1,i2, j1,j2, idim, jdim, kdim, ldim) Ldispl(l) = 5*(l-1) enddo call mpp_gather(Ldims, Gdims) -! call MPI_GATHERV(Ldims, 5, MPI_INTEGER, Gdims, cnts, Ldispl, MPI_INTEGER, masterproc, commglobal, ierror) Lsize = ( (i2 - i1 + 1) * (j2 - j1 + 1) ) * kdim do l=1,npes_this_grid @@ -1473,7 +1478,6 @@ subroutine mp_gather_4d_r4(q, i1,i2, j1,j2, idim, jdim, kdim, ldim) LsizeS(:)=1 Lsize_buf(1) = Lsize call mpp_gather(Lsize_buf, LsizeS) -! call MPI_GATHERV(Lsize, 1, MPI_INTEGER, LsizeS, cnts, Ldispl, MPI_INTEGER, masterproc, commglobal, ierror) allocate ( larr(Lsize) ) icnt = 1 @@ -1486,18 +1490,15 @@ subroutine mp_gather_4d_r4(q, i1,i2, j1,j2, idim, jdim, kdim, ldim) enddo enddo Ldispl(1) = 0.0 -! call mp_bcst(LsizeS(1)) call mpp_broadcast(LsizeS, npes_this_grid, masterproc) Gsize = LsizeS(1) do l=2,npes_this_grid -! call mp_bcst(LsizeS(l)) Ldispl(l) = Ldispl(l-1) + LsizeS(l-1) Gsize = Gsize + LsizeS(l) enddo allocate ( garr(Gsize) ) call mpp_gather(larr, Lsize, garr, LsizeS) -! call MPI_GATHERV(larr, Lsize, MPI_REAL, garr, LsizeS, Ldispl, MPI_REAL, masterproc, commglobal, ierror) if (gid==masterproc) then do n=2,npes_this_grid @@ -1548,7 +1549,6 @@ subroutine mp_gather_3d_r4(q, i1,i2, j1,j2, idim, jdim, ldim) cnts(l) = 5 Ldispl(l) = 5*(l-1) enddo -! call MPI_GATHERV(Ldims, 5, MPI_INTEGER, Gdims, cnts, Ldispl, MPI_INTEGER, masterproc, commglobal, ierror) call mpp_gather(Ldims, Gdims) Lsize = ( (i2 - i1 + 1) * (j2 - j1 + 1) ) @@ -1559,7 +1559,6 @@ subroutine mp_gather_3d_r4(q, i1,i2, j1,j2, idim, jdim, ldim) LsizeS(:)=1 Lsize_buf(1) = Lsize call mpp_gather(Lsize_buf, LsizeS) -! call MPI_GATHERV(Lsize, 1, MPI_INTEGER, LsizeS, cnts, Ldispl, MPI_INTEGER, masterproc, commglobal, ierror) allocate ( larr(Lsize) ) icnt = 1 @@ -1570,17 +1569,14 @@ subroutine mp_gather_3d_r4(q, i1,i2, j1,j2, idim, jdim, ldim) enddo enddo Ldispl(1) = 0.0 -! call mp_bcst(LsizeS(1)) call mpp_broadcast(LsizeS, npes_this_grid, masterproc) Gsize = LsizeS(1) do l=2,npes_this_grid -! call mp_bcst(LsizeS(l)) Ldispl(l) = Ldispl(l-1) + LsizeS(l-1) Gsize = Gsize + LsizeS(l) enddo allocate ( garr(Gsize) ) call mpp_gather(larr, Lsize, garr, LsizeS) -! call MPI_GATHERV(larr, Lsize, MPI_REAL, garr, LsizeS, Ldispl, MPI_REAL, masterproc, commglobal, ierror) if (gid==masterproc) then do n=2,npes_this_grid icnt=1 @@ -1636,7 +1632,6 @@ subroutine mp_gather_3d_r8(q, i1,i2, j1,j2, idim, jdim, ldim) enddo LsizeS(:)=0. -! call MPI_GATHERV(Lsize, 1, MPI_INTEGER, LsizeS, cnts, Ldispl, MPI_INTEGER, masterproc, commglobal, ierror) Lsize_buf(1) = Lsize call mpp_gather(Lsize_buf, LsizeS) @@ -1650,17 +1645,14 @@ subroutine mp_gather_3d_r8(q, i1,i2, j1,j2, idim, jdim, ldim) enddo Ldispl(1) = 0.0 call mpp_broadcast(LsizeS, npes_this_grid, masterproc) -! call mp_bcst(LsizeS(1)) Gsize = LsizeS(1) do l=2,npes_this_grid -! call mp_bcst(LsizeS(l)) Ldispl(l) = Ldispl(l-1) + LsizeS(l-1) Gsize = Gsize + LsizeS(l) enddo allocate ( garr(Gsize) ) call mpp_gather(larr, Lsize, garr, LsizeS) -! call MPI_GATHERV(larr, Lsize, MPI_DOUBLE_PRECISION, garr, LsizeS, Ldispl, MPI_DOUBLE_PRECISION, masterproc, commglobal, ierror) if (gid==masterproc) then do n=2,npes_this_grid icnt=1 @@ -1682,147 +1674,6 @@ end subroutine mp_gather_3d_r8 ! ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ! !------------------------------------------------------------------------------- -!------------------------------------------------------------------------------- -! vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv ! -! -! mp_bcst_i4 :: Call SPMD broadcast -! - subroutine mp_bcst_i4(q) - integer, intent(INOUT) :: q - - call MPI_BCAST(q, 1, MPI_INTEGER, masterproc, commglobal, ierror) - - end subroutine mp_bcst_i4 -! -! ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ! -!------------------------------------------------------------------------------- - -!------------------------------------------------------------------------------- -! vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv ! -! -! mp_bcst_r4 :: Call SPMD broadcast -! - subroutine mp_bcst_r4(q) - real(kind=4), intent(INOUT) :: q - - call MPI_BCAST(q, 1, MPI_REAL, masterproc, commglobal, ierror) - - end subroutine mp_bcst_r4 -! -! ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ! -!------------------------------------------------------------------------------- - -!------------------------------------------------------------------------------- -! vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv ! -! -! mp_bcst_r8 :: Call SPMD broadcast -! - subroutine mp_bcst_r8(q) - real(kind=8), intent(INOUT) :: q - - call MPI_BCAST(q, 1, MPI_DOUBLE_PRECISION, masterproc, commglobal, ierror) - - end subroutine mp_bcst_r8 -! -! ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ! -!------------------------------------------------------------------------------- - -!------------------------------------------------------------------------------- -! vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv ! -! -! mp_bcst_3d_r4 :: Call SPMD broadcast -! - subroutine mp_bcst_3d_r4(q, idim, jdim, kdim) - integer, intent(IN) :: idim, jdim, kdim - real(kind=4), intent(INOUT) :: q(idim,jdim,kdim) - - call MPI_BCAST(q, idim*jdim*kdim, MPI_REAL, masterproc, commglobal, ierror) - - end subroutine mp_bcst_3d_r4 -! -! ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ! -!------------------------------------------------------------------------------- - -!------------------------------------------------------------------------------- -! vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv ! -! -! mp_bcst_3d_r8 :: Call SPMD broadcast -! - subroutine mp_bcst_3d_r8(q, idim, jdim, kdim) - integer, intent(IN) :: idim, jdim, kdim - real(kind=8), intent(INOUT) :: q(idim,jdim,kdim) - - call MPI_BCAST(q, idim*jdim*kdim, MPI_DOUBLE_PRECISION, masterproc, commglobal, ierror) - - end subroutine mp_bcst_3d_r8 -! -! ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ! -!------------------------------------------------------------------------------- - -!------------------------------------------------------------------------------- -! vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv ! -! -! mp_bcst_4d_r4 :: Call SPMD broadcast -! - subroutine mp_bcst_4d_r4(q, idim, jdim, kdim, ldim) - integer, intent(IN) :: idim, jdim, kdim, ldim - real(kind=4), intent(INOUT) :: q(idim,jdim,kdim,ldim) - - call MPI_BCAST(q, idim*jdim*kdim*ldim, MPI_REAL, masterproc, commglobal, ierror) - - end subroutine mp_bcst_4d_r4 -! -! ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ! -!------------------------------------------------------------------------------- - -!------------------------------------------------------------------------------- -! vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv ! -! -! mp_bcst_4d_r8 :: Call SPMD broadcast -! - subroutine mp_bcst_4d_r8(q, idim, jdim, kdim, ldim) - integer, intent(IN) :: idim, jdim, kdim, ldim - real(kind=8), intent(INOUT) :: q(idim,jdim,kdim,ldim) - - call MPI_BCAST(q, idim*jdim*kdim*ldim, MPI_DOUBLE_PRECISION, masterproc, commglobal, ierror) - - end subroutine mp_bcst_4d_r8 -! -! ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ! -!------------------------------------------------------------------------------- - -!------------------------------------------------------------------------------- -! vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv ! -! -! mp_bcst_3d_i8 :: Call SPMD broadcast -! - subroutine mp_bcst_3d_i8(q, idim, jdim, kdim) - integer, intent(IN) :: idim, jdim, kdim - integer, intent(INOUT) :: q(idim,jdim,kdim) - - call MPI_BCAST(q, idim*jdim*kdim, MPI_INTEGER, masterproc, commglobal, ierror) - - end subroutine mp_bcst_3d_i8 -! -! ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ! -!------------------------------------------------------------------------------- - -!------------------------------------------------------------------------------- -! vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv ! -! -! mp_bcst_4d_i8 :: Call SPMD broadcast -! - subroutine mp_bcst_4d_i8(q, idim, jdim, kdim, ldim) - integer, intent(IN) :: idim, jdim, kdim, ldim - integer, intent(INOUT) :: q(idim,jdim,kdim,ldim) - - call MPI_BCAST(q, idim*jdim*kdim*ldim, MPI_INTEGER, masterproc, commglobal, ierror) - - end subroutine mp_bcst_4d_i8 -! -! ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ! -!------------------------------------------------------------------------------- - !------------------------------------------------------------------------------- ! vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv ! @@ -1835,10 +1686,11 @@ subroutine mp_reduce_max_r4_1d(mymax,npts) real(kind=4) :: gmax(npts) - call MPI_ALLREDUCE( mymax, gmax, npts, MPI_REAL, MPI_MAX, & - commglobal, ierror ) - - mymax = gmax + call mpp_max (mymax, npts) +! call MPI_ALLREDUCE( mymax, gmax, npts, MPI_REAL, MPI_MAX, & +! commglobal, ierror ) +! +! mymax = gmax end subroutine mp_reduce_max_r4_1d ! @@ -1857,10 +1709,11 @@ subroutine mp_reduce_max_r8_1d(mymax,npts) real(kind=8) :: gmax(npts) - call MPI_ALLREDUCE( mymax, gmax, npts, MPI_DOUBLE_PRECISION, MPI_MAX, & - commglobal, ierror ) - - mymax = gmax + call mpp_max (mymax, npts) +! call MPI_ALLREDUCE( mymax, gmax, npts, MPI_DOUBLE_PRECISION, MPI_MAX, & +! commglobal, ierror ) +! +! mymax = gmax end subroutine mp_reduce_max_r8_1d ! @@ -1878,10 +1731,11 @@ subroutine mp_reduce_max_r4(mymax) real(kind=4) :: gmax - call MPI_ALLREDUCE( mymax, gmax, 1, MPI_REAL, MPI_MAX, & - commglobal, ierror ) - - mymax = gmax + call mpp_max (mymax) +! call MPI_ALLREDUCE( mymax, gmax, 1, MPI_REAL, MPI_MAX, & +! commglobal, ierror ) +! +! mymax = gmax end subroutine mp_reduce_max_r4 @@ -1895,10 +1749,11 @@ subroutine mp_reduce_max_r8(mymax) real(kind=8) :: gmax - call MPI_ALLREDUCE( mymax, gmax, 1, MPI_DOUBLE_PRECISION, MPI_MAX, & - commglobal, ierror ) - - mymax = gmax + call mpp_max (mymax) +! call MPI_ALLREDUCE( mymax, gmax, 1, MPI_DOUBLE_PRECISION, MPI_MAX, & +! commglobal, ierror ) +! +! mymax = gmax end subroutine mp_reduce_max_r8 @@ -1907,10 +1762,11 @@ subroutine mp_reduce_min_r4(mymin) real(kind=4) :: gmin - call MPI_ALLREDUCE( mymin, gmin, 1, MPI_REAL, MPI_MIN, & - commglobal, ierror ) - - mymin = gmin + call mpp_min (mymin) +! call MPI_ALLREDUCE( mymin, gmin, 1, MPI_REAL, MPI_MIN, & +! commglobal, ierror ) +! +! mymin = gmin end subroutine mp_reduce_min_r4 @@ -1919,10 +1775,11 @@ subroutine mp_reduce_min_r8(mymin) real(kind=8) :: gmin - call MPI_ALLREDUCE( mymin, gmin, 1, MPI_DOUBLE_PRECISION, MPI_MIN, & - commglobal, ierror ) - - mymin = gmin + call mpp_min (mymin) +! call MPI_ALLREDUCE( mymin, gmin, 1, MPI_DOUBLE_PRECISION, MPI_MIN, & +! commglobal, ierror ) +! +! mymin = gmin end subroutine mp_reduce_min_r8 ! @@ -1932,17 +1789,18 @@ end subroutine mp_reduce_min_r8 !------------------------------------------------------------------------------- ! vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv ! ! -! mp_bcst_4d_i4 :: Call SPMD REDUCE_MAX +! mp_reduce_max_i4 :: Call SPMD REDUCE_MAX ! subroutine mp_reduce_max_i4(mymax) integer, intent(INOUT) :: mymax integer :: gmax - call MPI_ALLREDUCE( mymax, gmax, 1, MPI_INTEGER, MPI_MAX, & - commglobal, ierror ) - - mymax = gmax + call mpp_max(mymax) +! call MPI_ALLREDUCE( mymax, gmax, 1, MPI_INTEGER, MPI_MAX, & +! commglobal, ierror ) +! +! mymax = gmax end subroutine mp_reduce_max_i4 ! @@ -1959,10 +1817,11 @@ subroutine mp_reduce_sum_r4(mysum) real(kind=4) :: gsum - call MPI_ALLREDUCE( mysum, gsum, 1, MPI_REAL, MPI_SUM, & - commglobal, ierror ) - - mysum = gsum + call mpp_sum(mysum) +! call MPI_ALLREDUCE( mysum, gsum, 1, MPI_REAL, MPI_SUM, & +! commglobal, ierror ) +! +! mysum = gsum end subroutine mp_reduce_sum_r4 ! @@ -1979,10 +1838,11 @@ subroutine mp_reduce_sum_r8(mysum) real(kind=8) :: gsum - call MPI_ALLREDUCE( mysum, gsum, 1, MPI_DOUBLE_PRECISION, MPI_SUM, & - commglobal, ierror ) - - mysum = gsum + call mpp_sum (mysum) +! call MPI_ALLREDUCE( mysum, gsum, 1, MPI_DOUBLE_PRECISION, MPI_SUM, & +! commglobal, ierror ) +! +! mysum = gsum end subroutine mp_reduce_sum_r8 ! @@ -2007,10 +1867,11 @@ subroutine mp_reduce_sum_r4_1d(mysum, sum1d, npts) mysum = mysum + sum1d(i) enddo - call MPI_ALLREDUCE( mysum, gsum, 1, MPI_DOUBLE_PRECISION, MPI_SUM, & - commglobal, ierror ) - - mysum = gsum + call mpp_sum (mysum) +! call MPI_ALLREDUCE( mysum, gsum, 1, MPI_DOUBLE_PRECISION, MPI_SUM, & +! commglobal, ierror ) +! +! mysum = gsum end subroutine mp_reduce_sum_r4_1d ! @@ -2035,15 +1896,107 @@ subroutine mp_reduce_sum_r8_1d(mysum, sum1d, npts) mysum = mysum + sum1d(i) enddo - call MPI_ALLREDUCE( mysum, gsum, 1, MPI_DOUBLE_PRECISION, MPI_SUM, & - commglobal, ierror ) - - mysum = gsum + call mpp_sum (mysum) +! call MPI_ALLREDUCE( mysum, gsum, 1, MPI_DOUBLE_PRECISION, MPI_SUM, & +! commglobal, ierror ) +! +! mysum = gsum end subroutine mp_reduce_sum_r8_1d ! ! ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ! !------------------------------------------------------------------------------- + +!------------------------------------------------------------------------------- +! vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv ! +! +! mp_reduce_sum_r4_1darr :: Call SPMD REDUCE_SUM +! + subroutine mp_reduce_sum_r4_1darr(mysum, npts) + integer, intent(in) :: npts + real(kind=4), intent(inout) :: mysum(npts) + real(kind=4) :: gsum(npts) + + call mpp_sum (mysum, npts) +! gsum = 0.0 +! call MPI_ALLREDUCE( mysum, gsum, npts, MPI_REAL, MPI_SUM, & +! commglobal, ierror ) +! +! mysum = gsum + + end subroutine mp_reduce_sum_r4_1darr +! +! ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ! +!------------------------------------------------------------------------------- + +!------------------------------------------------------------------------------- +! vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv ! +! +! mp_reduce_sum_r4_2darr :: Call SPMD REDUCE_SUM +! + subroutine mp_reduce_sum_r4_2darr(mysum, npts1,npts2) + integer, intent(in) :: npts1,npts2 + real(kind=4), intent(inout) :: mysum(npts1,npts2) + real(kind=4) :: gsum(npts1,npts2) + + call mpp_sum (mysum, npts1*npts2) +! gsum = 0.0 +! call MPI_ALLREDUCE( mysum, gsum, npts1*npts2, MPI_REAL, MPI_SUM, & +! commglobal, ierror ) +! +! mysum = gsum + + end subroutine mp_reduce_sum_r4_2darr +! +! ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ! +!------------------------------------------------------------------------------- + +!------------------------------------------------------------------------------- +! vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv ! +! +! mp_reduce_sum_r8_1darr :: Call SPMD REDUCE_SUM +! + subroutine mp_reduce_sum_r8_1darr(mysum, npts) + integer, intent(in) :: npts + real(kind=8), intent(inout) :: mysum(npts) + real(kind=8) :: gsum(npts) + + call mpp_sum (mysum, npts) +! gsum = 0.0 +! call MPI_ALLREDUCE( mysum, gsum, npts, MPI_DOUBLE_PRECISION, & +! MPI_SUM, & +! commglobal, ierror ) +! +! mysum = gsum + + end subroutine mp_reduce_sum_r8_1darr +! +! ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ! +!------------------------------------------------------------------------------- + +!------------------------------------------------------------------------------- +! vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv ! +! +! mp_reduce_sum_r8_2darr :: Call SPMD REDUCE_SUM +! + subroutine mp_reduce_sum_r8_2darr(mysum, npts1,npts2) + integer, intent(in) :: npts1,npts2 + real(kind=8), intent(inout) :: mysum(npts1,npts2) + real(kind=8) :: gsum(npts1,npts2) + + call mpp_sum (mysum, npts1*npts2) +! gsum = 0.0 +! call MPI_ALLREDUCE( mysum, gsum, npts1*npts2, & +! MPI_DOUBLE_PRECISION, MPI_SUM, & +! commglobal, ierror ) +! +! mysum = gsum + + end subroutine mp_reduce_sum_r8_2darr +! +! ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ! +!------------------------------------------------------------------------------- + #else implicit none private diff --git a/tools/fv_nggps_diag.F90 b/tools/fv_nggps_diag.F90 index 8e68b2e44..63b086699 100644 --- a/tools/fv_nggps_diag.F90 +++ b/tools/fv_nggps_diag.F90 @@ -11,7 +11,7 @@ !* (at your option) any later version. !* !* The FV3 dynamical core is distributed in the hope that it will be -!* useful, but WITHOUT ANYWARRANTY; without even the implied warranty +!* useful, but WITHOUT ANY WARRANTY; without even the implied warranty !* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. !* See the GNU General Public License for more details. !* @@ -71,11 +71,12 @@ module fv_nggps_diags_mod use diag_util_mod, only: find_input_field use tracer_manager_mod, only: get_tracer_names, get_number_tracers, get_tracer_index use field_manager_mod, only: MODEL_ATMOS - use fv_diagnostics_mod, only: range_check, dbzcalc,max_vv,get_vorticity, & - max_uh,max_vorticity,bunkers_vector, & - helicity_relative_CAPS,max_vorticity_hy1 + use fv_diagnostics_mod, only: range_check, max_vv, get_vorticity, & + max_uh, bunkers_vector, helicity_relative_CAPS use fv_arrays_mod, only: fv_atmos_type use mpp_domains_mod, only: domain1d, domainUG + use rad_ref_mod, only: rad_ref + use fv_eta_mod, only: get_eta_level #ifdef MULTI_GASES use multi_gases_mod, only: virq #endif @@ -107,6 +108,7 @@ module fv_nggps_diags_mod integer :: id_maxvort02,kstt_maxvort02,kend_maxvort02 integer :: isco, ieco, jsco, jeco, npzo, ncnsto integer :: isdo, iedo, jsdo, jedo + integer :: mp_top integer :: nlevs logical :: hydrostatico integer, allocatable :: id_tracer(:), all_axes(:) @@ -149,7 +151,9 @@ subroutine fv_nggps_diag_init(Atm, axes, Time) type(fv_atmos_type), intent(inout), target :: Atm(:) integer, intent(in) :: axes(4) type(time_type), intent(in) :: Time + integer :: n, i, j, nz + real, allocatable, dimension(:) :: pfull, phalf n = 1 ncnsto = Atm(1)%ncnst @@ -168,6 +172,20 @@ subroutine fv_nggps_diag_init(Atm, axes, Time) snowwat = get_tracer_index (MODEL_ATMOS, 'snowwat') graupel = get_tracer_index (MODEL_ATMOS, 'graupel') + allocate ( pfull(npzo) ) + allocate ( phalf(npzo+1) ) + call get_eta_level(Atm(1)%npz, Atm(1)%flagstruct%p_ref, pfull, phalf, Atm(1)%ak, Atm(1)%bk, 0.01) + + mp_top = 1 + do i=1,npzo + if ( pfull(i) > 30.e2 ) then + mp_top = i + exit + endif + enddo + deallocate (phalf) + deallocate (pfull) + !-------------------------------------------------------------- ! Register main prognostic fields: ps, (u,v), t, omega (dp/dt) !-------------------------------------------------------------- @@ -639,9 +657,10 @@ subroutine fv_nggps_diag(Atm, zvir, Time) !--- 3-D Reflectivity field if ( rainwat > 0 .and. id_dbz>0) then - call dbzcalc(Atm(n)%q, Atm(n)%pt, Atm(n)%delp, Atm(n)%peln, Atm(n)%delz, & + call rad_ref(Atm(n)%q, Atm(n)%pt, Atm(n)%delp, Atm(n)%peln, Atm(n)%delz, & wk, wk2, allmax, Atm(n)%bd, npzo, Atm(n)%ncnst, Atm(n)%flagstruct%hydrostatic, & - zvir, .false., .false., .false., .true., Atm(n)%flagstruct%do_inline_mp ) ! GFDL MP has constant N_0 intercept + zvir, .false., .false., .false., .true., Atm(n)%flagstruct%do_inline_mp, & + sphum, liq_wat, ice_wat, rainwat, snowwat, graupel, mp_top) ! GFDL MP has constant N_0 intercept call store_data(id_dbz, wk, Time, kstt_dbz, kend_dbz) endif @@ -819,6 +838,75 @@ subroutine fv_nggps_tavg(Atm, Time_step_atmos,avg_max_length,zvir) endif endif end subroutine fv_nggps_tavg +! + subroutine max_vorticity_hy1(is, ie, js, je, km, vort, maxvorthy1) + integer, intent(in):: is, ie, js, je, km + real, intent(in), dimension(is:ie,js:je,km):: vort + real, intent(inout), dimension(is:ie,js:je):: maxvorthy1 + integer i, j, k + + do j=js,je + do i=is,ie + maxvorthy1(i,j)=max(maxvorthy1(i,j),vort(i,j,km)) + enddo ! i-loop + enddo ! j-loop + end subroutine max_vorticity_hy1 +! + subroutine max_vorticity(is, ie, js, je, ng, km, zvir, sphum, delz, q, hydrostatic, & + pt, peln, phis, grav, vort, maxvort, z_bot, z_top) + integer, intent(in):: is, ie, js, je, ng, km, sphum + real, intent(in):: grav, zvir, z_bot, z_top + real, intent(in), dimension(is-ng:ie+ng,js-ng:je+ng,km):: pt + real, intent(in), dimension(is:ie,js:je,km):: vort + real, intent(in):: delz(is:ie,js:je,km) + real, intent(in):: q(is-ng:ie+ng,js-ng:je+ng,km,*) + real, intent(in):: phis(is-ng:ie+ng,js-ng:je+ng) + real, intent(in):: peln(is:ie,km+1,js:je) + logical, intent(in):: hydrostatic + real, intent(inout), dimension(is:ie,js:je):: maxvort + + real:: rdg + real, dimension(is:ie):: zh, dz, zh0 + integer i, j, k,klevel + logical below(is:ie) + + rdg = rdgas / grav + + do j=js,je + + do i=is,ie + zh(i) = 0. + below(i) = .true. + zh0(i) = 0. + + K_LOOP:do k=km,1,-1 + if ( hydrostatic ) then +#ifdef MULTI_GASES + dz(i) = rdg*pt(i,j,k)*virq(q(i,j,k,1:num_gas))*(peln(i,k+1,j)-peln(i,k,j)) +#else + dz(i) = rdg*pt(i,j,k)*(1.+zvir*q(i,j,k,sphum))*(peln(i,k+1,j)-peln(i,k,j)) +#endif + else + dz(i) = - delz(i,j,k) + endif + zh(i) = zh(i) + dz(i) + if (zh(i) <= z_bot ) continue + if (zh(i) > z_bot .and. below(i)) then + maxvort(i,j) = max(maxvort(i,j),vort(i,j,k)) + below(i) = .false. + elseif ( zh(i) < z_top ) then + maxvort(i,j) = max(maxvort(i,j),vort(i,j,k)) + else + maxvort(i,j) = max(maxvort(i,j),vort(i,j,k)) + EXIT K_LOOP + endif + enddo K_LOOP +! maxvorthy1(i,j)=max(maxvorthy1(i,j),vort(i,j,km)) + enddo ! i-loop + enddo ! j-loop + + + end subroutine max_vorticity ! subroutine store_data(id, work, Time, nstt, nend) integer, intent(in) :: id diff --git a/tools/fv_nudge.F90 b/tools/fv_nudge.F90 index bbc948662..fb492203d 100644 --- a/tools/fv_nudge.F90 +++ b/tools/fv_nudge.F90 @@ -10,7 +10,7 @@ !* (at your option) any later version. !* !* The FV3 dynamical core is distributed in the hope that it will be -!* useful, but WITHOUT ANYWARRANTY; without even the implied warranty +!* useful, but WITHOUT ANY WARRANTY; without even the implied warranty !* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. !* See the GNU General Public License for more details. !* @@ -18,6 +18,7 @@ !* License along with the FV3 dynamical core. !* If not, see . !*********************************************************************** + #ifdef OVERLOAD_R4 #define _GET_VAR1 get_var1_real #else @@ -228,7 +229,7 @@ module fv_nwp_nudge_mod contains - subroutine fv_nwp_nudge ( Time, dt, npx, npy, npz, ps_dt, u_dt, v_dt, t_dt, q_dt, zvir, ptop, & + subroutine fv_nwp_nudge ( Time, dt, npx, npy, npz, ps_dt, u_dt, v_dt, t_dt, q_dt, zvir, & ak, bk, ts, ps, delp, ua, va, pt, nwat, q, phis, gridstruct, & bd, domain ) @@ -237,7 +238,7 @@ subroutine fv_nwp_nudge ( Time, dt, npx, npy, npz, ps_dt, u_dt, v_dt, t_dt, q_dt integer, intent(in):: npz ! vertical dimension integer, intent(in):: nwat real, intent(in):: dt - real, intent(in):: zvir, ptop + real, intent(in):: zvir type(domain2d), intent(INOUT), target :: domain type(fv_grid_bounds_type), intent(IN) :: bd real, intent(in ), dimension(npz+1):: ak, bk @@ -435,7 +436,7 @@ subroutine fv_nwp_nudge ( Time, dt, npx, npy, npz, ps_dt, u_dt, v_dt, t_dt, q_dt call get_obs(Time, dt, zvir, ak, bk, ps, ts, ps_obs, delp, pt, nwat, q, u_obs, v_obs, t_obs, q_obs, & - phis, ua, va, u_dt, v_dt, npx, npy, npz, factor, factor_nwp, mask, ptop, bd, gridstruct, domain) + phis, ua, va, u_dt, v_dt, npx, npy, npz, factor, factor_nwp, mask, bd, gridstruct, domain) ! *t_obs* is virtual temperature if ( no_obs ) then @@ -1030,10 +1031,10 @@ end subroutine compute_slp subroutine get_obs(Time, dt, zvir, ak, bk, ps, ts, ps_obs, delp, pt, nwat, q, u_obs, v_obs, t_obs, q_obs, & - phis, ua, va, u_dt, v_dt, npx, npy, npz, factor, factor_nwp, mask, ptop, bd, gridstruct, domain) + phis, ua, va, u_dt, v_dt, npx, npy, npz, factor, factor_nwp, mask, bd, gridstruct, domain) type(time_type), intent(in):: Time integer, intent(in):: npz, nwat, npx, npy - real, intent(in):: zvir, ptop + real, intent(in):: zvir real, intent(in):: dt, factor, factor_nwp real, intent(in), dimension(npz+1):: ak, bk type(fv_grid_bounds_type), intent(IN) :: bd @@ -1161,26 +1162,26 @@ subroutine get_obs(Time, dt, zvir, ak, bk, ps, ts, ps_obs, delp, pt, nwat, q, u_ if ( nudge_winds ) then call remap_uv(npz, ak, bk, ps(is:ie,js:je), delp, ut, vt, & - km, ps_dat(is:ie,js:je,1), u_dat(:,:,:,1), v_dat(:,:,:,1), ptop ) + km, ps_dat(is:ie,js:je,1), u_dat(:,:,:,1), v_dat(:,:,:,1) ) u_obs(:,:,:) = alpha*ut(:,:,:) v_obs(:,:,:) = alpha*vt(:,:,:) call remap_uv(npz, ak, bk, ps(is:ie,js:je), delp, ut, vt, & - km, ps_dat(is:ie,js:je,2), u_dat(:,:,:,2), v_dat(:,:,:,2), ptop ) + km, ps_dat(is:ie,js:je,2), u_dat(:,:,:,2), v_dat(:,:,:,2) ) u_obs(:,:,:) = u_obs(:,:,:) + beta*ut(:,:,:) v_obs(:,:,:) = v_obs(:,:,:) + beta*vt(:,:,:) endif call remap_tq(npz, ak, bk, ps(is:ie,js:je), delp, ut, vt, & - km, ps_dat(is:ie,js:je,1), t_dat(:,:,:,1), q_dat(:,:,:,1), zvir, ptop) + km, ps_dat(is:ie,js:je,1), t_dat(:,:,:,1), q_dat(:,:,:,1), zvir) t_obs(:,:,:) = alpha*ut(:,:,:) q_obs(:,:,:) = alpha*vt(:,:,:) call remap_tq(npz, ak, bk, ps(is:ie,js:je), delp, ut, vt, & - km, ps_dat(is:ie,js:je,2), t_dat(:,:,:,2), q_dat(:,:,:,2), zvir, ptop) + km, ps_dat(is:ie,js:je,2), t_dat(:,:,:,2), q_dat(:,:,:,2), zvir) t_obs(:,:,:) = t_obs(:,:,:) + beta*ut(:,:,:) q_obs(:,:,:) = q_obs(:,:,:) + beta*vt(:,:,:) @@ -1866,9 +1867,9 @@ end subroutine get_int_hght subroutine remap_tq( npz, ak, bk, ps, delp, t, q, & - kmd, ps0, ta, qa, zvir, ptop) + kmd, ps0, ta, qa, zvir) integer, intent(in):: npz, kmd - real, intent(in):: zvir, ptop + real, intent(in):: zvir real, intent(in):: ak(npz+1), bk(npz+1) real, intent(in), dimension(is:ie,js:je):: ps0 real, intent(inout), dimension(is:ie,js:je):: ps @@ -1919,7 +1920,7 @@ subroutine remap_tq( npz, ak, bk, ps, delp, t, q, & qp(i,k) = qa(i,j,k) enddo enddo - call mappm(kmd, pe0, qp, npz, pe1, qn1, is,ie, 0, kord_data, ptop) + call mappm(kmd, pe0, qp, npz, pe1, qn1, is,ie, 0, kord_data) do k=1,npz do i=is,ie q(i,j,k) = qn1(i,k) @@ -1932,7 +1933,7 @@ subroutine remap_tq( npz, ak, bk, ps, delp, t, q, & tp(i,k) = ta(i,j,k) enddo enddo - call mappm(kmd, pn0, tp, npz, pn1, qn1, is,ie, 1, kord_data, ptop) + call mappm(kmd, pn0, tp, npz, pn1, qn1, is,ie, 1, kord_data) do k=1,npz do i=is,ie @@ -1945,9 +1946,8 @@ subroutine remap_tq( npz, ak, bk, ps, delp, t, q, & end subroutine remap_tq - subroutine remap_uv(npz, ak, bk, ps, delp, u, v, kmd, ps0, u0, v0, ptop) + subroutine remap_uv(npz, ak, bk, ps, delp, u, v, kmd, ps0, u0, v0) integer, intent(in):: npz - real, intent(IN):: ptop real, intent(in):: ak(npz+1), bk(npz+1) real, intent(inout):: ps(is:ie,js:je) real, intent(in), dimension(isd:ied,jsd:jed,npz):: delp @@ -1995,7 +1995,7 @@ subroutine remap_uv(npz, ak, bk, ps, delp, u, v, kmd, ps0, u0, v0, ptop) qt(i,k) = u0(i,j,k) enddo enddo - call mappm(kmd, pe0, qt, npz, pe1, qn1, is,ie, -1, kord_data, ptop) + call mappm(kmd, pe0, qt, npz, pe1, qn1, is,ie, -1, kord_data) do k=1,npz do i=is,ie u(i,j,k) = qn1(i,k) @@ -2009,7 +2009,7 @@ subroutine remap_uv(npz, ak, bk, ps, delp, u, v, kmd, ps0, u0, v0, ptop) qt(i,k) = v0(i,j,k) enddo enddo - call mappm(kmd, pe0, qt, npz, pe1, qn1, is,ie, -1, kord_data, ptop) + call mappm(kmd, pe0, qt, npz, pe1, qn1, is,ie, -1, kord_data) do k=1,npz do i=is,ie v(i,j,k) = qn1(i,k) diff --git a/tools/fv_restart.F90 b/tools/fv_restart.F90 index 73bbd6f4f..363d30d26 100644 --- a/tools/fv_restart.F90 +++ b/tools/fv_restart.F90 @@ -10,7 +10,7 @@ !* (at your option) any later version. !* !* The FV3 dynamical core is distributed in the hope that it will be -!* useful, but WITHOUT ANYWARRANTY; without even the implied warranty +!* useful, but WITHOUT ANY WARRANTY; without even the implied warranty !* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. !* See the GNU General Public License for more details. !* @@ -18,6 +18,7 @@ !* License along with the FV3 dynamical core. !* If not, see . !*********************************************************************** + module fv_restart_mod ! @@ -29,38 +30,37 @@ module fv_restart_mod ! for the model. ! - use constants_mod, only: kappa, pi=>pi_8, omega, rdgas, grav, rvgas, cp_air, radius + use constants_mod, only: kappa, pi=>pi_8, rdgas, grav, rvgas, cp_air + use fv_arrays_mod, only: radius, omega ! scaled for small earth use fv_arrays_mod, only: fv_atmos_type, fv_nest_type, fv_grid_bounds_type, R_GRID use fv_io_mod, only: fv_io_init, fv_io_read_restart, fv_io_write_restart, & - remap_restart, fv_io_register_nudge_restart, & - fv_io_register_restart_BCs, fv_io_write_BCs, fv_io_read_BCs + remap_restart, fv_io_write_BCs, fv_io_read_BCs use fv_grid_utils_mod, only: ptop_min, fill_ghost, g_sum, & make_eta_level, cubed_to_latlon, great_circle_dist use fv_diagnostics_mod, only: prt_maxmin use init_hydro_mod, only: p_var use mpp_domains_mod, only: mpp_update_domains, domain2d, DGRID_NE + use mpp_domains_mod, only: mpp_get_compute_domain, mpp_get_data_domain, mpp_get_global_domain + use mpp_domains_mod, only: CENTER, CORNER, NORTH, EAST, mpp_get_C2F_index, WEST, SOUTH + use mpp_domains_mod, only: mpp_global_field use mpp_mod, only: mpp_chksum, stdout, mpp_error, FATAL, NOTE - use mpp_mod, only: get_unit, mpp_sum, mpp_broadcast, mpp_max, mpp_npes + use mpp_mod, only: get_unit, mpp_sum, mpp_broadcast, mpp_max use mpp_mod, only: mpp_get_current_pelist, mpp_npes, mpp_set_current_pelist + use mpp_mod, only: mpp_send, mpp_recv, mpp_sync_self, mpp_pe, mpp_sync + use fms2_io_mod, only: file_exists, set_filename_appendix, FmsNetcdfFile_t, open_file, close_file + use fms_io_mod, only: fmsset_filename_appendix=> set_filename_appendix use test_cases_mod, only: alpha, init_case, init_double_periodic!, init_latlon use fv_mp_mod, only: is_master, mp_reduce_min, mp_reduce_max, corners_YDir => YDir, fill_corners, tile_fine, global_nest_domain use fv_surf_map_mod, only: sgh_g, oro_g - use tracer_manager_mod, only: get_tracer_names + use tracer_manager_mod, only: get_tracer_index, get_tracer_names, set_tracer_profile use field_manager_mod, only: MODEL_ATMOS use external_ic_mod, only: get_external_ic use fv_eta_mod, only: compute_dz_var, compute_dz_L32, set_hybrid_z use fv_surf_map_mod, only: del2_cubed_sphere, del4_cubed_sphere use boundary_mod, only: fill_nested_grid, nested_grid_BC, update_coarse_grid - use tracer_manager_mod, only: get_tracer_index - use field_manager_mod, only: MODEL_ATMOS use fv_timing_mod, only: timing_on, timing_off - use mpp_domains_mod, only: mpp_get_compute_domain, mpp_get_data_domain, mpp_get_global_domain - use mpp_mod, only: mpp_send, mpp_recv, mpp_sync_self, mpp_set_current_pelist, mpp_get_current_pelist, mpp_npes, mpp_pe, mpp_sync - use mpp_domains_mod, only: CENTER, CORNER, NORTH, EAST, mpp_get_C2F_index, WEST, SOUTH - use mpp_domains_mod, only: mpp_global_field use fv_treat_da_inc_mod, only: read_da_inc - use fms2_io_mod, only: file_exists, set_filename_appendix, FmsNetcdfFile_t, open_file, close_file - use fms_io_mod, only: fmsset_filename_appendix=> set_filename_appendix + use fv_regional_mod, only: write_full_fields use coarse_grained_restart_files_mod, only: fv_io_write_restart_coarse implicit none @@ -97,7 +97,8 @@ end subroutine fv_restart_init ! The fv core restart facility ! ! - subroutine fv_restart(fv_domain, Atm, dt_atmos, seconds, days, cold_start, grid_type, this_grid) + subroutine fv_restart(fv_domain, Atm, dt_atmos, seconds, days, cold_start, grid_type, & + this_grid) type(domain2d), intent(inout) :: fv_domain type(fv_atmos_type), intent(inout) :: Atm(:) real, intent(in) :: dt_atmos @@ -106,7 +107,7 @@ subroutine fv_restart(fv_domain, Atm, dt_atmos, seconds, days, cold_start, grid_ logical, intent(inout) :: cold_start integer, intent(in) :: grid_type, this_grid - integer :: i, j, k, n, ntileMe, nt, iq + integer :: i, j, k, l, m, n, ntileMe, nt, iq integer :: isc, iec, jsc, jec, ncnst, ntprog, ntdiag integer :: isd, ied, jsd, jed, npz integer isd_p, ied_p, jsd_p, jed_p, isc_p, iec_p, jsc_p, jec_p, isg, ieg, jsg,jeg, npx_p, npy_p @@ -119,12 +120,13 @@ subroutine fv_restart(fv_domain, Atm, dt_atmos, seconds, days, cold_start, grid_ character(len=128):: tname, errstring, fname, tracer_name character(len=120):: fname_ne, fname_sw character(len=3) :: gn + character(len=10) :: inputdir character(len=6) :: gnn integer :: npts, sphum integer, allocatable :: pelist(:), global_pelist(:), smoothed_topo(:) real :: sumpertn - real :: zvir + real :: zvir, nbg_inv type(FmsNetcdfFile_t) :: fileobj logical :: do_read_restart = .false. @@ -161,7 +163,7 @@ subroutine fv_restart(fv_domain, Atm, dt_atmos, seconds, days, cold_start, grid_ ntprog = size(Atm(n)%q,4) ntdiag = size(Atm(n)%qdiag,4) - !1. sort out restart, external_ic, and cold-start (idealized) + !1. sort out restart, external_ic, and cold-start (idealized) plus initialize tracers if (Atm(n)%neststruct%nested) then write(fname, '(A, I2.2, A)') 'INPUT/fv_core.res.nest', Atm(n)%grid_number, '.nc' write(fname_ne,'(A, I2.2, A)') 'INPUT/fv_BC_ne.res.nest', Atm(n)%grid_number, '.nc' @@ -181,6 +183,18 @@ subroutine fv_restart(fv_domain, Atm, dt_atmos, seconds, days, cold_start, grid_ if (is_master()) print*, 'FV_RESTART: ', n, do_read_restart, do_read_restart_bc endif + !initialize tracers + do nt = 1, ntprog + call get_tracer_names(MODEL_ATMOS, nt, tracer_name) + ! set all tracers to an initial profile value + call set_tracer_profile (MODEL_ATMOS, nt, Atm(n)%q(:,:,:,nt)) + enddo + do nt = ntprog+1, ntprog+ntdiag + call get_tracer_names(MODEL_ATMOS, nt, tracer_name) + ! set all tracers to an initial profile value + call set_tracer_profile (MODEL_ATMOS, nt, Atm(n)%qdiag(:,:,:,nt)) + enddo + !2. Register restarts !No longer need to register restarts in fv_restart_mod with fms2_io implementation @@ -246,10 +260,10 @@ subroutine fv_restart(fv_domain, Atm, dt_atmos, seconds, days, cold_start, grid_ !3. External_ic if (Atm(n)%flagstruct%external_ic) then if( is_master() ) write(*,*) 'Calling get_external_ic' - call get_external_ic(Atm(n), Atm(n)%domain, .not. do_read_restart) + call get_external_ic(Atm(n), .not. do_read_restart) if( is_master() ) write(*,*) 'IC generated from the specified external source' - !4. Restart + !4. Restart elseif (do_read_restart) then if ( Atm(n)%flagstruct%npz_rst /= 0 .and. Atm(n)%flagstruct%npz_rst /= Atm(n)%npz ) then @@ -261,11 +275,11 @@ subroutine fv_restart(fv_domain, Atm, dt_atmos, seconds, days, cold_start, grid_ write(*,*) '***** End Note from FV core **************************' write(*,*) ' ' endif - call remap_restart( Atm(n)%domain, Atm(n:n) ) + call remap_restart( Atm(n:n) ) if( is_master() ) write(*,*) 'Done remapping dynamical IC' else if( is_master() ) write(*,*) 'Warm starting, calling fv_io_restart' - call fv_io_read_restart(Atm(n)%domain,Atm(n:n)) + call fv_io_read_restart(Atm(n)%domain_for_read,Atm(n:n)) !====== PJP added DA functionality ====== if (Atm(n)%flagstruct%read_increment) then ! print point in middle of domain for a sanity check @@ -273,8 +287,7 @@ subroutine fv_restart(fv_domain, Atm, dt_atmos, seconds, days, cold_start, grid_ j = (Atm(n)%bd%jsc + Atm(n)%bd%jec)/2 k = Atm(n)%npz/2 if( is_master() ) write(*,*) 'Calling read_da_inc',Atm(n)%pt(i,j,k) - call read_da_inc(Atm(n), Atm(n)%domain, Atm(n)%bd, Atm(n)%npz, Atm(n)%ncnst, & - Atm(n)%u, Atm(n)%v, Atm(n)%q, Atm(n)%delp, Atm(n)%pt, isd, jsd, ied, jed) + call read_da_inc(Atm(n), Atm(n)%domain) if( is_master() ) write(*,*) 'Back from read_da_inc',Atm(n)%pt(i,j,k) endif !====== end PJP added DA functionailty====== @@ -509,7 +522,6 @@ subroutine fv_restart(fv_domain, Atm, dt_atmos, seconds, days, cold_start, grid_ ntprog = size(Atm(n)%q,4) ntdiag = size(Atm(n)%qdiag,4) - if (ideal_test_case(n) == 0) then #ifdef SW_DYNAMICS Atm(n)%pt(:,:,:)=1. @@ -691,7 +703,7 @@ subroutine fv_restart(fv_domain, Atm, dt_atmos, seconds, days, cold_start, grid_ !-------------------------------------------- ! Initialize surface winds for flux coupler: !-------------------------------------------- - if ( .not. Atm(n)%flagstruct%srf_init ) then + if ( .not. Atm(n)%flagstruct%srf_init ) then call cubed_to_latlon(Atm(n)%u, Atm(n)%v, Atm(n)%ua, Atm(n)%va, & Atm(n)%gridstruct, & Atm(n)%npx, Atm(n)%npy, npz, 1, & @@ -704,7 +716,7 @@ subroutine fv_restart(fv_domain, Atm, dt_atmos, seconds, days, cold_start, grid_ enddo enddo Atm(n)%flagstruct%srf_init = .true. - endif + endif end do ! n_tile @@ -1253,10 +1265,10 @@ subroutine fv_write_restart(Atm, timestamp) if (Atm%coarse_graining%write_coarse_restart_files) then call fv_io_write_restart_coarse(Atm, timestamp) if (.not. Atm%coarse_graining%write_only_coarse_intermediate_restarts) then - call fv_io_write_restart(Atm, timestamp) + call fv_io_write_restart(Atm, prefix=timestamp) endif else - call fv_io_write_restart(Atm, timestamp) + call fv_io_write_restart(Atm, prefix=timestamp) endif if (Atm%neststruct%nested) then @@ -1346,13 +1358,15 @@ subroutine fv_restart_end(Atm) ! Write4 energy correction term #endif + call fv_io_write_restart(Atm) if (Atm%coarse_graining%write_coarse_restart_files) then call fv_io_write_restart_coarse(Atm) endif - call fv_io_write_restart(Atm) if (Atm%neststruct%nested) call fv_io_write_BCs(Atm) + if (Atm%flagstruct%write_restart_with_bcs) call write_full_fields(Atm) + module_is_initialized = .FALSE. #ifdef EFLUX_OUT @@ -1412,4 +1426,5 @@ subroutine pmaxmn_g(qname, q, is, ie, js, je, km, fac, area, domain) if(is_master()) write(6,*) qname, qmax*fac, qmin*fac, gmean*fac end subroutine pmaxmn_g + end module fv_restart_mod diff --git a/tools/fv_surf_map.F90 b/tools/fv_surf_map.F90 index 84252bec9..5a634dec5 100644 --- a/tools/fv_surf_map.F90 +++ b/tools/fv_surf_map.F90 @@ -10,7 +10,7 @@ !* (at your option) any later version. !* !* The FV3 dynamical core is distributed in the hope that it will be -!* useful, but WITHOUT ANYWARRANTY; without even the implied warranty +!* useful, but WITHOUT ANY WARRANTY; without even the implied warranty !* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. !* See the GNU General Public License for more details. !* @@ -18,6 +18,7 @@ !* License along with the FV3 dynamical core. !* If not, see . !*********************************************************************** + module fv_surf_map_mod use fms_mod, only: check_nml_error, stdlog, & @@ -25,7 +26,7 @@ module fv_surf_map_mod use fms2_io_mod, only: file_exists use mpp_mod, only: get_unit, input_nml_file, mpp_error use mpp_domains_mod, only: mpp_update_domains, domain2d - use constants_mod, only: grav, radius, pi=>pi_8 + use constants_mod, only: grav, pi=>pi_8 use fv_grid_utils_mod, only: great_circle_dist, latlon2xyz, v_prod, normalize_vect use fv_grid_utils_mod, only: g_sum, global_mx, vect_cross diff --git a/tools/fv_timing.F90 b/tools/fv_timing.F90 index 3740a7ab8..6b55b2fdb 100644 --- a/tools/fv_timing.F90 +++ b/tools/fv_timing.F90 @@ -10,7 +10,7 @@ !* (at your option) any later version. !* !* The FV3 dynamical core is distributed in the hope that it will be -!* useful, but WITHOUT ANYWARRANTY; without even the implied warranty +!* useful, but WITHOUT ANY WARRANTY; without even the implied warranty !* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. !* See the GNU General Public License for more details. !* @@ -18,6 +18,7 @@ !* License along with the FV3 dynamical core. !* If not, see . !*********************************************************************** + module fv_timing_mod use mpp_mod, only: mpp_error, FATAL diff --git a/tools/fv_treat_da_inc.F90 b/tools/fv_treat_da_inc.F90 index 7165b4a84..6e1be2e85 100644 --- a/tools/fv_treat_da_inc.F90 +++ b/tools/fv_treat_da_inc.F90 @@ -10,7 +10,7 @@ !* (at your option) any later version. !* !* The FV3 dynamical core is distributed in the hope that it will be -!* useful, but WITHOUT ANYWARRANTY; without even the implied warranty +!* useful, but WITHOUT ANY WARRANTY; without even the implied warranty !* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. !* See the GNU General Public License for more details. !* @@ -47,8 +47,9 @@ module fv_treat_da_inc_mod get_tracer_index use field_manager_mod, only: MODEL_ATMOS - use constants_mod, only: pi=>pi_8, omega, grav, kappa, & + use constants_mod, only: pi=>pi_8, grav, kappa, & rdgas, rvgas, cp_air + use fv_arrays_mod, only: omega ! scaled for small earth use fv_arrays_mod, only: fv_atmos_type, & fv_grid_type, & fv_grid_bounds_type, & @@ -68,7 +69,8 @@ module fv_treat_da_inc_mod get_var1_double, & get_var2_real, & get_var3_r4, & - get_var1_real + get_var1_real, & + check_var_exists implicit none private @@ -82,17 +84,9 @@ module fv_treat_da_inc_mod !> Do NOT Have delz increment available yet !> EMC reads in delz increments but does NOT use them!! - subroutine read_da_inc(Atm, fv_domain, bd, npz_in, nq, u, v, q, delp, pt, is_in, js_in, ie_in, je_in ) - type(fv_atmos_type), intent(inout) :: Atm - type(domain2d), intent(inout) :: fv_domain - type(fv_grid_bounds_type), intent(IN) :: bd - integer, intent(IN) :: npz_in, nq, is_in, js_in, ie_in, je_in - real, intent(inout), dimension(is_in:ie_in, js_in:je_in+1,npz_in):: u ! D grid zonal wind (m/s) - real, intent(inout), dimension(is_in:ie_in+1,js_in:je_in ,npz_in):: v ! D grid meridional wind (m/s) - real, intent(inout) :: delp(is_in:ie_in ,js_in:je_in ,npz_in) ! pressure thickness (pascal) - real, intent(inout) :: pt( is_in:ie_in ,js_in:je_in ,npz_in) ! temperature (K) - real, intent(inout) :: q( is_in:ie_in ,js_in:je_in ,npz_in, nq) ! - + subroutine read_da_inc(Atm, fv_domain) + type(fv_atmos_type), intent(inout) :: Atm + type(domain2d), intent(inout) :: fv_domain ! local real :: deg2rad character(len=128) :: fname @@ -112,17 +106,19 @@ subroutine read_da_inc(Atm, fv_domain, bd, npz_in, nq, u, v, q, delp, pt, is_in, integer, dimension(Atm%bd%is:Atm%bd%ie,Atm%bd%js:Atm%bd%je+1)::& id1_d, id2_d, jdc_d - integer:: i, j, k, im, jm, km, npt + integer:: i, j, k, im, jm, km, npz, npt integer:: i1, i2, j1, ncid integer:: jbeg, jend integer tsize(3) real(kind=R_GRID), dimension(2):: p1, p2, p3 real(kind=R_GRID), dimension(3):: e1, e2, ex, ey - logical:: found + logical:: found, cliptracers integer :: is, ie, js, je integer :: isd, ied, jsd, jed - integer :: sphum, liq_wat, o3mr + integer :: isc, iec, jsc, jec + integer :: sphum, liq_wat, o3mr, ice_wat + integer :: snowwat, rainwat, graupel is = Atm%bd%is ie = Atm%bd%ie @@ -132,9 +128,18 @@ subroutine read_da_inc(Atm, fv_domain, bd, npz_in, nq, u, v, q, delp, pt, is_in, ied = Atm%bd%ied jsd = Atm%bd%jsd jed = Atm%bd%jed + isc = Atm%bd%isc + iec = Atm%bd%iec + jsc = Atm%bd%jsc + jec = Atm%bd%jec + deg2rad = pi/180. + npz = Atm%npz + + cliptracers = .true. + fname = 'INPUT/'//Atm%flagstruct%res_latlon_dynamics if( file_exists(fname) ) then @@ -145,10 +150,10 @@ subroutine read_da_inc(Atm, fv_domain, bd, npz_in, nq, u, v, q, delp, pt, is_in, im = tsize(1); jm = tsize(2); km = tsize(3) - if (km.ne.npz_in) then + if (km.ne.npz) then if (is_master()) print *, 'km = ', km call mpp_error(FATAL, & - '==> Error in read_da_inc: km is not equal to npz_in') + '==> Error in read_da_inc: km is not equal to npz') endif if(is_master()) write(*,*) fname, ' DA increment dimensions:', tsize @@ -190,16 +195,30 @@ subroutine read_da_inc(Atm, fv_domain, bd, npz_in, nq, u, v, q, delp, pt, is_in, sphum = get_tracer_index(MODEL_ATMOS, 'sphum') o3mr = get_tracer_index(MODEL_ATMOS, 'o3mr') liq_wat = get_tracer_index(MODEL_ATMOS, 'liq_wat') + ice_wat = get_tracer_index(MODEL_ATMOS, 'ice_wat') + rainwat = get_tracer_index(MODEL_ATMOS, 'rainwat') + snowwat = get_tracer_index(MODEL_ATMOS, 'snowwat') + graupel = get_tracer_index(MODEL_ATMOS, 'graupel') + + if (is_master()) print *, 'index: sphum,o3mr,ql,qi,qr,qs,qg,nq=', & + sphum,o3mr,liq_wat,ice_wat,rainwat,snowwat,graupel,Atm%ncnst ! perform increments on scalars allocate ( wk3(1:im,jbeg:jend, 1:km) ) allocate ( tp(is:ie,js:je,km) ) - call apply_inc_on_3d_scalar('T_inc',pt, is_in, js_in, ie_in, je_in) - call apply_inc_on_3d_scalar('delp_inc',delp, is_in, js_in, ie_in, je_in) - call apply_inc_on_3d_scalar('sphum_inc',q(:,:,:,sphum), is_in, js_in, ie_in, je_in) - call apply_inc_on_3d_scalar('liq_wat_inc',q(:,:,:,liq_wat), is_in, js_in, ie_in, je_in) - call apply_inc_on_3d_scalar('o3mr_inc',q(:,:,:,o3mr), is_in, js_in, ie_in, je_in) + call apply_inc_on_3d_scalar('T_inc',Atm%pt,isd,jsd,ied,jed) + call apply_inc_on_3d_scalar('delp_inc',Atm%delp,isd,jsd,ied,jed) + if (.not. Atm%flagstruct%hydrostatic) then + call apply_inc_on_3d_scalar('delz_inc',Atm%delz,isc,jsc,iec,jec) + endif + call apply_inc_on_3d_scalar('sphum_inc',Atm%q(:,:,:,sphum),isd,jsd,ied,jed,cliptracers) + call apply_inc_on_3d_scalar('liq_wat_inc',Atm%q(:,:,:,liq_wat),isd,jsd,ied,jed,cliptracers) + if(ice_wat > 0) call apply_inc_on_3d_scalar('icmr_inc',Atm%q(:,:,:,ice_wat),isd,jsd,ied,jed,cliptracers) + if(rainwat > 0) call apply_inc_on_3d_scalar('rwmr_inc',Atm%q(:,:,:,rainwat),isd,jsd,ied,jed,cliptracers) + if(snowwat > 0) call apply_inc_on_3d_scalar('snmr_inc',Atm%q(:,:,:,snowwat),isd,jsd,ied,jed,cliptracers) + if(graupel > 0) call apply_inc_on_3d_scalar('grle_inc',Atm%q(:,:,:,graupel),isd,jsd,ied,jed,cliptracers) + call apply_inc_on_3d_scalar('o3mr_inc',Atm%q(:,:,:,o3mr),isd,jsd,ied,jed,cliptracers) deallocate ( tp ) deallocate ( wk3 ) @@ -260,7 +279,7 @@ subroutine read_da_inc(Atm, fv_domain, bd, npz_in, nq, u, v, q, delp, pt, is_in, call get_latlon_vector(p3, ex, ey) vd_inc(i,j,k) = u_inc(i,j,k)*inner_prod(e2,ex) + & v_inc(i,j,k)*inner_prod(e2,ey) - v(i,j,k) = v(i,j,k) + vd_inc(i,j,k) + Atm%v(i,j,k) = Atm%v(i,j,k) + vd_inc(i,j,k) enddo enddo enddo @@ -313,7 +332,7 @@ subroutine read_da_inc(Atm, fv_domain, bd, npz_in, nq, u, v, q, delp, pt, is_in, call get_latlon_vector(p3, ex, ey) ud_inc(i,j,k) = u_inc(i,j,k)*inner_prod(e1,ex) + & v_inc(i,j,k)*inner_prod(e1,ey) - u(i,j,k) = u(i,j,k) + ud_inc(i,j,k) + Atm%u(i,j,k) = Atm%u(i,j,k) + ud_inc(i,j,k) enddo enddo enddo @@ -335,14 +354,30 @@ subroutine read_da_inc(Atm, fv_domain, bd, npz_in, nq, u, v, q, delp, pt, is_in, contains !--------------------------------------------------------------------------- - subroutine apply_inc_on_3d_scalar(field_name,var, is_in, js_in, ie_in, je_in) + subroutine apply_inc_on_3d_scalar(field_name,var,is_in,js_in,ie_in,je_in, & + cliptracers) character(len=*), intent(in) :: field_name integer, intent(IN) :: is_in, js_in, ie_in, je_in real, dimension(is_in:ie_in,js_in:je_in,1:km), intent(inout) :: var + logical, intent(in), optional :: cliptracers + integer :: ierr + real :: clip + + if (field_name == 'sphum_inc' .or. field_name == 'o3mr_inc') then + clip=tiny(0.0) + else + clip=0.0 + endif if (is_master()) print*, 'Reading increments ', field_name - call get_var3_r4( ncid, field_name, 1,im, jbeg,jend, 1,km, wk3 ) - if (is_master()) print*,trim(field_name),'before=',var(4,4,30) + call check_var_exists(ncid, field_name, ierr) + if (ierr == 0) then + call get_var3_r4( ncid, field_name, 1,im, jbeg,jend, 1,km, wk3 ) + else + if (is_master()) print *,'warning: no increment for ', & + trim(field_name),' found, assuming zero' + wk3 = 0. + endif do k=1,km do j=js,je @@ -353,10 +388,11 @@ subroutine apply_inc_on_3d_scalar(field_name,var, is_in, js_in, ie_in, je_in) tp(i,j,k) = s2c(i,j,1)*wk3(i1,j1 ,k) + s2c(i,j,2)*wk3(i2,j1 ,k)+& s2c(i,j,3)*wk3(i2,j1+1,k) + s2c(i,j,4)*wk3(i1,j1+1,k) var(i,j,k) = var(i,j,k)+tp(i,j,k) + if (present(cliptracers) .and. cliptracers .and. var(i,j,k) < clip) & + var(i,j,k)=clip enddo enddo enddo - if (is_master()) print*,trim(field_name),'after=',var(4,4,30),tp(4,4,30) end subroutine apply_inc_on_3d_scalar !--------------------------------------------------------------------------- diff --git a/tools/init_hydro.F90 b/tools/init_hydro.F90 index ca472c460..765741879 100644 --- a/tools/init_hydro.F90 +++ b/tools/init_hydro.F90 @@ -10,7 +10,7 @@ !* (at your option) any later version. !* !* The FV3 dynamical core is distributed in the hope that it will be -!* useful, but WITHOUT ANYWARRANTY; without even the implied warranty +!* useful, but WITHOUT ANY WARRANTY; without even the implied warranty !* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. !* See the GNU General Public License for more details. !* @@ -18,7 +18,6 @@ !* License along with the FV3 dynamical core. !* If not, see . !*********************************************************************** -! $Id$ module init_hydro_mod @@ -34,7 +33,7 @@ module init_hydro_mod implicit none private - public :: p_var, hydro_eq + public :: p_var, hydro_eq, hydro_eq_ext contains @@ -314,7 +313,7 @@ subroutine hydro_eq(km, is, ie, js, je, ps, hs, drym, delp, ak, bk, & z1 = 10.E3 * grav t1 = 200. t0 = 300. ! sea-level temp. - a0 = (t1-t0)/z1 + a0 = (t1-t0)/z1*0.5 c0 = t0/a0 if ( hybrid_z ) then @@ -330,7 +329,8 @@ subroutine hydro_eq(km, is, ie, js, je, ps, hs, drym, delp, ak, bk, & mslp = 100917.4 do j=js,je do i=is,ie - ps(i,j) = mslp*( c0/(hs(i,j)+c0))**(1./(a0*rdgas)) + !ps(i,j) = mslp*( c0/(hs(i,j)+c0))**(1./(a0*rdgas)) + ps(i,j) = mslp*exp(-1./(a0*rdgas)*hs(i,j)/(hs(i,j)+c0)) enddo enddo psm = g_sum(domain, ps(is:ie,js:je), is, ie, js, je, ng, area, 1, .true.) @@ -378,7 +378,8 @@ subroutine hydro_eq(km, is, ie, js, je, ps, hs, drym, delp, ak, bk, & ph(i,k) = ptop*exp( (gz(i,1)-gz(i,k))/(rdgas*t1) ) else ! Constant lapse rate region (troposphere) - ph(i,k) = ps(i,j)*((hs(i,j)+c0)/(gz(i,k)+c0))**(1./(a0*rdgas)) + !ph(i,k) = ps(i,j)*((hs(i,j)+c0)/(gz(i,k)+c0))**(1./(a0*rdgas)) + ph(i,k) = ps(i,j)*exp(-1./(a0*rdgas)*(gz(i,k)-hs(i,j))/(gz(i,k)-hs(i,j)+c0)) endif enddo enddo @@ -397,7 +398,9 @@ subroutine hydro_eq(km, is, ie, js, je, ps, hs, drym, delp, ak, bk, & if (ph(i,k) <= p1) then gz(i,k) = gz(i,k+1) + (rdgas*t1)*log(ph(i,k+1)/ph(i,k)) else - gz(i,k) = (hs(i,j)+c0)/(ph(i,k)/ps(i,j))**(a0*rdgas) - c0 +! Constant lapse rate region (troposphere) + !gz(i,k) = (hs(i,j)+c0)/(ph(i,k)/ps(i,j))**(a0*rdgas) - c0 + gz(i,k) = c0/(1+a0*rdgas*log(ph(i,k)/ps(i,j)))+hs(i,j)-c0 endif enddo enddo @@ -439,4 +442,173 @@ subroutine hydro_eq(km, is, ie, js, je, ps, hs, drym, delp, ak, bk, & end subroutine hydro_eq + ! Added by Linjiong Zhou, bugfix + increase temperature above tropospause + subroutine hydro_eq_ext(km, is, ie, js, je, ps, hs, drym, delp, ak, bk, & + pt, delz, area, ng, mountain, hydrostatic, hybrid_z, domain) +! Input: + integer, intent(in):: is, ie, js, je, km, ng + real, intent(in):: ak(km+1), bk(km+1) + real, intent(in):: hs(is-ng:ie+ng,js-ng:je+ng) + real, intent(in):: drym + logical, intent(in):: mountain + logical, intent(in):: hydrostatic + logical, intent(in):: hybrid_z + real(kind=R_GRID), intent(IN) :: area(is-ng:ie+ng,js-ng:je+ng) + type(domain2d), intent(IN) :: domain +! Output + real, intent(out):: ps(is-ng:ie+ng,js-ng:je+ng) + real, intent(out):: pt(is-ng:ie+ng,js-ng:je+ng,km) + real, intent(out):: delp(is-ng:ie+ng,js-ng:je+ng,km) + real, intent(inout):: delz(is:,js:,1:) +! Local + real gz(is:ie,km+1) + real ph(is:ie,km+1) + real mslp, z1, z2, t1, t2, p1, p2, t0, a0, a1, psm + real ztop, c0, c1 +#ifdef INIT_4BYTE + real(kind=4) :: dps +#else + real dps ! note that different PEs will get differt dps during initialization + ! this has no effect after cold start +#endif + real p0, gztop, ptop + integer i,j,k + + if ( is_master() ) write(*,*) 'Initializing ATM hydrostatically' + + if ( is_master() ) write(*,*) 'Initializing Earth' +! Given p1 and z1 (100mb, 15km) +! Given p2 and z2 (1mb, 45km) + p2 = 1.e2 + p1 = 100.e2 + z2 = 45.E3 * grav + z1 = 15.E3 * grav + t2 = 260. + t1 = 200. + t0 = 300. ! sea-level temp. + a0 = (t1-t0)/z1*0.5 + a1 = (t2-t1)/(z2-z1)*0.5 + c0 = t0/a0 + c1 = t1/a1 + + if ( hybrid_z ) then + ptop = 100. ! *** hardwired model top *** + else + ptop = ak(1) + endif + + ztop = z2 + (rdgas*t2)*log(p2/ptop) + if(is_master()) write(*,*) 'ZTOP is computed as', ztop/grav*1.E-3 + + if ( mountain ) then + mslp = 100917.4 + do j=js,je + do i=is,ie + !ps(i,j) = mslp*( c0/(hs(i,j)+c0))**(1./(a0*rdgas)) + ps(i,j) = mslp*exp(-1./(a0*rdgas)*hs(i,j)/(hs(i,j)+c0)) + enddo + enddo + psm = g_sum(domain, ps(is:ie,js:je), is, ie, js, je, ng, area, 1, .true.) + dps = drym - psm + if(is_master()) write(*,*) 'Computed mean ps=', psm + if(is_master()) write(*,*) 'Correction delta-ps=', dps + else + mslp = drym ! 1000.E2 + do j=js,je + do i=is,ie + ps(i,j) = mslp + enddo + enddo + dps = 0. + endif + + + do j=js,je + do i=is,ie + ps(i,j) = ps(i,j) + dps + gz(i, 1) = ztop + gz(i,km+1) = hs(i,j) + ph(i, 1) = ptop + ph(i,km+1) = ps(i,j) + enddo + + if ( hybrid_z ) then +!--------------- +! Hybrid Z +!--------------- + do k=km,2,-1 + do i=is,ie + gz(i,k) = gz(i,k+1) - delz(i,j,k)*grav + enddo + enddo +! Correct delz at the top: + do i=is,ie + delz(i,j,1) = (gz(i,2) - ztop) / grav + enddo + + do k=2,km + do i=is,ie + if ( gz(i,k) >= z2 ) then +! Isothermal + ph(i,k) = ptop*exp( (gz(i,1)-gz(i,k))/(rdgas*t2) ) + else if ( gz(i,k) >= z1 ) then +! Constant lapse rate region (troposphere) + !ph(i,k) = p1*((z1+c1)/(gz(i,k)+c1))**(1./(a1*rdgas)) + ph(i,k) = p1*exp(-1./(a1*rdgas)*(gz(i,k)-z1)/(gz(i,k)-z1+c1)) + else +! Constant lapse rate region (troposphere) + !ph(i,k) = ps(i,j)*((hs(i,j)+c0)/(gz(i,k)+c0))**(1./(a0*rdgas)) + ph(i,k) = ps(i,j)*exp(-1./(a0*rdgas)*(gz(i,k)-hs(i,j))/(gz(i,k)-hs(i,j)+c0)) + endif + enddo + enddo + else +!--------------- +! Hybrid sigma-p +!--------------- + do k=2,km+1 + do i=is,ie + ph(i,k) = ak(k) + bk(k)*ps(i,j) + enddo + enddo + + do k=2,km + do i=is,ie + if ( ph(i,k) <= p2 ) then +! Isothermal + gz(i,k) = ztop + (rdgas*t2)*log(ptop/ph(i,k)) + else if ( ph(i,k) <= p1 ) then +! Constant lapse rate region (troposphere) + !gz(i,k) = (z1+c1)/(ph(i,k)/p1)**(a1*rdgas) - c1 + gz(i,k) = c1/(1+a1*rdgas*log(ph(i,k)/p1))+z1-c1 + else +! Constant lapse rate region (troposphere) + !gz(i,k) = (hs(i,j)+c0)/(ph(i,k)/ps(i,j))**(a0*rdgas) - c0 + gz(i,k) = c0/(1+a0*rdgas*log(ph(i,k)/ps(i,j)))+hs(i,j)-c0 + endif + enddo + enddo + if ( .not. hydrostatic ) then + do k=1,km + do i=is,ie + delz(i,j,k) = ( gz(i,k+1) - gz(i,k) ) / grav + enddo + enddo + endif + endif ! end hybrid_z + +! Convert geopotential to Temperature + do k=1,km + do i=is,ie + pt(i,j,k) = (gz(i,k)-gz(i,k+1))/(rdgas*(log(ph(i,k+1)/ph(i,k)))) + pt(i,j,k) = max(t1, pt(i,j,k)) + delp(i,j,k) = ph(i,k+1) - ph(i,k) + enddo + enddo + enddo ! j-loop + + + end subroutine hydro_eq_ext + + end module init_hydro_mod diff --git a/tools/rad_ref.F90 b/tools/rad_ref.F90 new file mode 100644 index 000000000..2b79ed0d1 --- /dev/null +++ b/tools/rad_ref.F90 @@ -0,0 +1,235 @@ +!*********************************************************************** +!* GNU Lesser General Public License +!* +!* This file is part of the FV3 dynamical core. +!* +!* The FV3 dynamical core is free software: you can redistribute it +!* and/or modify it under the terms of the +!* GNU Lesser General Public License as published by the +!* Free Software Foundation, either version 3 of the License, or +!* (at your option) any later version. +!* +!* The FV3 dynamical core is distributed in the hope that it will be +!* useful, but WITHOUT ANY WARRANTY; without even the implied warranty +!* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. +!* See the GNU General Public License for more details. +!* +!* You should have received a copy of the GNU Lesser General Public +!* License along with the FV3 dynamical core. +!* If not, see . +!*********************************************************************** + +module rad_ref_mod + + use constants_mod, only: grav, rdgas, pi => pi_8 + use fv_arrays_mod, only: fv_grid_bounds_type, r_grid + use gfdl_mp_mod, only: do_hail, rhor, rhos, rhog, rhoh, rnzr, rnzs, rnzg, rnzh + use gfdl_mp_mod, only: do_hail_inline => do_hail ! assuming same densities and numbers in both inline and traditional gfdl mp + +contains + +subroutine rad_ref (q, pt, delp, peln, delz, dbz, maxdbz, allmax, bd, & + npz, ncnst, hydrostatic, zvir, in0r, in0s, in0g, iliqskin, do_inline_mp, & + sphum, liq_wat, ice_wat, rainwat, snowwat, graupel, mp_top) + + ! code from mark stoelinga's dbzcalc.f from the rip package. + ! currently just using values taken directly from that code, which is + ! consistent for the mm5 reisner - 2 microphysics. from that file: + + ! this routine computes equivalent reflectivity factor (in dbz) at + ! each model grid point. in calculating ze, the rip algorithm makes + ! assumptions consistent with those made in an early version + ! (ca. 1996) of the bulk mixed - phase microphysical scheme in the mm5 + ! model (i.e., the scheme known as "resiner - 2") . for each species: + ! + ! 1. particles are assumed to be spheres of constant density. the + ! densities of rain drops, snow particles, and graupel particles are + ! taken to be rho_r = rho_l = 1000 kg m^ - 3, rho_s = 100 kg m^ - 3, and + ! rho_g = 400 kg m^ - 3, respectively. (l refers to the density of + ! liquid water.) + ! + ! 2. the size distribution (in terms of the actual diameter of the + ! particles, rather than the melted diameter or the equivalent solid + ! ice sphere diameter) is assumed to follow an exponential + ! distribution of the form n (d) = n_0 * exp (lambda * d) . + ! + ! 3. if in0x = 0, the intercept parameter is assumed constant (as in + ! early reisner - 2), with values of 8x10^6, 2x10^7, and 4x10^6 m^ - 4, + ! for rain, snow, and graupel, respectively. various choices of + ! in0x are available (or can be added) . currently, in0x = 1 gives the + ! variable intercept for each species that is consistent with + ! thompson, rasmussen, and manning (2004, monthly weather review, + ! vol. 132, no. 2, pp. 519 - 542.) + ! + ! 4. if iliqskin = 1, frozen particles that are at a temperature above + ! freezing are assumed to scatter as a liquid particle. + ! + ! more information on the derivation of simulated reflectivity in rip + ! can be found in stoelinga (2005, unpublished write - up) . contact + ! mark stoelinga (stoeling@atmos.washington.edu) for a copy. + + ! 22sep16: modifying to use the gfdl mp parameters. if doing so remember + ! that the gfdl mp assumes a constant intercept (in0x = .false.) + ! ferrier - aligo has an option for fixed slope (rather than fixed intercept) . + ! thompson presumably is an extension of reisner mp. + + implicit none + + type (fv_grid_bounds_type), intent (in) :: bd + + logical, intent (in) :: hydrostatic, in0r, in0s, in0g, iliqskin, do_inline_mp + + integer, intent (in) :: npz, ncnst, mp_top + integer, intent (in) :: sphum, liq_wat, ice_wat, rainwat, snowwat, graupel + + real, intent (in), dimension (bd%isd:bd%ied, bd%jsd:bd%jed, npz) :: pt, delp + real, intent (in), dimension (bd%is:, bd%js:, 1:) :: delz + real, intent (in), dimension (bd%isd:bd%ied, bd%jsd:bd%jed, npz, ncnst) :: q + real, intent (in), dimension (bd%is :bd%ie, npz + 1, bd%js:bd%je) :: peln + real, intent (out), dimension (bd%is :bd%ie, bd%js :bd%je, npz) :: dbz + real, intent (out), dimension (bd%is :bd%ie, bd%js :bd%je) :: maxdbz + + real, intent (in) :: zvir + real, intent (out) :: allmax + + ! parameters for constant intercepts (in0[rsg] = .false.) + ! using gfdl mp values + + real (kind = r_grid), parameter :: vconr = 2503.23638966667 + real (kind = r_grid), parameter :: vcong = 87.2382675 + real (kind = r_grid), parameter :: vcons = 6.6280504 + real (kind = r_grid), parameter :: vconh = vcong + real (kind = r_grid), parameter :: normr = 25132741228.7183 + real (kind = r_grid), parameter :: normg = 5026548245.74367 + real (kind = r_grid), parameter :: normh = pi * rhoh * rnzh + real (kind = r_grid), parameter :: norms = 942477796.076938 + + ! constants for variable intercepts + ! will need to be changed based on mp scheme + + real, parameter :: r1 = 1.e-15 + real, parameter :: ron = 8.e6 + real, parameter :: ron2 = 1.e10 + real, parameter :: son = 2.e7 + real, parameter :: gon = 5.e7 + real, parameter :: ron_min = 8.e6 + real, parameter :: ron_qr0 = 0.00010 + real, parameter :: ron_delqr0 = 0.25 * ron_qr0 + real, parameter :: ron_const1r = (ron2 - ron_min) * 0.5 + real, parameter :: ron_const2r = (ron2 + ron_min) * 0.5 + + ! other constants + + real, parameter :: gamma_seven = 720. + real, parameter :: alpha = 0.224 + real (kind = r_grid), parameter :: factor_s = gamma_seven * 1.e18 * (1. / (pi * rhos)) ** 1.75 & + * (rhos / rhor) ** 2 * alpha + real, parameter :: qmin = 1.e-12 + real, parameter :: tice = 273.16 + + ! double precision + + real (kind = r_grid), dimension (bd%is:bd%ie) :: rhoair, denfac, z_e + real (kind = r_grid) :: qr1, qs1, qg1, t1, t2, t3, rwat, vtr, vtg, vts + real (kind = r_grid) :: factorb_s, factorb_g + real (kind = r_grid) :: temp_c, pres, sonv, gonv, ronv + + real :: rhogh, vcongh, normgh + + integer :: i, j, k + integer :: is, ie, js, je + + is = bd%is + ie = bd%ie + js = bd%js + je = bd%je + + if (rainwat < 1) return + + dbz (:, :, 1:mp_top) = - 20. + maxdbz (:, :) = - 20. ! minimum value + allmax = - 20. + + if ((do_hail .and. .not. do_inline_mp) .or. (do_hail_inline .and. do_inline_mp)) then + rhogh = rhoh + vcongh = vconh + normgh = normh + else + rhogh = rhog + vcongh = vcong + normgh = normg + endif + + !$omp parallel do default (shared) private (rhoair, t1, t2, t3, denfac, vtr, vtg, vts, z_e) + do k = mp_top + 1, npz + do j = js, je + if (hydrostatic) then + do i = is, ie + rhoair (i) = delp (i, j, k) / ((peln (i, k + 1, j) - peln (i, k, j)) * & + rdgas * pt (i, j, k) * (1. + zvir * q (i, j, k, sphum))) + denfac (i) = sqrt (min (10., 1.2 / rhoair (i))) + z_e (i) = 0. + enddo + else + do i = is, ie + rhoair (i) = - delp (i, j, k) / (grav * delz (i, j, k)) ! moist air density + denfac (i) = sqrt (min (10., 1.2 / rhoair (i))) + z_e (i) = 0. + enddo + endif + if (rainwat > 0) then + do i = is, ie + ! the following form vectorizes better & more consistent with gfdl_mp + ! sjl notes: marshall - palmer, dbz = 200 * precip ** 1.6, precip = 3.6e6 * t1 / rhor * vtr ! [mm / hr] + ! gfdl_mp terminal fall speeds are used + ! date modified 20170701 + ! account for excessively high cloud water - > autoconvert (diag only) excess cloud water + t1 = rhoair (i) * max (qmin, q (i, j, k, rainwat) + dim (q (i, j, k, liq_wat), 1.0e-3)) + vtr = max (1.e-3, vconr * denfac (i) * exp (0.2 * log (t1 / normr))) + z_e (i) = 200. * exp (1.6 * log (3.6e6 * t1 / rhor * vtr)) + ! z_e = 200. * (exp (1.6 * log (3.6e6 * t1 / rhor * vtr)) + & + ! exp (1.6 * log (3.6e6 * t3 / rhogh * vtg)) + & + ! exp (1.6 * log (3.6e6 * t2 / rhos * vts))) + enddo + endif + if (graupel > 0) then + do i = is, ie + t3 = rhoair (i) * max (qmin, q (i, j, k, graupel)) + vtg = max (1.e-3, vcongh * denfac (i) * exp (0.125 * log (t3 / normgh))) + z_e (i) = z_e (i) + 200. * exp (1.6 * log (3.6e6 * t3 / rhogh * vtg)) + enddo + endif + if (snowwat > 0) then + do i = is, ie + t2 = rhoair (i) * max (qmin, q (i, j, k, snowwat)) + ! vts = max (1.e-3, vcons * denfac * exp (0.0625 * log (t2 / norms))) + z_e (i) = z_e (i) + (factor_s / alpha) * t2 * exp (0.75 * log (t2 / rnzs)) + ! z_e = 200. * (exp (1.6 * log (3.6e6 * t1 / rhor * vtr)) + & + ! exp (1.6 * log (3.6e6 * t3 / rhogh * vtg)) + & + ! exp (1.6 * log (3.6e6 * t2 / rhos * vts))) + enddo + endif + do i = is, ie + dbz (i, j, k) = 10. * log10 (max (0.01, z_e (i))) + enddo + enddo + enddo + + !$omp parallel do default (shared) + do j = js, je + do k = mp_top + 1, npz + do i = is, ie + maxdbz (i, j) = max (dbz (i, j, k), maxdbz (i, j)) + enddo + enddo + enddo + + do j = js, je + do i = is, ie + allmax = max (maxdbz (i, j), allmax) + enddo + enddo + +end subroutine rad_ref + +end module rad_ref_mod diff --git a/tools/sim_nc_mod.F90 b/tools/sim_nc_mod.F90 index e7f837e9d..18a2951dd 100644 --- a/tools/sim_nc_mod.F90 +++ b/tools/sim_nc_mod.F90 @@ -10,7 +10,7 @@ !* (at your option) any later version. !* !* The FV3 dynamical core is distributed in the hope that it will be -!* useful, but WITHOUT ANYWARRANTY; without even the implied warranty +!* useful, but WITHOUT ANY WARRANTY; without even the implied warranty !* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. !* See the GNU General Public License for more details. !* @@ -18,6 +18,7 @@ !* License along with the FV3 dynamical core. !* If not, see . !*********************************************************************** + module sim_nc_mod ! This is S-J Lin's private netcdf file reader @@ -39,7 +40,8 @@ module sim_nc_mod private public open_ncfile, close_ncfile, get_ncdim1, get_var1_double, get_var2_double, & get_var3_real, get_var3_double, get_var3_r4, get_var2_real, get_var2_r4, & - handle_err, check_var, get_var1_real, get_var_att_double + handle_err, check_var, get_var1_real, get_var_att_double, & + check_var_exists contains @@ -358,6 +360,14 @@ logical function check_var( ncid, var3_name) end function check_var + subroutine check_var_exists(ncid, var_name, status) + integer, intent(in):: ncid + integer, intent(inout) :: status + character(len=*), intent(in):: var_name + integer:: varid + status = nf_inq_varid (ncid, var_name, varid) + end subroutine check_var_exists + subroutine get_var_att_str(ncid, var_name, att_name, att) implicit none #include diff --git a/tools/sorted_index.F90 b/tools/sorted_index.F90 index 3ca5f3f91..62f6ebf9b 100644 --- a/tools/sorted_index.F90 +++ b/tools/sorted_index.F90 @@ -10,7 +10,7 @@ !* (at your option) any later version. !* !* The FV3 dynamical core is distributed in the hope that it will be -!* useful, but WITHOUT ANYWARRANTY; without even the implied warranty +!* useful, but WITHOUT ANY WARRANTY; without even the implied warranty !* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. !* See the GNU General Public License for more details. !* @@ -18,6 +18,7 @@ !* License along with the FV3 dynamical core. !* If not, see . !*********************************************************************** + module sorted_index_mod !--------------------------------------------------------------------- ! diff --git a/tools/statistics.F90 b/tools/statistics.F90 new file mode 100644 index 000000000..5099d34cf --- /dev/null +++ b/tools/statistics.F90 @@ -0,0 +1,266 @@ +!*********************************************************************** +!* GNU Lesser General Public License +!* +!* This file is part of the FV3 dynamical core. +!* +!* The FV3 dynamical core is free software: you can redistribute it +!* and/or modify it under the terms of the +!* GNU Lesser General Public License as published by the +!* Free Software Foundation, either version 3 of the License, or +!* (at your option) any later version. +!* +!* The FV3 dynamical core is distributed in the hope that it will be +!* useful, but WITHOUT ANY WARRANTY; without even the implied warranty +!* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. +!* See the GNU General Public License for more details. +!* +!* You should have received a copy of the GNU Lesser General Public +!* License along with the FV3 dynamical core. +!* If not, see . +!*********************************************************************** + +module statistics_mod + +implicit none + +interface mode + module procedure mode_1d_real4 + module procedure mode_2d_real4 + module procedure masked_mode_2d_real4 + module procedure mode_1d_real8 + module procedure mode_2d_real8 + module procedure masked_mode_2d_real8 +end interface mode + +contains + + ! qksrt implementation copied and adapted for real arrays from implementation + ! in FMS: FMS/drifters/quicksort.F90 + function qksrt_partition_real4(n, list, start, end) result(top) + implicit none + integer, intent(in) :: n + real(kind=4), intent(inout) :: list(n) + integer, intent(in) :: start, end + + real(kind=4) :: pivot + integer :: bottom, top + logical :: done + + pivot = list(end) ! Partition around the last value + bottom = start-1 ! Start outside the area to be partitioned + top = end ! Ditto + + done = .false. + do while (.not. done) ! Until all elements are partitioned... + + do while (.not. done) ! Until we find an out of place element... + bottom = bottom+1 ! ... move the bottom up. + + if(bottom == top) then ! If we hit the top... + done = .true. ! ... we are done. + exit + endif + + if(list(bottom) > pivot) then ! Is the bottom out of place? + list(top) = list(bottom) ! Then put it at the top... + exit ! ... and start searching from the top. + endif + enddo + + do while (.not. done) ! Until we find an out of place element... + top = top-1 ! ... move the top down. + + if(top == bottom) then ! If we hit the bottom... + done = .true. ! ... we are done. + exit + endif + + if(list(top) < pivot) then ! Is the top out of place? + list(bottom) = list(top) ! Then put it at the bottom... + exit ! ...and start searching from the bottom. + endif + enddo + enddo + + list(top) = pivot ! Put the pivot in its place. + ! Return the split point + end function qksrt_partition_real4 + + recursive subroutine qksrt_quicksort_real4(n, list, start, end) + implicit none + integer, intent(in) :: n + real(kind=4), intent(inout) :: list(n) + integer, intent(in) :: start, end + integer :: split + + if(start < end) then ! If there are two or more elements... + split = qksrt_partition_real4(n, list, start, end) ! ... partition the sublist... + call qksrt_quicksort_real4(n, list, start, split-1) ! ... and sort both halves. + call qksrt_quicksort_real4(n, list, split+1, end) + endif + end subroutine qksrt_quicksort_real4 + + ! This procedure produces the same results as scipy.stats.mode; if there is a + ! tie in counts, the minimum mode value is returned. + function mode_1d_real4(array) + real(kind=4), dimension(:), intent(in) :: array + + real(kind=4) :: mode_1d_real4 + + integer :: i, run, max_run + real(kind=4), dimension(size(array)) :: sorted_array + + run = 1 + max_run = 0 + + sorted_array = array + call qksrt_quicksort_real4(size(sorted_array), sorted_array, 1, size(sorted_array)) + + if (size(sorted_array) == 1) then + mode_1d_real4 = sorted_array(1) + else + do i = 2, size(sorted_array) + if (sorted_array(i) == sorted_array(i - 1)) then + run = run + 1 + else + run = 1 + endif + if (run > max_run) then + max_run = run + mode_1d_real4 = sorted_array(i - 1) + endif + enddo + endif + end function mode_1d_real4 + + function mode_2d_real4(array) + real(kind=4), dimension(:,:), intent(in) :: array + + real(kind=4) :: mode_2d_real4 + + mode_2d_real4 = mode_1d_real4(pack(array, .true.)) + end function mode_2d_real4 + + function masked_mode_2d_real4(array, mask) + real(kind=4), dimension(:,:), intent(in) :: array + logical, dimension(:,:), intent(in) :: mask + real(kind=4) :: masked_mode_2d_real4 + + masked_mode_2d_real4 = mode_1d_real4(pack(array, mask)) + end function masked_mode_2d_real4 + + ! qksrt implementation copied and adapted for real arrays from implementation + ! in FMS: FMS/drifters/quicksort.F90 + function qksrt_partition_real8(n, list, start, end) result(top) + implicit none + integer, intent(in) :: n + real(kind=8), intent(inout) :: list(n) + integer, intent(in) :: start, end + + real(kind=8) :: pivot + integer :: bottom, top + logical :: done + + pivot = list(end) ! Partition around the last value + bottom = start-1 ! Start outside the area to be partitioned + top = end ! Ditto + + done = .false. + do while (.not. done) ! Until all elements are partitioned... + + do while (.not. done) ! Until we find an out of place element... + bottom = bottom+1 ! ... move the bottom up. + + if(bottom == top) then ! If we hit the top... + done = .true. ! ... we are done. + exit + endif + + if(list(bottom) > pivot) then ! Is the bottom out of place? + list(top) = list(bottom) ! Then put it at the top... + exit ! ... and start searching from the top. + endif + enddo + + do while (.not. done) ! Until we find an out of place element... + top = top-1 ! ... move the top down. + + if(top == bottom) then ! If we hit the bottom... + done = .true. ! ... we are done. + exit + endif + + if(list(top) < pivot) then ! Is the top out of place? + list(bottom) = list(top) ! Then put it at the bottom... + exit ! ...and start searching from the bottom. + endif + enddo + enddo + + list(top) = pivot ! Put the pivot in its place. + ! Return the split point + end function qksrt_partition_real8 + + recursive subroutine qksrt_quicksort_real8(n, list, start, end) + implicit none + integer, intent(in) :: n + real(kind=8), intent(inout) :: list(n) + integer, intent(in) :: start, end + integer :: split + + if(start < end) then ! If there are two or more elements... + split = qksrt_partition_real8(n, list, start, end) ! ... partition the sublist... + call qksrt_quicksort_real8(n, list, start, split-1) ! ... and sort both halves. + call qksrt_quicksort_real8(n, list, split+1, end) + endif + end subroutine qksrt_quicksort_real8 + + ! This procedure produces the same results as scipy.stats.mode; if there is a + ! tie in counts, the minimum mode value is returned. + function mode_1d_real8(array) + real(kind=8), dimension(:), intent(in) :: array + + real(kind=8) :: mode_1d_real8 + + integer :: i, run, max_run + real(kind=8), dimension(size(array)) :: sorted_array + + run = 1 + max_run = 0 + + sorted_array = array + call qksrt_quicksort_real8(size(sorted_array), sorted_array, 1, size(sorted_array)) + + if (size(sorted_array) == 1) then + mode_1d_real8 = sorted_array(1) + else + do i = 2, size(sorted_array) + if (sorted_array(i) == sorted_array(i - 1)) then + run = run + 1 + else + run = 1 + endif + if (run > max_run) then + max_run = run + mode_1d_real8 = sorted_array(i - 1) + endif + enddo + endif + end function mode_1d_real8 + + function mode_2d_real8(array) + real(kind=8), dimension(:,:), intent(in) :: array + + real(kind=8) :: mode_2d_real8 + + mode_2d_real8 = mode_1d_real8(pack(array, .true.)) + end function mode_2d_real8 + + function masked_mode_2d_real8(array, mask) + real(kind=8), dimension(:,:), intent(in) :: array + logical, dimension(:,:), intent(in) :: mask + real(kind=8) :: masked_mode_2d_real8 + + masked_mode_2d_real8 = mode_1d_real8(pack(array, mask)) + end function masked_mode_2d_real8 +end module statistics_mod diff --git a/tools/test_cases.F90 b/tools/test_cases.F90 index d61d558e1..034a91fde 100644 --- a/tools/test_cases.F90 +++ b/tools/test_cases.F90 @@ -10,7 +10,7 @@ !* (at your option) any later version. !* !* The FV3 dynamical core is distributed in the hope that it will be -!* useful, but WITHOUT ANYWARRANTY; without even the implied warranty +!* useful, but WITHOUT ANY WARRANTY; without even the implied warranty !* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. !* See the GNU General Public License for more details. !* @@ -21,11 +21,12 @@ module test_cases_mod - use constants_mod, only: cnst_radius=>radius, pi=>pi_8, omega, grav, kappa, rdgas, cp_air, rvgas - use init_hydro_mod, only: p_var, hydro_eq + use constants_mod, only: cnst_radius=>radius, pi=>pi_8, cnst_omega=>omega, grav, kappa, rdgas, cp_air, rvgas + use fv_arrays_mod, only: radius, omega ! scaled for small earth + use init_hydro_mod, only: p_var, hydro_eq, hydro_eq_ext use fv_mp_mod, only: is_master, & domain_decomp, fill_corners, XDir, YDir, & - mp_stop, mp_reduce_sum, mp_reduce_max, mp_gather, mp_bcst + mp_stop, mp_reduce_sum, mp_reduce_max, mp_gather use fv_grid_utils_mod, only: cubed_to_latlon, great_circle_dist, mid_pt_sphere, & ptop_min, inner_prod, get_latlon_vector, get_unit_vect2, & g_sum, latlon2xyz, cart_to_latlon, make_eta_level, f_p, project_sphere_v @@ -35,17 +36,15 @@ module test_cases_mod use fv_eta_mod, only: compute_dz_L32, compute_dz_L101, set_hybrid_z, gw_1d, & hybrid_z_dz - use mpp_mod, only: mpp_error, FATAL, mpp_root_pe, mpp_broadcast, mpp_sum + use mpp_mod, only: mpp_error, FATAL, mpp_root_pe, mpp_broadcast, mpp_sum, mpp_sync use mpp_mod, only: stdlog, input_nml_file use fms_mod, only: check_nml_error use mpp_domains_mod, only: mpp_update_domains, domain2d use mpp_parameter_mod, only: AGRID_PARAM=>AGRID,CGRID_NE_PARAM=>CGRID_NE, & SCALAR_PAIR use fv_sg_mod, only: qsmith - use fv_diagnostics_mod, only: prt_maxmin, ppme, eqv_pot, qcly0 -!!! DEBUG CODE - use mpp_mod, only: mpp_pe, mpp_chksum, stdout -!!! END DEBUG CODE + use fv_diagnostics_mod, only: prt_maxmin, ppme, eqv_pot, qcly0, is_ideal_case + use mpp_mod, only: mpp_pe, mpp_chksum, stdout use fv_arrays_mod, only: fv_grid_type, fv_flags_type, fv_grid_bounds_type, R_GRID use tracer_manager_mod, only: get_tracer_index use field_manager_mod, only: MODEL_ATMOS @@ -58,18 +57,19 @@ module test_cases_mod !!!! virtual temperature effect. ! Test Case Number (cubed-sphere domain) +! SHALLOW WATER TESTS: ! -1 = Divergence conservation test ! 0 = Idealized non-linear deformational flow -! 1 = Cosine Bell advection +! 1 = Cosine Bell advection (not implemented) ! 2 = Zonal geostrophically balanced flow ! 3 = non-rotating potential flow ! 4 = Tropical cyclones (merger of Rankine vortices) -! 5 = Zonal geostrophically balanced flow over an isolated mountain +! 5 = Zonal geostrophically balanced flow over an isolated mountain, with or without wind ! 6 = Rossby Wave number 4 ! 7 = Barotropic instability -! ! 8 = Potential flow (as in 5 but no rotation and initially at rest) ! 8 = "Soliton" propagation twin-vortex along equator -! 9 = Polar vortex +! 9 = Bates and Li (1997, Atmos.-Ocn.) polar vortex +! THREE-DIMENSIONAL TESTS ! 10 = hydrostatically balanced 3D test with idealized mountain ! 11 = Use this for cold starting the climate model with USGS terrain ! 12 = Jablonowski & Williamson Baroclinic test case (Steady State) @@ -92,20 +92,43 @@ module test_cases_mod ! 36 = HIWPP Super_Cell; no perturbation ! 37 = HIWPP Super_Cell; with the prescribed thermal ! 44 = Lock-exchange on the sphere; atm at rest with no mountain -! 45 = New test +! 45 = 3D Soliton ! 51 = 3D tracer advection (deformational nondivergent flow) +! 52 = Resting atmosphere over topography ! 55 = TC ! -55 = DCMIP 2016 TC test ! 101 = 3D non-hydrostatic Large-Eddy-Simulation (LES) with hybrid_z IC +!! Doubly-periodic tests (THREE-DIMENSIONAL) +! 1 = Pure advection (not implemented) +! 2 = Resting flow over a 1.5 km mountain +! 14 = Aqua-plane with hydro_eq sounding and optional warm bubble +! (sfc = 300 K, 200 K 250 mb tropopause) +! 15 = Warm bubble in isothermal atmosphere +! 16 = Cold bubble in isothermal atmosphere +! 17 = Symmetric Supercell +! 18 = Asymmetric supercell with M. Toy quarter-circle hodograph +! 19 = LJZ update to 17 with Cetrone-Houze marine sounding +! and several bubble and sounding options +! 101 = LES with isothermal atmosphere (not implemented) + + + + integer :: sphum, theta_d - real(kind=R_GRID), parameter :: radius = cnst_radius real(kind=R_GRID), parameter :: one = 1.d0 integer :: test_case = 11 logical :: bubble_do = .false. + logical :: no_wind = .false. + logical :: gaussian_dt = .false. + logical :: do_marine_sounding = .false. + real :: dt_amp = 2.1 real :: alpha = 0.0 - integer :: Nsolitons = 1 + integer :: Nsolitons = 2 real :: soliton_size = 750.e3, soliton_Umax = 50. + logical :: checker_tr + real :: small_earth_scale = 1.0 + real :: umean = 0.0 ! Case 0 parameters real :: p0_c0 = 3.0 @@ -154,11 +177,12 @@ module test_cases_mod integer, parameter :: interpOrder = 1 public :: pz0, zz0 - public :: read_namelist_test_case_nml, alpha + public :: read_namelist_test_case_nml, alpha, test_case public :: init_case public :: case9_forcing1, case9_forcing2, case51_forcing public :: init_double_periodic public :: checker_tracers + public :: radius, omega, small_earth_scale INTERFACE mp_update_dwinds MODULE PROCEDURE mp_update_dwinds_2d @@ -536,6 +560,9 @@ subroutine init_case(u,v,w,pt,delp,q,phis, ps,pe,peln,pk,pkz, uc,vc, ua,va, ak, real :: tmp1(1 :npx ,1 :npy ,1:nregions) real(kind=R_GRID) :: p0(2) ! Temporary Point + real(kind=R_GRID) :: p0e(2) ! Temporary Point + real(kind=R_GRID) :: p0w(2) ! Temporary Point + real(kind=R_GRID) :: p1(2) ! Temporary Point real(kind=R_GRID) :: p2(2) ! Temporary Point real(kind=R_GRID) :: p3(2) ! Temporary Point @@ -754,7 +781,7 @@ subroutine init_case(u,v,w,pt,delp,q,phis, ps,pe,peln,pk,pkz, uc,vc, ua,va, ak, sin(agrid(i ,j ,2))*cos(alpha) ) ** 2.0 enddo enddo - call init_winds(UBar, u,v,ua,va,uc,vc, 1, npx, npy, ng, ndims, nregions, gridstruct%bounded_domain, gridstruct, domain, tile) + call init_winds(UBar, u,v,ua,va,uc,vc, 1, npx, npy, ng, ndims, nregions, gridstruct%bounded_domain, gridstruct, domain, tile,bd) ! Test Divergence operator at cell centers do j=js,je @@ -776,8 +803,6 @@ subroutine init_case(u,v,w,pt,delp,q,phis, ps,pe,peln,pk,pkz, uc,vc, ua,va, ak, ! call mpp_update_domains( vor0, domain ) ! call mpp_update_domains( divg, domain ) ! call mpp_update_domains( vort, domain ) - call get_scalar_stats( divg, div0, npx, npy, ndims, nregions, & - pmin, pmax, L1_norm, L2_norm, Linf_norm, gridstruct, tile) 200 format(i4.4,'x',i4.4,'x',i4.4,' ',e21.14,' ',e21.14,' ',e21.14,' ',e21.14,' ',e21.14,' ',e21.14,' ',e21.14,' ',e21.14) 201 format(' ',A,e21.14,' ',e21.14) 202 format(' ',A,i4.4,'x',i4.4,'x',i4.4) @@ -809,8 +834,6 @@ subroutine init_case(u,v,w,pt,delp,q,phis, ps,pe,peln,pk,pkz, uc,vc, ua,va, ak, ua0 = ua va0 = va div0(:,:) = 1.e-20 - call get_scalar_stats( divg, div0, npx, npy, ndims, nregions, & - pmin, pmax, L1_norm, L2_norm, Linf_norm, gridstruct, tile) if ( is_master() ) then write(*,*) ' Error Norms of Analytical Divergence field A-Winds initialized' write(*,201) 'Divergence MAX error : ', pmax @@ -839,8 +862,6 @@ subroutine init_case(u,v,w,pt,delp,q,phis, ps,pe,peln,pk,pkz, uc,vc, ua,va, ak, enddo enddo div0(:,:) = 1.e-20 - call get_scalar_stats( divg, div0, npx, npy, ndims, nregions, & - pmin, pmax, L1_norm, L2_norm, Linf_norm, gridstruct, tile) if ( is_master() ) then write(*,*) ' Error Norms of Analytical Divergence field D-Winds initialized' write(*,201) 'Divergence MAX error : ', pmax @@ -906,7 +927,6 @@ subroutine init_case(u,v,w,pt,delp,q,phis, ps,pe,peln,pk,pkz, uc,vc, ua,va, ak, enddo initWindsCase=initWindsCase1 case(2) -#ifdef TEST_TRACER gh0 = 1.0e-6 r0 = radius/3. !RADIUS radius/3. p1(2) = 35./180.*pi !0. @@ -917,14 +937,13 @@ subroutine init_case(u,v,w,pt,delp,q,phis, ps,pe,peln,pk,pkz, uc,vc, ua,va, ak, p2(2) = agrid(i,j,2) r = great_circle_dist( p1, p2, radius ) if (r < r0 .and. .not.( abs(p1(2)-p2(2)) < 1./18. .and. p2(1)-p1(1) < 5./36.)) then - !q(i,j,k,1) = max(gh0*0.5*(1.0+cos(PI*r/r0))*exp(real(k-npz)),0.) q(i,j,1,1) = gh0 else q(i,j,1,1) = 0. endif enddo enddo -#endif + Ubar = (2.0*pi*radius)/(12.0*86400.0) gh0 = 2.94e4 phis = 0.0 @@ -953,7 +972,7 @@ subroutine init_case(u,v,w,pt,delp,q,phis, ps,pe,peln,pk,pkz, uc,vc, ua,va, ak, delp(i,j,1) = gh0 - (radius*omega*Ubar + (Ubar*Ubar)/2.) * & ( -1.*cos(agrid(i ,j ,1))*cos(agrid(i ,j ,2))*sin(alpha) + & sin(agrid(i ,j ,2))*cos(alpha) ) ** 2.0 -#endif +#endif FIVE_AVG enddo enddo initWindsCase=initWindsCase2 @@ -961,11 +980,11 @@ subroutine init_case(u,v,w,pt,delp,q,phis, ps,pe,peln,pk,pkz, uc,vc, ua,va, ak, !---------------------------- ! Non-rotating potential flow !---------------------------- -#ifdef NO_WIND - ubar = 0. -#else - ubar = 40. -#endif + if (no_wind) then + ubar = 0. + else + ubar = 40. + endif gh0 = 1.0e3 * grav phis = 0.0 r0 = radius/3. !RADIUS radius/3. @@ -986,12 +1005,12 @@ subroutine init_case(u,v,w,pt,delp,q,phis, ps,pe,peln,pk,pkz, uc,vc, ua,va, ak, enddo enddo -#ifdef NO_WIND - u = 0.; v = 0. - f0 = 0.; fC = 0. -#else + if (no_wind) then + u = 0.; v = 0. + f0 = 0.; fC = 0. + else - do j=js,je + do j=js,je do i=is,ie+1 p1(:) = grid(i ,j ,1:2) p2(:) = grid(i,j+1 ,1:2) @@ -1002,8 +1021,8 @@ subroutine init_case(u,v,w,pt,delp,q,phis, ps,pe,peln,pk,pkz, uc,vc, ua,va, ak, vtmp = 0. v(i,j,1) = utmp*inner_prod(e2,ex) + vtmp*inner_prod(e2,ey) enddo - enddo - do j=js,je+1 + enddo + do j=js,je+1 do i=is,ie p1(:) = grid(i, j,1:2) p2(:) = grid(i+1,j,1:2) @@ -1014,20 +1033,22 @@ subroutine init_case(u,v,w,pt,delp,q,phis, ps,pe,peln,pk,pkz, uc,vc, ua,va, ak, vtmp = 0. u(i,j,1) = utmp*inner_prod(e1,ex) + vtmp*inner_prod(e1,ey) enddo - enddo + enddo - anti_rot = -ubar/ radius - do j=jsd,jed+1 + anti_rot = -ubar/ radius + do j=jsd,jed+1 do i=isd,ied+1 fC(i,j) = 2.*anti_rot*sin(grid(i,j,2)) enddo - enddo - do j=jsd,jed + enddo + do j=jsd,jed do i=isd,ied f0(i,j) = 2.*anti_rot*sin(agrid(i,j,2)) enddo - enddo -#endif + enddo + + endif !no_wind + initWindsCase= -1 case(4) @@ -1061,7 +1082,6 @@ subroutine init_case(u,v,w,pt,delp,q,phis, ps,pe,peln,pk,pkz, uc,vc, ua,va, ak, p2(2) = pi/18. ! 10 N call rankine_vortex(ubar, r0, p2, u, v, grid, bd) -#ifndef SINGULAR_VORTEX !----------- ! Anti-pole: !----------- @@ -1079,7 +1099,7 @@ subroutine init_case(u,v,w,pt,delp,q,phis, ps,pe,peln,pk,pkz, uc,vc, ua,va, ak, enddo call cart_to_latlon(1, e1, p4(1), p4(2)) call rankine_vortex(ubar, r0, p4, u, v, grid, bd) -#endif + call mp_update_dwinds(u, v, npx, npy, npz, domain, bd) initWindsCase=-1 ! do nothing @@ -1100,14 +1120,29 @@ subroutine init_case(u,v,w,pt,delp,q,phis, ps,pe,peln,pk,pkz, uc,vc, ua,va, ak, phis(i,j) = 2000.0*Grav*(1.0-(r/r0)) enddo enddo - do j=js2,je2 + if (no_wind) then + do j=js,je + do i=is,ie + delp(i,j,1) = gh0 + enddo + enddo + u = 0.; v = 0. + f0 = 0.; fC = 0. + initWindsCase= -1 + + else + do j=js2,je2 do i=is2,ie2 delp(i,j,1) =gh0 - (radius*omega*Ubar + (Ubar*Ubar)/2.) * & ( -1.*cos(agrid(i ,j ,1))*cos(agrid(i ,j ,2))*sin(alpha) + & sin(agrid(i ,j ,2))*cos(alpha) ) ** 2 - phis(i,j) enddo - enddo - initWindsCase=initWindsCase5 + enddo + + initWindsCase=initWindsCase5 + endif + + case(6) gh0 = 8.E3*Grav R = 4. @@ -1159,6 +1194,7 @@ subroutine init_case(u,v,w,pt,delp,q,phis, ps,pe,peln,pk,pkz, uc,vc, ua,va, ak, !call mpp_update_domains( ua, va, domain, gridtype=AGRID_PARAM) call atoc(ua,va,uc,vc,dx,dy,dxa,dya,npx,npy,ng, gridstruct%bounded_domain, domain, bd) initWindsCase=initWindsCase6 + case(7) ! Barotropically unstable jet gh0 = 10.E3*Grav @@ -1189,13 +1225,6 @@ subroutine init_case(u,v,w,pt,delp,q,phis, ps,pe,peln,pk,pkz, uc,vc, ua,va, ak, pt8 = gh_jet(npy, grid(i+1,j+1,2)) pt9 = gh_jet(npy, grid(i ,j+1,2)) ftmp = 0.25*pt1 + 0.125*(pt2+pt3+pt4+pt5) + 0.0625*(pt6+pt7+pt8+pt9) -#ifndef NEW_PERT - delp(i,j,1) = ftmp + 120.*grav*cos(agrid(i,j,2)) * & - exp( -(3.*(agrid(i,j,1)-pi))**2 ) * exp( -(15.*(agrid(i,j,2)-pi/4.))**2 ) -! phis(i,j) = ftmp -! delp(i,j,1) = 10.E3*grav + 120.*grav*cos(agrid(i,j,2)) * & -! exp( -(3.*(agrid(i,j,1)-pi))**2 ) * exp( -(15.*(agrid(i,j,2)-pi/4.))**2 ) -#else ! Using great circle dist: p1(:) = agrid(i,j,1:2) delp(i,j,1) = ftmp @@ -1203,7 +1232,6 @@ subroutine init_case(u,v,w,pt,delp,q,phis, ps,pe,peln,pk,pkz, uc,vc, ua,va, ak, if ( r < 3.*r0 ) then delp(i,j,1) = delp(i,j,1) + 1000.*grav*exp(-(r/r0)**2) endif -#endif enddo enddo @@ -1219,7 +1247,6 @@ subroutine init_case(u,v,w,pt,delp,q,phis, ps,pe,peln,pk,pkz, uc,vc, ua,va, ak, vv2 = u_jet(pa(2))*(ew(2,i,j,2)*cos(pa(1)) - ew(1,i,j,2)*sin(pa(1))) ! 3-point average: v(i,j,1) = 0.25*(vv1 + 2.*vv2 + vv3) -! v(i,j,1) = vv2 enddo enddo ! U-wind: @@ -1234,7 +1261,6 @@ subroutine init_case(u,v,w,pt,delp,q,phis, ps,pe,peln,pk,pkz, uc,vc, ua,va, ak, uu2 = u_jet(pa(2))*(es(2,i,j,1)*cos(pa(1)) - es(1,i,j,1)*sin(pa(1))) ! 3-point average: u(i,j,1) = 0.25*(uu1 + 2.*uu2 + uu3) -! u(i,j,1) = uu2 enddo enddo initWindsCase=initWindsCase6 ! shouldn't do anything with this @@ -1258,39 +1284,10 @@ subroutine init_case(u,v,w,pt,delp,q,phis, ps,pe,peln,pk,pkz, uc,vc, ua,va, ak, do j=js,je do i=is,ie q(i,j,npz,1) = ( q(i,j,npz,1) + f0(i,j) ) / delp(i,j,npz) * 1.e6 ! PVU - !q(i,j,npz,1) = ( q(i,j,npz,1) + f0(i,j) ) * grav / delp(i,j,npz) enddo enddo -! call pv_entropy(is, ie, js, je, ng, npz, q(is:ie,js:je,:,2), f0, pt, pkz, delp, grav) case(8) -#ifdef USE_OLD -!---------------------------- -! Non-rotating potential flow -!---------------------------- - gh0 = 5960.*Grav - phis = 0.0 - r0 = PI/9. - p1(1) = PI/2. - p1(2) = PI/6. - do j=js,je - do i=is,ie - p2(1) = agrid(i,j,1) - p2(2) = agrid(i,j,2) - r = MIN(r0*r0, (p2(1)-p1(1))*(p2(1)-p1(1)) + (p2(2)-p1(2))*(p2(2)-p1(2)) ) - r = SQRT(r) - phis(i,j) = 2000.0*Grav*(1.0-(r/r0)) - enddo - enddo - do j=js,je - do i=is,ie - delp(i,j,1) = gh0 - enddo - enddo - u = 0.; v = 0. - f0 = 0.; fC = 0. - initWindsCase= -1 -#endif !---------------------------- ! Soliton twin-vortex !---------------------------- @@ -1307,6 +1304,7 @@ subroutine init_case(u,v,w,pt,delp,q,phis, ps,pe,peln,pk,pkz, uc,vc, ua,va, ak, ! Initiate the westerly-wind-burst: ubar = soliton_Umax r0 = soliton_size + ! #1 1: westerly p0(1) = pi*0.5 p0(2) = 0. @@ -1336,7 +1334,8 @@ subroutine init_case(u,v,w,pt,delp,q,phis, ps,pe,peln,pk,pkz, uc,vc, ua,va, ak, enddo enddo -! #1 2: easterly + ! #2: easterly + if (nsolitons > 0) then p0(1) = p0(1) + pi p0(2) = 0. @@ -1364,10 +1363,12 @@ subroutine init_case(u,v,w,pt,delp,q,phis, ps,pe,peln,pk,pkz, uc,vc, ua,va, ak, u(i,j,1) = u(i,j,1) - utmp*inner_prod(e1,ex) enddo enddo + endif initWindsCase= -1 + case(9) -#ifdef USE_OLD + jm1 = jm - 1 DDP = PI/DBLE(jm1) DP = DDP @@ -1439,56 +1440,21 @@ subroutine init_case(u,v,w,pt,delp,q,phis, ps,pe,peln,pk,pkz, uc,vc, ua,va, ak, call mp_update_dwinds(u, v, npx, npy, npz, domain, bd) initWindsCase=initWindsCase9 - + allocate(case9_B(isd:ied,jsd:jed)) call get_case9_B(case9_B, agrid, isd, ied, jsd, jed) AofT(:) = 0.0 -#else -!---------------------------- -! Soliton twin-vortex -!---------------------------- - if ( is_master() ) write(*,*) 'Initialzing case-9: soliton cyclones...' - f0 = 0.; fC = 0. ! non-rotating planet setup - phis = 0.0 ! flat terrain - gh0 = 5.E3*Grav - do j=js,je - do i=is,ie - delp(i,j,1) = gh0 - enddo - enddo - -! Initiate the westerly-wind-burst: - ubar = soliton_Umax - r0 = soliton_size - p0(1) = pi*0.5 - p0(2) = 0. - do j=js,je - do i=is,ie+1 - p1(:) = grid(i ,j ,1:2) - p2(:) = grid(i,j+1 ,1:2) - call mid_pt_sphere(p1, p2, p3) - r = great_circle_dist( p0, p3, radius ) - utmp = ubar*exp(-(r/r0)**2) - call get_unit_vect2(p1, p2, e2) - call get_latlon_vector(p3, ex, ey) - v(i,j,1) = utmp*inner_prod(e2,ex) - enddo - enddo - do j=js,je+1 - do i=is,ie - p1(:) = grid(i, j,1:2) - p2(:) = grid(i+1,j,1:2) - call mid_pt_sphere(p1, p2, p3) - r = great_circle_dist( p0, p3, radius ) - utmp = ubar*exp(-(r/r0)**2) - call get_unit_vect2(p1, p2, e1) - call get_latlon_vector(p3, ex, ey) - u(i,j,1) = utmp*inner_prod(e1,ex) - enddo - enddo - initWindsCase= -1 -#endif end select + + + cl = get_tracer_index(MODEL_ATMOS, 'cl') + cl2 = get_tracer_index(MODEL_ATMOS, 'cl2') + if (cl > 0 .and. cl2 > 0) then + call terminator_tracers(is,ie,js,je,isd,ied,jsd,jed,npz, & + q, delp,ncnst,agrid(isd:ied,jsd:jed,1),agrid(isd:ied,jsd:jed,2),bd) + call mpp_update_domains(q,domain) + endif + !--------------- end s-w cases -------------------------- ! Copy 3D data for Shallow Water Tests @@ -1591,53 +1557,14 @@ subroutine init_case(u,v,w,pt,delp,q,phis, ps,pe,peln,pk,pkz, uc,vc, ua,va, ak, else if ( (test_case==12) .or. (test_case==13) ) then -#ifdef HIWPP_TRACER - if (is_master()) print*, 'TEST TRACER enabled for this test case' -#ifdef HIWPP - call checker_tracers(is,ie, js,je, isd,ied, jsd,jed, & - ncnst, npz, q, agrid(is:ie,js:je,1), agrid(is:ie,js:je,2), 9., 9.) -#else - !For consistency with earlier single-grid simulations use gh0 = 1.0e-6 and p1(1) = 195.*pi/180. - q(:,:,:,:) = 0. - gh0 = 1.0e-3 - r0 = radius/3. !RADIUS radius/3. - p1(2) = 51.*pi/180. - p1(1) = 205.*pi/180. !231.*pi/180. - do k=1,npz - do j=jsd,jed - do i=isd,ied - p2(1) = agrid(i,j,1) - p2(2) = agrid(i,j,2) - r = great_circle_dist( p1, p2, radius ) - if (r < r0 .and. .not.( abs(p1(2)-p2(2)) < 1./18. .and. p2(1)-p1(1) < 5./36.) .and. k > 16) then - q(i,j,k,1) = gh0 - else - q(i,j,k,1) = 0. - endif - enddo - enddo - enddo -#endif - -#else + !For consistency with earlier single-grid simulations use gh0 = 1.0e-6 and p1(1) = 195.*pi/180. q(:,:,:,:) = 0. -#ifdef HIWPP - - cl = get_tracer_index(MODEL_ATMOS, 'cl') - cl2 = get_tracer_index(MODEL_ATMOS, 'cl2') - if (cl > 0 .and. cl2 > 0) then - call terminator_tracers(is,ie,js,je,isd,ied,jsd,jed,npz, & - q, delp,ncnst,agrid(isd:ied,jsd:jed,1),agrid(isd:ied,jsd:jed,2),bd) - call mpp_update_domains(q,domain) - endif -#endif -#endif ! Initialize surface Pressure ps(:,:) = 1.e5 - ! Initialize detla-P + ! Initialize delta-P !$OMP parallel do default(none) shared(is,ie,js,je,npz,delp,ak,ps,bk) do z=1,npz do j=js,je @@ -1690,13 +1617,8 @@ subroutine init_case(u,v,w,pt,delp,q,phis, ps,pe,peln,pk,pkz, uc,vc, ua,va, ak, do k=1,npz do j=js,je do i=is,ie - !r = great_circle_dist(pcen, agrid(i,j,:), radius) - !ptmp = 0.5*(pe(i,k,j)+pe(i,k+1,j)) - 100000. - !q(i,j,k,1) = 0.021*exp(-(agrid(i,j,2)/pcen(2))**4.)*exp(-(ptmp/34000.)**2.) ptmp = delp(i,j,k)/(peln(i,k+1,j)-peln(i,k,j)) - 100000. q(i,j,k,sphum) = 0.021*exp(-(agrid(i,j,2)/pcen(2))**4.)*exp(-(ptmp/34000.)**2.) -! SJL: -! q(i,j,k,sphum) = max(1.e-25, q(i,j,k,sphum)) enddo enddo enddo @@ -1708,17 +1630,12 @@ subroutine init_case(u,v,w,pt,delp,q,phis, ps,pe,peln,pk,pkz, uc,vc, ua,va, ak, pcen(1) = PI/9. pcen(2) = 2.0*PI/9. if (test_case == 13) then -#ifdef ALT_PERT - u1 = 0.0 - pt0 = 3.0 -#else u1 = 1.0 pt0 = 0.0 -#endif r0 = radius/10.0 endif -!$OMP parallel do default(none) shared(is,ie,js,je,npz,eta_v,grid,Ubar,pcen,r0,ee2,v,ee1,es,u,u1,ew) & +!$OMP parallel do default(none) shared(is,ie,js,je,npz,eta_v,grid,Ubar,pcen,r0,ee2,v,ee1,es,u,u1,ew,radius) & !$OMP private(utmp,r,vv1,vv3,p1,p2,vv2,uu1,uu2,uu3,pa) do z=1,npz do j=js,je @@ -1782,7 +1699,7 @@ subroutine init_case(u,v,w,pt,delp,q,phis, ps,pe,peln,pk,pkz, uc,vc, ua,va, ak, delta_T = 480000.0 lapse_rate = 0.005 !$OMP parallel do default(none) shared(is,ie,js,je,npz,eta,ak,bk,T_0,lapse_rate,eta_t, & -!$OMP delta_T,ptop,delp,Ubar,eta_v,agrid,grid,pcen,pt,r0) & +!$OMP delta_T,ptop,delp,Ubar,eta_v,agrid,grid,pcen,pt,r0,radius,omega) & !$OMP private(T_mean,press,pt1,pt2,pt3,pt4,pt5,pt6,pt7,pt8,pt9,p1,r) do z=1,npz eta(z) = 0.5*( (ak(z)+ak(z+1))/1.e5 + bk(z)+bk(z+1) ) @@ -1854,20 +1771,13 @@ subroutine init_case(u,v,w,pt,delp,q,phis, ps,pe,peln,pk,pkz, uc,vc, ua,va, ak, pt(i,j,z) = pt1 #endif -#ifdef ALT_PERT - r = great_circle_dist( pcen, agrid(i,j,1:2), radius ) - if ( (r/r0)**2 < 40. ) then - pt(i,j,z) = pt(i,j,z) + pt0*exp(-(r/r0)**2) - endif -#endif - enddo enddo enddo if (is_master()) print*,' ' ! Surface Geopotential phis(:,:)=1.e25 -!$OMP parallel do default(none) shared(is2,ie2,js2,je2,Ubar,eta_s,eta_0,agrid,grid,phis) & +!$OMP parallel do default(none) shared(is2,ie2,js2,je2,Ubar,eta_s,eta_0,agrid,grid,phis,radius,omega) & !$OMP private(pt1,pt2,pt3,pt4,pt5,pt6,pt7,pt8,pt9,p1) do j=js2,je2 do i=is2,ie2 @@ -2044,23 +1954,14 @@ subroutine init_case(u,v,w,pt,delp,q,phis, ps,pe,peln,pk,pkz, uc,vc, ua,va, ak, p1(2) = 0. do k=1,npz -#ifndef STD_BUBBLE r0 = 0.5*(ze1(k)+ze1(k+1)) - 3.2E3 -#else - r0 = (0.5*(ze1(k)+ze1(k+1)) - 3.0E3) / 2.E3 -#endif do j=js,je do i=is,ie ! Impose perturbation in potential temperature: pturb p2(1) = agrid(i,j,1) p2(2) = agrid(i,j,2) -#ifndef STD_BUBBLE r = great_circle_dist( p1, p2, radius ) dist = sqrt( r**2 + r0**2 ) / 3.2E3 -#else - r = great_circle_dist( p1, p2, radius ) / 4.E3 - dist = sqrt( r**2 + r0**2 ) -#endif if ( dist<=1. ) then q(i,j,k,1) = pk0 * pturb/pkz(i,j,k)*(cos(pi*dist)+1.)/2. pt(i,j,k) = pt(i,j,k) - pturb/pkz(i,j,k)*(cos(pi*dist)+1.)/2. @@ -2601,6 +2502,7 @@ subroutine init_case(u,v,w,pt,delp,q,phis, ps,pe,peln,pk,pkz, uc,vc, ua,va, ak, u = 0. v = 0. + q = 0. p00 = 1.e5 wind_field = tracer_test @@ -2670,8 +2572,7 @@ subroutine init_case(u,v,w,pt,delp,q,phis, ps,pe,peln,pk,pkz, uc,vc, ua,va, ak, ! 0.5*(ak(k)+ak(k+1)), 0.5*(bk(k)+bk(k+1)), dum3, dum4, dum5, & ! pt(i,j,k), phis(i,j), ps(i,j), dum6, q(i,j,k,1)) delp(i,j,k) = pe(i,k+1,j) - pe(i,k,j) - !Analytic point-value - !ANalytic layer-mean + !Analytic layer-mean pt(i,j,k) = -grav*t00*p00/(rdgas*gamma + grav)/delp(i,j,k) * & ( (pe(i,k,j)/p00)**(exponent+1.) - (pe(i,k+1,j)/p00)**(exponent+1.) ) @@ -3324,8 +3225,11 @@ subroutine init_case(u,v,w,pt,delp,q,phis, ps,pe,peln,pk,pkz, uc,vc, ua,va, ak, ! Initiate the westerly-wind-burst: ubar = soliton_Umax r0 = soliton_size - p0(1) = pi*0.5 - p0(2) = 0. + p0w(1) = pi*0.5 + p0w(2) = 0. + p0e(1) = p0w(1) + pi + p0e(2) = 0. + do k=1,npz do j=js,je @@ -3333,7 +3237,7 @@ subroutine init_case(u,v,w,pt,delp,q,phis, ps,pe,peln,pk,pkz, uc,vc, ua,va, ak, p1(:) = grid(i ,j ,1:2) p2(:) = grid(i,j+1 ,1:2) call mid_pt_sphere(p1, p2, p3) - r = great_circle_dist( p0, p3, radius ) + r = great_circle_dist( p0w, p3, radius ) utmp = ubar*exp(-(r/r0)**2) call get_unit_vect2(p1, p2, e2) call get_latlon_vector(p3, ex, ey) @@ -3345,7 +3249,7 @@ subroutine init_case(u,v,w,pt,delp,q,phis, ps,pe,peln,pk,pkz, uc,vc, ua,va, ak, p1(:) = grid(i, j,1:2) p2(:) = grid(i+1,j,1:2) call mid_pt_sphere(p1, p2, p3) - r = great_circle_dist( p0, p3, radius ) + r = great_circle_dist( p0w, p3, radius ) utmp = ubar*exp(-(r/r0)**2) call get_unit_vect2(p1, p2, e1) call get_latlon_vector(p3, ex, ey) @@ -3353,9 +3257,41 @@ subroutine init_case(u,v,w,pt,delp,q,phis, ps,pe,peln,pk,pkz, uc,vc, ua,va, ak, enddo enddo +! Add easterly-wind-brust: + if (nsolitons > 0) then + p0(1) = p0(1) + pi + p0(2) = 0. + + do j=js,je + do i=is,ie+1 + p1(:) = grid(i ,j ,1:2) + p2(:) = grid(i,j+1 ,1:2) + call mid_pt_sphere(p1, p2, p3) + r = great_circle_dist( p0e, p3, radius ) + utmp = ubar*exp(-(r/r0)**2) + call get_unit_vect2(p1, p2, e2) + call get_latlon_vector(p3, ex, ey) + v(i,j,k) = v(i,j,k) - utmp*inner_prod(e2,ex) + enddo + enddo + do j=js,je+1 + do i=is,ie + p1(:) = grid(i, j,1:2) + p2(:) = grid(i+1,j,1:2) + call mid_pt_sphere(p1, p2, p3) + r = great_circle_dist( p0e, p3, radius ) + utmp = ubar*exp(-(r/r0)**2) + call get_unit_vect2(p1, p2, e1) + call get_latlon_vector(p3, ex, ey) + u(i,j,k) = u(i,j,k) - utmp*inner_prod(e1,ex) + enddo + enddo + endif !nsolitons > 0 + do j=js,je do i=is,ie pkz(i,j,k) = (pk(i,j,k+1)-pk(i,j,k))/(kappa*(peln(i,k+1,j)-peln(i,k,j))) + #ifdef USE_PT pt(i,j,k) = pt0/p00**kappa ! Convert back to temperature: @@ -3378,8 +3314,8 @@ subroutine init_case(u,v,w,pt,delp,q,phis, ps,pe,peln,pk,pkz, uc,vc, ua,va, ak, enddo enddo #else - call checker_tracers(is,ie, js,je, isd,ied, jsd,jed, & - ncnst, npz, q, agrid(is:ie,js:je,1), agrid(is:ie,js:je,2), 9., 9.) +! call checker_tracers(is,ie, js,je, isd,ied, jsd,jed, & +! ncnst, npz, q, agrid(is:ie,js:je,1), agrid(is:ie,js:je,2), 9., 9.) #endif if ( .not. hydrostatic ) then @@ -3663,31 +3599,27 @@ subroutine init_case(u,v,w,pt,delp,q,phis, ps,pe,peln,pk,pkz, uc,vc, ua,va, ak, moist_phys, hydrostatic, nwat, domain, adiabatic, .not.hydrostatic) #endif -#ifdef COLUMN_TRACER - if( ncnst>1 ) q(:,:,:,2:ncnst) = 0.0 - ! Initialize a dummy Column Tracer - pcen(1) = PI/9. - pcen(2) = 2.0*PI/9. - r0 = radius/10.0 - do z=1,npz - do j=js,je - do i=is,ie - p1(:) = grid(i ,j ,1:2) - p2(:) = grid(i,j+1 ,1:2) - call mid_pt_sphere(p1, p2, pa) - call get_unit_vect2(p1, p2, e2) - call get_latlon_vector(pa, ex, ey) - ! Perturbation Location Case==13 - r = great_circle_dist( pcen, pa, radius ) - if (-(r/r0)**2.0 > -40.0) q(i,j,z,1) = EXP(-(r/r0)**2.0) - enddo - enddo - enddo -#endif + !Initialize tracers + + if (checker_tr) then + if (is_master()) print*, 'TEST TRACER enabled for this test case' + call checker_tracers(is,ie, js,je, isd,ied, jsd,jed, & + ncnst, npz, q, agrid(is:ie,js:je,1), agrid(is:ie,js:je,2), 9., 9.) + endif + + cl = get_tracer_index(MODEL_ATMOS, 'cl') + cl2 = get_tracer_index(MODEL_ATMOS, 'cl2') + if (cl > 0 .and. cl2 > 0) then + call terminator_tracers(is,ie,js,je,isd,ied,jsd,jed,npz, & + q, delp,ncnst,agrid(isd:ied,jsd:jed,1),agrid(isd:ied,jsd:jed,2),bd) + call mpp_update_domains(q,domain) + endif + +#endif SW_DYNAMICS -#endif call mp_update_dwinds(u, v, npx, npy, npz, domain, bd) + is_ideal_case = .true. nullify(agrid) nullify(grid) @@ -4556,11 +4488,16 @@ subroutine init_double_periodic(u,v,w,pt,delp,q,phis, ps,pe,peln,pk,pkz, uc,vc, real, dimension(1:npz):: pk1, ts1, qs1 real :: us0 = 30. real :: dist, r0, f0_const, prf, rgrav - real :: ptmp, ze, zc, zm, utmp, vtmp + real :: ptmp, ze, zc, zm, utmp, vtmp, xr, yr real :: t00, p00, xmax, xc, xx, yy, pk0, pturb, ztop real :: ze1(npz+1) - real:: dz1(npz) + real:: dz1(npz) + real :: gz(bd%isd:bd%ied,bd%jsd:bd%jed,npz+1) real:: zvir + real :: sigma, mu, amp, zint, zmid, qsum, pint, pmid + real :: N2, N2b, th0, ths, pks, rkap, ampb, thl + real :: dz, thp, pp, zt, p_t, pkp + integer :: o3mr integer :: i, j, k, m, icenter, jcenter real, pointer, dimension(:,:,:) :: agrid, grid @@ -4708,7 +4645,8 @@ subroutine init_double_periodic(u,v,w,pt,delp,q,phis, ps,pe,peln,pk,pkz, uc,vc, do k=1,npz prf = ak(k) + ps(i,j)*bk(k) if ( prf > 100.E2 ) then - pt(i,j,k) = pt(i,j,k) + 0.01*(1. - (dist/r0)) * prf/ps(i,j) + pt(i,j,k) = pt(i,j,k) + 2.0*(1. - (dist/r0)) * prf/ps(i,j) +! pt(i,j,k) = pt(i,j,k) + 0.01*(1. - (dist/r0)) * prf/ps(i,j) endif enddo enddo @@ -4738,6 +4676,35 @@ subroutine init_double_periodic(u,v,w,pt,delp,q,phis, ps,pe,peln,pk,pkz, uc,vc, enddo enddo +#ifdef O3_IC + !-------------------------------------------------------------- + ! *** Add o3 distribution *** Linjiong Zhou + ! normal distribution based on pressure + o3mr = get_tracer_index (MODEL_ATMOS, 'o3mr') + if (o3mr > 0) then + sigma = 19.0 + mu = 1.e3 + amp = 0.00023 + do j=js,je + do i=is,ie + pint = ptop + qsum = 0.0 + do k=1,npz + pmid = pint + 0.5 * delp(i,j,k) + pint = pint + delp(i,j,k) + q(i,j,k,o3mr) = 1.0 / (sigma * sqrt(2.0 * pi)) * & + exp(- (pmid ** 0.5 - mu ** 0.5) ** 2.0 / (2.0 * sigma ** 2.0)) + qsum = qsum + q(i,j,k,o3mr) + enddo + do k=npz,1,-1 + q(i,j,k,o3mr) = amp * q(i,j,k,o3mr) / qsum + enddo + enddo + enddo + endif + !-------------------------------------------------------------- +#endif + case ( 15 ) !--------------------------- ! Doubly periodic bubble @@ -4767,18 +4734,10 @@ subroutine init_double_periodic(u,v,w,pt,delp,q,phis, ps,pe,peln,pk,pkz, uc,vc, enddo - do k=1,npz - do j=jsd,jed - do i=isd,ied - ptmp = delp(i,j,k)/(peln(i,k+1,j)-peln(i,k,j)) -! pt(i,j,k) = t00 - enddo - enddo - enddo call p_var(npz, is, ie, js, je, ptop, ptop_min, delp, delz, pt, ps, & pe, peln, pk, pkz, kappa, q, ng, ncnst, area, dry_mass, .false., .false., & - moist_phys, .false., nwat, domain, flagstruct%adiabatic) + moist_phys, .false., nwat, domain, flagstruct%adiabatic, .true.) ! *** Add Initial perturbation *** r0 = 5.*max(dx_const, dy_const) @@ -4796,7 +4755,7 @@ subroutine init_double_periodic(u,v,w,pt,delp,q,phis, ps,pe,peln,pk,pkz, uc,vc, (zm-zc)**2 dist = sqrt(dist) if ( dist <= r0 ) then - pt(i,j,k) = pt(i,j,k) + 5.*(1.-dist/r0) + pt(i,j,k) = pt(i,j,k) + 5.*(1.-dist/r0) endif enddo enddo @@ -4847,7 +4806,7 @@ subroutine init_double_periodic(u,v,w,pt,delp,q,phis, ps,pe,peln,pk,pkz, uc,vc, do j=js,je do i=is,ie peln(i,k,j) = log(pe(i,k,j)) - ze0(i,j,k) = ze1(k) + !ze0(i,j,k) = ze1(k) !not used? enddo enddo enddo @@ -4927,11 +4886,17 @@ subroutine init_double_periodic(u,v,w,pt,delp,q,phis, ps,pe,peln,pk,pkz, uc,vc, do i=is,ie pt(i,j,k) = ts1(k) q(i,j,k,1) = qs1(k) - delz(i,j,k) = rdgas/grav*ts1(k)*(1.+zvir*qs1(k))*(peln(i,k,j)-peln(i,k+1,j)) +! delz(i,j,k) = rdgas/grav*ts1(k)*(1.+zvir*qs1(k))*(peln(i,k,j)-peln(i,k+1,j)) enddo enddo enddo + call p_var(npz, is, ie, js, je, ptop, ptop_min, delp, delz, pt, ps, & + pe, peln, pk, pkz, kappa, q, ng, ncnst, area, dry_mass, .false., .false., & + moist_phys, .false., nwat, domain, flagstruct%adiabatic, .true.) + + + ze1(npz+1) = 0. do k=npz,1,-1 ze1(k) = ze1(k+1) - delz(is,js,k) @@ -4939,7 +4904,7 @@ subroutine init_double_periodic(u,v,w,pt,delp,q,phis, ps,pe,peln,pk,pkz, uc,vc, do k=1,npz zm = 0.5*(ze1(k)+ze1(k+1)) - utmp = us0*tanh(zm/3.E3) + utmp = us0*tanh(zm/3.E3) - us0*0.5 ! subtract off mean wind do j=js,je+1 do i=is,ie u(i,j,k) = utmp @@ -4952,25 +4917,23 @@ subroutine init_double_periodic(u,v,w,pt,delp,q,phis, ps,pe,peln,pk,pkz, uc,vc, .true., hydrostatic, nwat, domain, flagstruct%adiabatic) ! *** Add Initial perturbation *** - pturb = 2. - r0 = 10.e3 - zc = 1.4e3 ! center of bubble from surface - icenter = (npx-1)/3 + 1 - jcenter = (npy-1)/2 + 1 - do k=1, npz - zm = 0.5*(ze1(k)+ze1(k+1)) - ptmp = ( (zm-zc)/zc ) **2 - if ( ptmp < 1. ) then + if (bubble_do) then + pturb = 2. + r0 = 10.e3 + zc = 1.4e3 ! center of bubble from surface + icenter = (npx-1)/3 + 1 + jcenter = (npy-1)/2 + 1 + do k=1, npz + zm = 0.5*(ze1(k)+ze1(k+1)) + ptmp = ( (zm-zc)/zc ) **2 do j=js,je do i=is,ie - dist = ptmp+((i-icenter)*dx_const/r0)**2+((j-jcenter)*dy_const/r0)**2 - if ( dist < 1. ) then - pt(i,j,k) = pt(i,j,k) + pturb*(1.-sqrt(dist)) - endif + dist = ptmp+((i-icenter)*dx_const/r0)**2+((j-jcenter)*dy_const/r0)**2 + pt(i,j,k) = pt(i,j,k) + pturb*max(1.-sqrt(dist),0.) enddo enddo - endif - enddo + enddo + endif case ( 18 ) !--------------------------- @@ -5061,27 +5024,411 @@ subroutine init_double_periodic(u,v,w,pt,delp,q,phis, ps,pe,peln,pk,pkz, uc,vc, ! *** Add Initial perturbation *** if (bubble_do) then - r0 = 10.e3 - zc = 1.4e3 ! center of bubble from surface - icenter = (npx-1)/2 + 1 - jcenter = (npy-1)/2 + 1 - do k=1, npz - zm = 0.5*(ze1(k)+ze1(k+1)) - ptmp = ( (zm-zc)/zc ) **2 - if ( ptmp < 1. ) then - do j=js,je - do i=is,ie - dist = ptmp+((i-icenter)*dx_const/r0)**2+((j-jcenter)*dy_const/r0)**2 - if ( dist < 1. ) then - pt(i,j,k) = pt(i,j,k) + pturb*(1.-sqrt(dist)) - endif - enddo - enddo - endif - enddo - endif + pturb = 2. + r0 = 10.e3 + zc = 1.4e3 ! center of bubble from surface + icenter = (npx-1)/3 + 1 + jcenter = (npy-1)/2 + 1 + do k=1, npz + zm = 0.5*(ze1(k)+ze1(k+1)) + ptmp = ( (zm-zc)/zc ) **2 + do j=js,je + do i=is,ie + dist = ptmp+((i-icenter)*dx_const/r0)**2+((j-jcenter)*dy_const/r0)**2 + pt(i,j,k) = pt(i,j,k) + pturb*max(1.-sqrt(dist),0.) + enddo + enddo + enddo + endif + + case ( 19 ) +!--------------------------- +! Revised Doubly periodic SuperCell, straight wind (v==0) +! Linjiong Zhou +!-------------------------- + zvir = rvgas/rdgas - 1. + p00 = 1000.E2 + ps(:,:) = p00 + phis(:,:) = 0. + do j=js,je + do i=is,ie + pk(i,j,1) = ptop**kappa + pe(i,1,j) = ptop + peln(i,1,j) = log(ptop) + enddo + enddo + + do k=1,npz + do j=js,je + do i=is,ie + delp(i,j,k) = ak(k+1)-ak(k) + ps(i,j)*(bk(k+1)-bk(k)) + pe(i,k+1,j) = ak(k+1) + ps(i,j)*bk(k+1) + peln(i,k+1,j) = log(pe(i,k+1,j)) + pk(i,j,k+1) = exp( kappa*peln(i,k+1,j) ) + enddo + enddo + enddo + + i = is + j = js + do k=1,npz + pk1(k) = (pk(i,j,k+1)-pk(i,j,k))/(kappa*(peln(i,k+1,j)-peln(i,k,j))) + enddo + + if (do_marine_sounding) then + call Marine_Sounding(npz, p00, pk1, ts1, qs1) + else + call SuperCell_Sounding_Marine(npz, p00, pk1, ts1, qs1) + endif + + v(:,:,:) = 0. + w(:,:,:) = 0. + q(:,:,:,:) = 0. + + do k=1,npz + do j=js,je + do i=is,ie + pt(i,j,k) = ts1(k) + q(i,j,k,1) = qs1(k) + delz(i,j,k) = rdgas/grav*ts1(k)*(1.+zvir*qs1(k))*(peln(i,k,j)-peln(i,k+1,j)) + enddo + enddo + enddo + + ze1(npz+1) = 0. + do k=npz,1,-1 + ze1(k) = ze1(k+1) - delz(is,js,k) + enddo + + do k=1,npz + zm = 0.5*(ze1(k)+ze1(k+1)) + if (no_wind) then + us0 = 0.0 + umean + else + us0 = 14. + umean + endif + utmp = us0*tanh(zm/1.2E4) + do j=js,je+1 + do i=is,ie + u(i,j,k) = utmp + enddo + enddo + enddo + + call p_var(npz, is, ie, js, je, ptop, ptop_min, delp, delz, pt, ps, & + pe, peln, pk, pkz, kappa, q, ng, ncnst, area, dry_mass, .false., .false., & + .true., hydrostatic, nwat, domain, flagstruct%adiabatic) + + if (gaussian_dt) then + +! *** Add Initial perturbation (Gaussian) *** + pturb = dt_amp + r0 = 10.e3 + zc = 1.4e3 ! center of bubble from surface + icenter = (npx-1)/2 + 1 + jcenter = (npy-1)/2 + 1 + do k=1, npz + zm = 0.5*(ze1(k)+ze1(k+1)) + ptmp = min(abs((zm-zc)/zc),1.0) + do j=js,je + do i=is,ie + xr = min(abs((i-icenter)*dx_const/r0),1.0) + yr = min(abs((j-jcenter)*dy_const/r0),1.0) + dist = cos(pi/2*ptmp)**2*cos(pi/2*xr)**2*cos(pi/2*yr)**2 + pt(i,j,k) = pt(i,j,k) + pturb*dist + enddo + enddo + enddo + + else + +! *** Add Initial perturbation (Ellipse) *** + pturb = dt_amp + r0 = 10.e3 + zc = 1.4e3 ! center of bubble from surface + icenter = (npx-1)/2 + 1 + jcenter = (npy-1)/2 + 1 + do k=1, npz + zm = 0.5*(ze1(k)+ze1(k+1)) + ptmp = ( (zm-zc)/zc ) **2 + do j=js,je + do i=is,ie + dist = ptmp+((i-icenter)*dx_const/r0)**2+((j-jcenter)*dy_const/r0)**2 + pt(i,j,k) = pt(i,j,k) + pturb*max(1.-sqrt(dist),0.) + enddo + enddo + enddo + + endif + + case ( 21 ) +!--------------------------------------------------------- +! Mountain wave +!--------------------------------------------------------- + t00 = 288. + N2 = 0.01**2 + p00 = 1.e5 + pk0 = exp(kappa*log(p00)) + th0 = t00/pk0 + amp = grav*grav/(cp_air*N2) + rkap = 1./kappa + + !1. set up topography (uniform-in-y) + icenter = npx/2 + jcenter = npy/2 + do j=jsd,jed + do i=isd,ied + dist=(i-icenter)*dx_const + phis(i,j)=250.*exp(-(dist/5000.)**2)*cos(pi*dist/4000.)*cos(pi*dist/4000.) + gz(i,j,npz+1) = phis(i,j) + enddo + enddo - case ( 101 ) + !2. Compute surface pressure + ! then form pressure surfaces + do j=jsd,jed + do i=isd,ied + ths = th0*exp(phis(i,j)*N2/grav) + pks = pk0 + amp*(1./ths - 1./th0) + ps(i,j) = exp(rkap*log(pks)) + enddo + enddo + + do k=1,npz+1 + do j=js,je + do i=is,ie + pe(i,k,j) = ak(k) + ps(i,j)*bk(k) + peln(i,k,j) = log(pe(i,k,j)) + pk(i,j,k) = exp(kappa*log(pe(i,k,j))) + enddo + enddo + enddo + do k=1,npz + do j=js,je + do i=is,ie + delp(i,j,k) = pe(i,k+1,j) - pe(i,k,j) + !delp(i,j,k) = ak(k+1) - ak(k) + ps(i,j)*(bk(k+1) - bk(k)) + pkz(i,j,k) = delp(i,j,k)/(peln(i,k+1,j)-peln(i,k,j)) + pkz(i,j,k) = exp(kappa*log(pkz(i,j,k))) + enddo + enddo + enddo + ptop = ak(1) + + !3. Set up thermal profile: N = 0.02 + do j=js,je + do i=is,ie + ths = exp(-phis(i,j)*N2/grav)/th0 + ths = ths - (pk(i,j,npz+1)-pkz(i,j,npz))/amp + pt(i,j,npz) = pkz(i,j,npz)/ths + delz(i,j,npz) = rdgas/grav*pt(i,j,npz)*(peln(i,npz,j)-peln(i,npz+1,j)) + gz(i,j,npz) = gz(i,j,npz+1) - delz(i,j,npz) + enddo + enddo + + do k=npz-1,1,-1 + do j=js,je + do i=is,ie + ths = pkz(i,j,k+1)/pt(i,j,k+1) - (pkz(i,j,k+1)-pkz(i,j,k))/amp + pt(i,j,k) = pkz(i,j,k)/ths + delz(i,j,k) = rdgas/grav*pt(i,j,k)*(peln(i,k,j)-peln(i,k+1,j)) + gz(i,j,k) = gz(i,j,k+1) - delz(i,j,k) + enddo + enddo + enddo + + !4. Set up wind profile: + u = 10.0 + v = 0.0 + w = 0.0 + q = 0.0 + + !5. Re-adjust phis and gz ; set up other variables + do j=jsd,jed + do i=isd,ied + phis(i,j) = phis(i,j)*grav + enddo + enddo + do k=1,npz+1 + do j=jsd,jed + do i=isd,ied + gz(i,j,k) = gz(i,j,k)*grav + enddo + enddo + enddo + + call p_var(npz, is, ie, js, je, ptop, ptop_min, delp, delz, pt, ps, & + pe, peln, pk, pkz, kappa, q, ng, ncnst, area, dry_mass, .false., .false., & + moist_phys, hydrostatic, nwat, domain, flagstruct%adiabatic, .not. hydrostatic ) + + case ( 22 ) +!--------------------------------------------------------- +! Uniform-in-y resting + shear flow over Schar topography +!--------------------------------------------------------- + t00 = 300. + N2 = 0.01**2 + N2b = 0.02**2 + p00 = 1.e5 + pk0 = exp(kappa*log(p00)) + th0 = t00/pk0 + amp = grav*grav/(cp_air*N2) + ampb = grav*grav/(cp_air*N2b) + rkap = 1./kappa + +#ifdef UNIFORM_DZ + !0. Set up uniform ~500-m grid spacing + !(This is a primitive method for creating a hybrid coordinate + ! and produces discontinuities.) + dz = 500. + ze = 0.0 + zt = 8000. + !zt = 5000. + thp = th0 + pkp = pk0 + ak(npz+1) = 0.0 + bk(npz+1) = 1.0 + + ths = th0*exp(zt*N2/grav) + pks = pk0 + amp*(1./ths - 1./th0) + p_t = exp(1./kappa*log(pks)) + + if (is_master()) write(*,'(I, 2F)') npz+1, ak(npz+1), bk(npz+1) + if (is_master()) write(*,'(2F)') ths*pk0, p_t + + do k=npz,1,-1 + ze = ze+dz + if (ze >= 10000.) then + ths = thp*exp(dz*N2b/grav) + pks = pkp + ampb*(1./ths - 1./thp) + else + ths = thp*exp(dz*N2/grav) + pks = pkp + amp*(1./ths - 1./thp) + endif + pp = exp(1./kappa*log(pks)) + if (pp <= p_t) then + ak(k) = pp + bk(k) = 0.0 + else + ak(k) = p_t*(pp-p00)/(p_t-p00) + bk(k) = (pp-p_t)/(p00-p_t) + endif + thp = ths + pkp = pks + if (is_master()) write(*,'(I, 5F)') k, ak(k), bk(k), ak(k+1)-ak(k) + p00*(bk(k+1)-bk(k)), ths*pk0, pp + + enddo + + call mpp_sync() +#endif + + !1. set up topography (uniform-in-y) + icenter = npx/2 + jcenter = npy/2 + do j=jsd,jed + do i=isd,ied + dist=(i-icenter)*dx_const + phis(i,j)=2000.*exp(-(dist/10000.)**2)*cos(pi*dist/8000.)*cos(pi*dist/8000.) + gz(i,j,npz+1) = phis(i,j) + enddo + enddo + + !2. Compute surface pressure assuming constant N = 0.01 + ! then form pressure surfaces + do j=jsd,jed + do i=isd,ied + ths = th0*exp(phis(i,j)*N2/grav) + pks = pk0 + amp*(1./ths - 1./th0) + ps(i,j) = exp(rkap*log(pks)) + enddo + enddo + + do k=1,npz+1 + do j=js,je + do i=is,ie + pe(i,k,j) = ak(k) + ps(i,j)*bk(k) + peln(i,k,j) = log(pe(i,k,j)) + pk(i,j,k) = exp(kappa*log(pe(i,k,j))) + enddo + enddo + enddo + do k=1,npz + do j=js,je + do i=is,ie + delp(i,j,k) = pe(i,k+1,j) - pe(i,k,j) + !delp(i,j,k) = ak(k+1) - ak(k) + ps(i,j)*(bk(k+1) - bk(k)) + pkz(i,j,k) = delp(i,j,k)/(peln(i,k+1,j)-peln(i,k,j)) + pkz(i,j,k) = exp(kappa*log(pkz(i,j,k))) + enddo + enddo + enddo + ptop = ak(1) + + !2. Set up thermal profile: N = 0.01 below 14 km and 0.02 above 14 km. + do j=js,je + do i=is,ie + ths = exp(-phis(i,j)*N2/grav)/th0 + ths = ths - (pk(i,j,npz+1)-pkz(i,j,npz))/amp + pt(i,j,npz) = pkz(i,j,npz)/ths + delz(i,j,npz) = rdgas/grav*pt(i,j,npz)*(peln(i,npz,j)-peln(i,npz+1,j)) + gz(i,j,npz) = gz(i,j,npz+1) - delz(i,j,npz) + enddo + enddo + + do k=npz-1,1,-1 + do j=js,je + do i=is,ie + if (gz(i,j,k+1) < 14000.) then + ths = pkz(i,j,k+1)/pt(i,j,k+1) - (pkz(i,j,k+1)-pkz(i,j,k))/amp + else + ths = pkz(i,j,k+1)/pt(i,j,k+1) - (pkz(i,j,k+1)-pkz(i,j,k))/ampb + endif + pt(i,j,k) = pkz(i,j,k)/ths + delz(i,j,k) = rdgas/grav*pt(i,j,k)*(peln(i,k,j)-peln(i,k+1,j)) + gz(i,j,k) = gz(i,j,k+1) - delz(i,j,k) + enddo + enddo + enddo + + !3. Set up wind profile: 0 below 10 km, 20 above 14 km, linear between + ! (recall this is uniform-in-y; a 3D problem would require + ! computing staggered height from cell-centroid gz) + do k=npz,1,-1 + do j=js,je+1 + do i=is,ie + if (gz(i,js,k+1) < 10000.) then + u(i,j,k) = 0.0 + elseif (gz(i,js,k+1) < 14000.) then + u(i,j,k) = 0.005*(0.5*(gz(i,js,k)+gz(i,js,k+1))-10000.) + else + u(i,j,k) = 20.0 + endif + enddo + enddo + enddo + v = 0.0 + w = 0.0 + q = 0.0 + + !4. Re-adjust phis and gz ; set up other variables + do j=jsd,jed + do i=isd,ied + phis(i,j) = phis(i,j)*grav + enddo + enddo + do k=1,npz+1 + do j=jsd,jed + do i=isd,ied + gz(i,j,k) = gz(i,j,k)*grav + enddo + enddo + enddo + + call p_var(npz, is, ie, js, je, ptop, ptop_min, delp, delz, pt, ps, & + pe, peln, pk, pkz, kappa, q, ng, ncnst, area, dry_mass, .false., .false., & + moist_phys, hydrostatic, nwat, domain, flagstruct%adiabatic, .not. hydrostatic ) + + + case ( 101 ) ! IC for LES t00 = 250. ! constant temp @@ -5170,15 +5517,15 @@ subroutine init_double_periodic(u,v,w,pt,delp,q,phis, ps,pe,peln,pk,pkz, uc,vc, zm = 0.5*(ze0(i,j,k)+ze0(i,j,k+1)) dist = ((i-icenter)*dx_const)**2 + ((j-jcenter)*dy_const)**2 + (zm-zc)**2 dist = sqrt(dist) - if ( dist <= r0 ) then - pt(i,j,k) = pt(i,j,k) + 2.0*(1.-dist/r0) - endif + pt(i,j,k) = pt(i,j,k) + 2.0*max((1.-dist/r0),0.) enddo enddo enddo end select + is_ideal_case = .true. + nullify(grid) nullify(agrid) @@ -5219,11 +5566,11 @@ subroutine init_double_periodic(u,v,w,pt,delp,q,phis, ps,pe,peln,pk,pkz, uc,vc, end subroutine init_double_periodic - subroutine read_namelist_test_case_nml(nml_filename) + subroutine read_namelist_test_case_nml() - character(*), intent(IN) :: nml_filename integer :: ierr, f_unit, unit, ios - namelist /test_case_nml/test_case, bubble_do, alpha, nsolitons, soliton_Umax, soliton_size + namelist /test_case_nml/test_case, bubble_do, alpha, nsolitons, soliton_Umax, soliton_size, & + no_wind, gaussian_dt, dt_amp, do_marine_sounding, checker_tr, small_earth_scale, Umean #include @@ -5239,6 +5586,10 @@ subroutine read_namelist_test_case_nml(nml_filename) ierr = check_nml_error(ios,'test_case_nml') write(unit, nml=test_case_nml) + if (.not. (small_earth_scale == 1.0)) then + radius = cnst_radius / small_earth_scale + omega = cnst_omega * small_earth_scale + endif end subroutine read_namelist_test_case_nml @@ -5566,7 +5917,7 @@ end subroutine superK_u subroutine SuperCell_Sounding(km, ps, pk1, tp, qp) - use gfdl_cloud_microphys_mod, only: wqsat_moist, qsmith_init, qs_blend + use gfdl_mp_mod, only: wqsat_moist, qsmith_init, qs_blend ! Morris Weisman & J. Klemp 2002 sounding ! Output sounding on pressure levels: integer, intent(in):: km @@ -5588,11 +5939,119 @@ subroutine SuperCell_Sounding(km, ps, pk1, tp, qp) real:: dz0, zvir, fac_z, pk0, temp1, p2 integer:: k, n, kk -#ifdef GFS_PHYS + zvir = rvgas/rdgas - 1. + pk0 = p00**kappa + pp(ns) = ps + pk(ns) = ps**kappa + if ( (is_master()) ) then + write(*,*) 'Computing sounding for super-cell test' + endif - call mpp_error(FATAL, 'SuperCell sounding cannot perform with GFS Physics.') + call qsmith_init -#else + dz0 = 50. + zs(ns) = 0. + qs(:) = qst + rh(:) = 0.25 + + do k=ns-1, 1, -1 + zs(k) = zs(k+1) + dz0 + enddo + + do k=1,ns +! Potential temperature + if ( zs(k) .gt. ztr ) then +! Stratosphere: + pt(k) = ptr*exp(grav*(zs(k)-ztr)/(cp_air*ttr)) + else +! Troposphere: + fac_z = (zs(k)/ztr)**1.25 + pt(k) = pt0 + (ptr-pt0)* fac_z + rh(k) = 1. - 0.75 * fac_z +! First guess on q: + qs(k) = qv0 - (qv0-qst)*fac_z + endif + pt(k) = pt(k) / pk0 + enddo + +!-------------------------------------- +! Iterate nx times with virtual effect: +!-------------------------------------- + do n=1, nx + do k=1,ns-1 + temp1 = 0.5*(pt(k)*(1.+zvir*qs(k)) + pt(k+1)*(1.+zvir*qs(k+1))) + dpk(k) = grav*(zs(k)-zs(k+1))/(cp_air*temp1) ! DPK > 0 + enddo + + do k=ns-1,1,-1 + pk(k) = pk(k+1) - dpk(k) + enddo + + do k=1, ns + temp1 = pt(k)*pk(k) +! if ( (is_master()) ) write(*,*) k, temp1, rh(k) + if ( pk(k) > 0. ) then + pp(k) = exp(log(pk(k))/kappa) + qs(k) = min(qv0, rh(k)*wqsat_moist(temp1, qs(k), pp(k))) + !qs(k) = min(qv0, rh(k)*qs_blend(temp1, pp(k), qs(k))) + !if ( (is_master()) ) write(*,*) 0.001*pp(k), qs(k) + else + !if ( (is_master()) ) write(*,*) n, k, pk(k) + call mpp_error(FATAL, 'Super-Cell case: pk < 0') + endif + enddo + enddo + +! Interpolate to p levels using pk1: p**kappa + do 555 k=1, km + if ( pk1(k) .le. pk(1) ) then + tp(k) = pt(1)*pk(1)/pk1(k) ! isothermal above + qp(k) = qst ! set to stratosphere value + elseif ( pk1(k) .ge. pk(ns) ) then + tp(k) = pt(ns) + qp(k) = qs(ns) + else + do kk=1,ns-1 + if( (pk1(k).le.pk(kk+1)) .and. (pk1(k).ge.pk(kk)) ) then + fac_z = (pk1(k)-pk(kk))/(pk(kk+1)-pk(kk)) + tp(k) = pt(kk) + (pt(kk+1)-pt(kk))*fac_z + qp(k) = qs(kk) + (qs(kk+1)-qs(kk))*fac_z + goto 555 + endif + enddo + endif +555 continue + + do k=1,km + tp(k) = tp(k)*pk1(k) ! temperature + tp(k) = max(Tmin, tp(k)) + enddo + + end subroutine SuperCell_Sounding + +! added by Linjiong Zhou + subroutine SuperCell_Sounding_Marine(km, ps, pk1, tp, qp) + use gfdl_mp_mod, only: wqsat_moist, qsmith_init, qs_blend +! Morris Weisman & J. Klemp 2002 sounding +! Output sounding on pressure levels: + integer, intent(in):: km + real, intent(in):: ps ! surface pressure (Pa) + real, intent(in), dimension(km):: pk1 + real, intent(out), dimension(km):: tp, qp +! Local: + integer, parameter:: ns = 401 + integer, parameter:: nx = 3 + real, dimension(ns):: zs, pt, qs, us, rh, pp, pk, dpk, dqdt + real, parameter:: Tmin = 175. + real, parameter:: p00 = 1.0e5 + real, parameter:: qst = 3.0e-6 + real, parameter:: qv0 = 1.7e-2 ! higher surface specific humidity + real, parameter:: ztr = 12.E3 + real, parameter:: ttr = 213. + real, parameter:: ptr = 353. ! higher Tropopause potential temp. + real, parameter:: pt0 = 300. ! surface potential temperature + real:: dz0, zvir, fac_z, pk0, temp1, p2 + integer:: k, n, kk zvir = rvgas/rdgas - 1. pk0 = p00**kappa @@ -5602,7 +6061,7 @@ subroutine SuperCell_Sounding(km, ps, pk1, tp, qp) write(*,*) 'Computing sounding for super-cell test' endif - call qsmith_init + !call qsmith_init dz0 = 50. zs(ns) = 0. @@ -5629,6 +6088,133 @@ subroutine SuperCell_Sounding(km, ps, pk1, tp, qp) pt(k) = pt(k) / pk0 enddo +!-------------------------------------- +! Iterate nx times with virtual effect: +!-------------------------------------- + do n=1, nx + do k=1,ns-1 + temp1 = 0.5*(pt(k)*(1.+zvir*qs(k)) + pt(k+1)*(1.+zvir*qs(k+1))) + dpk(k) = grav*(zs(k)-zs(k+1))/(cp_air*temp1) ! DPK > 0 + enddo + + do k=ns-1,1,-1 + pk(k) = pk(k+1) - dpk(k) + enddo + + do k=1, ns + temp1 = pt(k)*pk(k) +! if ( (is_master()) ) write(*,*) k, temp1, rh(k) + if ( pk(k) > 0. ) then + pp(k) = exp(log(pk(k))/kappa) +!#ifdef SUPER_K + qs(k) = 380./pp(k)*exp(17.27*(temp1-273.)/(temp1-36.)) + qs(k) = min( qv0, rh(k)*qs(k) ) + if ( (is_master()) ) write(*,*) 0.01*pp(k), qs(k) +!#else +! +!#ifdef USE_MIXED_TABLE +! qs(k) = min(qv0, rh(k)*qs_blend(temp1, pp(k), qs(k))) +!#else +! qs(k) = min(qv0, rh(k)*wqsat_moist(temp1, qs(k), pp(k))) +!#endif +! +!#endif + else + if ( (is_master()) ) write(*,*) n, k, pk(k) + call mpp_error(FATAL, 'Super-Cell case: pk < 0') + endif + enddo + enddo + +! Interpolate to p levels using pk1: p**kappa + do 555 k=1, km + if ( pk1(k) .le. pk(1) ) then + tp(k) = pt(1)*pk(1)/pk1(k) ! isothermal above + qp(k) = qst ! set to stratosphere value + elseif ( pk1(k) .ge. pk(ns) ) then + tp(k) = pt(ns) + qp(k) = qs(ns) + else + do kk=1,ns-1 + if( (pk1(k).le.pk(kk+1)) .and. (pk1(k).ge.pk(kk)) ) then + fac_z = (pk1(k)-pk(kk))/(pk(kk+1)-pk(kk)) + tp(k) = pt(kk) + (pt(kk+1)-pt(kk))*fac_z + qp(k) = qs(kk) + (qs(kk+1)-qs(kk))*fac_z + goto 555 + endif + enddo + endif +555 continue + + do k=1,km + tp(k) = tp(k)*pk1(k) ! temperature + tp(k) = max(Tmin, tp(k)) + enddo + + end subroutine SuperCell_Sounding_Marine + + ! added by Linjiong Zhou + subroutine Marine_Sounding(km, ps, pk1, tp, qp) + use gfdl_mp_mod, only: wqsat_moist, qsmith_init, qs_blend +! JASMINE CETRONE AND ROBERT A. HOUZE JR. MWR 225 +! Output sounding on pressure levels: + integer, intent(in):: km + real, intent(in):: ps ! surface pressure (Pa) + real, intent(in), dimension(km):: pk1 + real, intent(out), dimension(km):: tp, qp +! Local: + integer, parameter:: ns = 401 + integer, parameter:: nx = 3 + real, dimension(ns):: zs, pt, qs, us, rh, pp, pk, dpk, dqdt + real, parameter:: Tmin = 175. + real, parameter:: p00 = 1.0e5 + real, parameter:: qst = 3.0e-6 + real, parameter:: qv0 = 2.0e-2 + real, parameter:: ztr = 12.E3 + real, parameter:: ttr = 213. + real, parameter:: ptr = 346. ! Tropopause potential temp. + real, parameter:: pt0 = 300. ! surface potential temperature + real:: dz0, zvir, fac_z, pk0, temp1, p2 + integer:: k, n, kk + + + zvir = rvgas/rdgas - 1. + pk0 = p00**kappa + pp(ns) = ps + pk(ns) = ps**kappa + if ( (is_master()) ) then + write(*,*) 'Computing sounding for super-cell test' + endif + + call qsmith_init + + dz0 = 50. + zs(ns) = 0. + qs(:) = qst + rh(:) = 0.25 + + do k=ns-1, 1, -1 + zs(k) = zs(k+1) + dz0 + enddo + + do k=1,ns +! Potential temperature + if ( zs(k) .gt. ztr ) then +! Stratosphere: + pt(k) = ptr*exp(grav*(zs(k)-ztr)/(cp_air*ttr)) + else +! Troposphere: + fac_z = (zs(k)/ztr)**1.25 + pt(k) = (pt0 + (ptr-pt0)* fac_z**1.25)*(ztr-zs(k))/ztr+& + (pt0 + (ptr-pt0)* fac_z**0.15)*zs(k)/ztr + rh(k) = 1. - 0.75 * fac_z +! First guess on q: + qs(k) = (qv0 - (qv0-qst)* fac_z**0.50)*(ztr-zs(k))/ztr+& + (qv0 - (qv0-qst)* fac_z**0.01)*zs(k)/ztr + endif + pt(k) = pt(k) / pk0 + enddo + !-------------------------------------- ! Iterate nx times with virtual effect: !-------------------------------------- @@ -5692,9 +6278,7 @@ subroutine SuperCell_Sounding(km, ps, pk1, tp, qp) tp(k) = max(Tmin, tp(k)) enddo -#endif - - end subroutine SuperCell_Sounding + end subroutine Marine_Sounding subroutine DCMIP16_BC(delp,pt,u,v,q,w,delz,& is,ie,js,je,isd,ied,jsd,jed,npz,nq,ak,bk,ptop, & @@ -5734,7 +6318,7 @@ subroutine DCMIP16_BC(delp,pt,u,v,q,w,delz,& real(kind=R_GRID), parameter :: lamp = pi/9. real(kind=R_GRID), parameter :: phip = 2.*lamp real(kind=R_GRID), parameter :: ppcenter(2) = (/ lamp, phip /) - real, parameter :: Rp = radius/10. + real :: Rp real, parameter :: lapse = 5.e-3 real, parameter :: dT = 4.8e5 real, parameter :: phiW = 2.*pi/9. @@ -5764,6 +6348,7 @@ subroutine DCMIP16_BC(delp,pt,u,v,q,w,delz,& !Compute p, z, T on both the staggered and unstaggered grids. Then compute the zonal ! and meridional winds on both grids, and rotate as needed zvir = rvgas/rdgas - 1. + Rp = radius/10. !PS do j=js,je @@ -6120,7 +6705,7 @@ subroutine DCMIP16_TC(delp,pt,u,v,q,w,delz,& real, parameter :: dp = 1115. ! Pa real, parameter :: rp = 282000. ! m real, parameter :: zp = 7000. ! m - real, parameter :: fc = 2.*OMEGA*sin(phip) + real :: fc real, parameter :: zconv = 1.e-6 real, parameter :: rdgrav = rdgas/grav @@ -6137,6 +6722,8 @@ subroutine DCMIP16_TC(delp,pt,u,v,q,w,delz,& real, dimension(is:ie+1,js:je) :: gz_v,p_v,peln_v,ps_v,v1,v2, rc_v real(kind=R_GRID), dimension(is:ie+1,js:je) :: lat_v,lon_v + fc = 2.*OMEGA*sin(phip) + !Compute ps, phis, delp, aux pressure variables, Temperature, winds ! (with or without perturbation), moisture, w, delz