Line data    Source code

       1             :       module mo_prod_loss
       2             :       use shr_kind_mod, only : r8 => shr_kind_r8
       3             :       private
       4             :       public :: exp_prod_loss
       5             :       public :: imp_prod_loss
       6             :       contains
       7       89784 :       subroutine exp_prod_loss( prod, loss, y, rxt, het_rates )
       8             :       use ppgrid, only : pver
       9             :       implicit none
      10             : !--------------------------------------------------------------------
      11             : ! ... dummy args
      12             : !--------------------------------------------------------------------
      13             :       real(r8), dimension(:,:,:), intent(out) :: &
      14             :             prod, &
      15             :             loss
      16             :       real(r8), intent(in) :: y(:,:,:)
      17             :       real(r8), intent(in) :: rxt(:,:,:)
      18             :       real(r8), intent(in) :: het_rates(:,:,:)
      19             : !--------------------------------------------------------------------
      20             : ! ... loss and production for Explicit method
      21             : !--------------------------------------------------------------------
      22   139603680 :          loss(:,:,1) = ( + het_rates(:,:,6))* y(:,:,6)
      23   139603680 :          prod(:,:,1) = 0._r8
      24       89784 :       end subroutine exp_prod_loss
      25   262148400 :       subroutine imp_prod_loss( prod, loss, y, rxt, het_rates )
      26             :       use ppgrid, only : pver
      27             :       implicit none
      28             : !--------------------------------------------------------------------
      29             : ! ... dummy args
      30             : !--------------------------------------------------------------------
      31             :       real(r8), dimension(:), intent(out) :: &
      32             :             prod, &
      33             :             loss
      34             :       real(r8), intent(in) :: y(:)
      35             :       real(r8), intent(in) :: rxt(:)
      36             :       real(r8), intent(in) :: het_rates(:)
      37             : !--------------------------------------------------------------------
      38             : ! ... loss and production for Implicit method
      39             : !--------------------------------------------------------------------
      40   262148400 :          loss(1) = ( + het_rates(1))* y(1)
      41   262148400 :          prod(1) = 0._r8
      42   262148400 :          loss(2) = ( + het_rates(2))* y(2)
      43   262148400 :          prod(2) = 0._r8
      44   262148400 :          loss(3) = ( + rxt(8) + het_rates(3))* y(3)
      45   262148400 :          prod(3) = 0._r8
      46   262148400 :          loss(4) = ( + rxt(9) + het_rates(4))* y(4)
      47   262148400 :          prod(4) = 0._r8
      48   262148400 :          loss(5) = ( + rxt(10) + het_rates(5))* y(5)
      49   262148400 :          prod(5) = 0._r8
      50   262148400 :          loss(6) = ( + rxt(11) + rxt(12) + rxt(14) + het_rates(7))* y(7)
      51   262148400 :          prod(6) = 0._r8
      52   262148400 :          loss(7) = ( + het_rates(8))* y(8)
      53   262148400 :          prod(7) = 0._r8
      54   262148400 :          loss(8) = ( + het_rates(9))* y(9)
      55   262148400 :          prod(8) = 0._r8
      56   262148400 :          loss(9) = ( + het_rates(10))* y(10)
      57   262148400 :          prod(9) = 0._r8
      58   262148400 :          loss(10) = ( + rxt(1) + rxt(5) + het_rates(11))* y(11)
      59   262148400 :          prod(10) = 0._r8
      60   262148400 :          loss(11) = ( + het_rates(12))* y(12)
      61   262148400 :          prod(11) =rxt(13)*y(23)
      62   262148400 :          loss(12) = ( + rxt(7) + het_rates(13))* y(13)
      63   262148400 :          prod(12) = 0._r8
      64   262148400 :          loss(13) = ( + het_rates(14))* y(14)
      65   262148400 :          prod(13) = 0._r8
      66   262148400 :          loss(14) = ( + het_rates(15))* y(15)
      67   262148400 :          prod(14) = 0._r8
      68   262148400 :          loss(15) = ( + het_rates(16))* y(16)
      69   262148400 :          prod(15) = 0._r8
      70   262148400 :          loss(16) = ( + het_rates(17))* y(17)
      71   262148400 :          prod(16) = 0._r8
      72   262148400 :          loss(17) = ( + het_rates(18))* y(18)
      73   262148400 :          prod(17) = 0._r8
      74   262148400 :          loss(18) = ( + het_rates(19))* y(19)
      75   262148400 :          prod(18) = 0._r8
      76   262148400 :          loss(19) = ( + het_rates(20))* y(20)
      77   262148400 :          prod(19) = 0._r8
      78   262148400 :          loss(20) = ( + het_rates(21))* y(21)
      79   262148400 :          prod(20) = 0._r8
      80   262148400 :          loss(21) = ( + het_rates(22))* y(22)
      81   262148400 :          prod(21) = 0._r8
      82   262148400 :          loss(22) = ( + rxt(13) + het_rates(23))* y(23)
      83   262148400 :          prod(22) = (rxt(11) +rxt(12) +.500_r8*rxt(14))*y(7)
      84   262148400 :          loss(23) = ( + het_rates(24))* y(24)
      85   262148400 :          prod(23) = 0._r8
      86   262148400 :          loss(24) = ( + het_rates(25))* y(25)
      87   262148400 :          prod(24) = 0._r8
      88   262148400 :          loss(25) = ( + het_rates(26))* y(26)
      89   262148400 :          prod(25) = 0._r8
      90   262148400 :          loss(26) = ( + rxt(2) + het_rates(27))* y(27)
      91   262148400 :          prod(26) = 0._r8
      92   262148400 :          loss(27) = ( + rxt(3) + het_rates(28))* y(28)
      93   262148400 :          prod(27) = 0._r8
      94   262148400 :          loss(28) = ( + rxt(15) + het_rates(29))* y(29)
      95   262148400 :          prod(28) = 0._r8
      96   262148400 :          loss(29) = ( + het_rates(30))* y(30)
      97   262148400 :          prod(29) =rxt(15)*y(29)
      98   262148400 :          loss(30) = ( + rxt(4) + het_rates(31))* y(31)
      99   262148400 :          prod(30) =2.000_r8*rxt(10)*y(5) +rxt(5)*y(11)
     100   262148400 :       end subroutine imp_prod_loss
     101             :       end module mo_prod_loss