New URL for NEMO forge!   http://forge.nemo-ocean.eu

Since March 2022 along with NEMO 4.2 release, the code development moved to a self-hosted GitLab.
This present forge is now archived and remained online for history.
Changeset 3161 for branches – NEMO

Changeset 3161 for branches


Ignore:
Timestamp:
2011-11-20T16:02:18+01:00 (12 years ago)
Author:
cetlod
Message:

New dynamical allocation & timing in OPA_SRC/DYN routines

Location:
branches/2011/dev_NEMO_MERGE_2011/NEMOGCM/NEMO/OPA_SRC
Files:
27 edited

Legend:

Unmodified
Added
Removed

  • branches/2011/dev_NEMO_MERGE_2011/NEMOGCM/NEMO/OPA_SRC/DYN/divcur.F90

    r3116 r3161  
    3131   USE lbclnk          ! ocean lateral boundary conditions (or mpp link) 
    3232   USE lib_mpp         ! MPP library 
     33   USE wrk_nemo_2      ! Memory Allocation 
     34   USE timing          ! Timing 
    3335 
    3436   IMPLICIT NONE 
    … …  
    8385      INTEGER, INTENT(in) ::   kt   ! ocean time-step index 
    8486      ! 
    85       REAL(wp), ALLOCATABLE, SAVE, DIMENSION(:,:) ::   zwu   ! specific 2D workspace 
    86       REAL(wp), ALLOCATABLE, SAVE, DIMENSION(:,:) ::   zwv   ! specific 2D workspace 
    87       ! 
    8887      INTEGER ::   ji, jj, jk, jl           ! dummy loop indices 
    8988      INTEGER ::   ii, ij, ijt, iju, ierr   ! local integer 
    9089      REAL(wp) ::  zraur, zdep              ! local scalar 
    91       !!---------------------------------------------------------------------- 
    92  
     90      REAL(wp), POINTER,  DIMENSION(:,:) ::   zwu, zwv   ! specific 2D workspace 
     91      !!---------------------------------------------------------------------- 
     92      ! 
     93      IF( nn_timing == 1 )  CALL timing_start('div_cur') 
     94      ! 
     95      CALL wrk_alloc( jpi  , jpj+2, zwu, kistart = 1  ) 
     96      CALL wrk_alloc( jpi+2, jpj  , zwv, kjstart = -1 ) 
     97      ! 
    9398      IF( kt == nit000 ) THEN 
    9499         IF(lwp) WRITE(numout,*) 
    95100         IF(lwp) WRITE(numout,*) 'div_cur : horizontal velocity divergence and relative vorticity' 
    96101         IF(lwp) WRITE(numout,*) '~~~~~~~   NOT optimal for auto-tasking case' 
    97          ! 
    98          ALLOCATE( zwu( jpi, 1:jpj+2) , zwv(-1:jpi+2, jpj) , STAT=ierr ) 
    99          IF( lk_mpp    )   CALL mpp_sum( ierr ) 
    100          IF( ierr /= 0 )   CALL ctl_stop( 'STOP', 'div_cur : unable to allocate arrays' ) 
    101102      ENDIF 
    102103 
    … …  
    230231      CALL lbc_lnk( hdivn, 'T', 1. )   ;   CALL lbc_lnk( rotn , 'F', 1. )    ! lateral boundary cond. (no sign change) 
    231232      ! 
     233      CALL wrk_dealloc( jpi  , jpj+2, zwu, kistart = 1  ) 
     234      CALL wrk_dealloc( jpi+2, jpj  , zwv, kjstart = -1 ) 
     235      ! 
     236      IF( nn_timing == 1 )  CALL timing_stop('div_cur') 
     237      ! 
    232238   END SUBROUTINE div_cur 
    233239    
    … …  
    267273      REAL(wp) ::   zraur, zdep   ! local scalars 
    268274      !!---------------------------------------------------------------------- 
    269  
     275      ! 
     276      IF( nn_timing == 1 )  CALL timing_start('div_cur') 
     277      ! 
    270278      IF( kt == nit000 ) THEN 
    271279         IF(lwp) WRITE(numout,*) 
    … …  
    319327      CALL lbc_lnk( hdivn, 'T', 1. )   ;   CALL lbc_lnk( rotn , 'F', 1. )     ! lateral boundary cond. (no sign change) 
    320328      ! 
     329      IF( nn_timing == 1 )  CALL timing_stop('div_cur') 
     330      ! 
    321331   END SUBROUTINE div_cur 
    322332    

  • branches/2011/dev_NEMO_MERGE_2011/NEMOGCM/NEMO/OPA_SRC/DYN/dynadv.F90

    r2715 r3161  
    1919   USE in_out_manager  ! I/O manager 
    2020   USE lib_mpp         ! MPP library 
     21   USE timing          ! Timing 
    2122 
    2223   IMPLICIT NONE 
    … …  
    5758      !!---------------------------------------------------------------------- 
    5859      ! 
     60      IF( nn_timing == 1 )  CALL timing_start('dyn_adv') 
     61      ! 
    5962      SELECT CASE ( nadv )                  ! compute advection trend and add it to general trend 
    6063      CASE ( 0 )      
    … …  
    7275                      CALL dyn_adv_ubs ( kt ) 
    7376      END SELECT 
     77      ! 
     78      IF( nn_timing == 1 )  CALL timing_stop('dyn_adv') 
    7479      ! 
    7580   END SUBROUTINE dyn_adv 

  • branches/2011/dev_NEMO_MERGE_2011/NEMOGCM/NEMO/OPA_SRC/DYN/dynadv_cen2.F90

    r2977 r3161  
    2020   USE lib_mpp        ! MPP library 
    2121   USE prtctl         ! Print control 
     22   USE wrk_nemo_2      ! Memory Allocation 
     23   USE timing          ! Timing 
    2224 
    2325   IMPLICIT NONE 
    … …  
    4749      !! ** Action  :   (ua,va) updated with the now vorticity term trend 
    4850      !!---------------------------------------------------------------------- 
    49       USE wrk_nemo, ONLY:   wrk_in_use, wrk_not_released 
    5051      USE oce     , ONLY:   tsa             ! tsa used as 2 3D workspace 
    51       USE wrk_nemo, ONLY:   zfu_t => wrk_3d_1 , zfv_t => wrk_3d_4 , zfu_uw =>wrk_3d_6   ! 3D workspaces 
    52       USE wrk_nemo, ONLY:   zfu_f => wrk_3d_2 , zfv_f => wrk_3d_5 , zfv_vw =>wrk_3d_7 
    53       USE wrk_nemo, ONLY:   zfw   => wrk_3d_3 
    5452      ! 
    5553      INTEGER, INTENT( in ) ::   kt   ! ocean time-step index 
    … …  
    5755      INTEGER  ::   ji, jj, jk   ! dummy loop indices 
    5856      REAL(wp) ::   zbu, zbv     ! local scalars 
     57      REAL(wp), POINTER, DIMENSION(:,:,:) ::  zfu_t, zfv_t, zfu_f, zfv_f, zfu_uw, zfv_vw, zfw 
    5958      REAL(wp), POINTER, DIMENSION(:,:,:) ::  zfu, zfv 
    6059      !!---------------------------------------------------------------------- 
    61  
     60      ! 
     61      IF( nn_timing == 1 )  CALL timing_start('dyn_adv_cen2') 
     62      ! 
     63      CALL wrk_alloc( jpi, jpj, jpk, zfu_t, zfv_t, zfu_f, zfv_f, zfu_uw, zfv_vw, zfw ) 
     64      zfu => tsa(:,:,:,1)  
     65      zfv => tsa(:,:,:,2)  
     66      ! 
    6267      IF( kt == nit000 .AND. lwp ) THEN 
    6368         WRITE(numout,*) 
    … …  
    6570         WRITE(numout,*) '~~~~~~~~~~~~' 
    6671      ENDIF 
    67  
    68       ! Check that global workspace arrays aren't already in use 
    69       IF( wrk_in_use(3, 1,2,3,4,5,6,7) ) THEN 
    70          CALL ctl_stop('dyn_adv_cen2 : requested workspace array unavailable')   ;   RETURN 
    71       ENDIF 
    72       ! 
    73       zfu => tsa(:,:,:,1)  
    74       zfv => tsa(:,:,:,2)  
    7572      ! 
    7673      IF( l_trddyn ) THEN           ! Save ua and va trends 
    … …  
    166163         &                       tab3d_2=va, clinfo2=           ' Va: ', mask2=vmask, clinfo3='dyn' ) 
    167164      ! 
    168       IF( wrk_not_released(3, 1,2,3,4,5,6,7) )   CALL ctl_stop('dyn_adv_cen2: failed to release workspace array') 
     165      CALL wrk_dealloc( jpi, jpj, jpk, zfu_t, zfv_t, zfu_f, zfv_f, zfu_uw, zfv_vw, zfw ) 
     166      ! 
     167      IF( nn_timing == 1 )  CALL timing_stop('dyn_adv_cen2') 
    169168      ! 
    170169   END SUBROUTINE dyn_adv_cen2 

  • branches/2011/dev_NEMO_MERGE_2011/NEMOGCM/NEMO/OPA_SRC/DYN/dynadv_ubs.F90

    r2977 r3161  
    2222   USE lbclnk         ! ocean lateral boundary conditions (or mpp link) 
    2323   USE lib_mpp        ! MPP library 
     24   USE wrk_nemo_2      ! Memory Allocation 
     25   USE timing          ! Timing 
    2426 
    2527   IMPLICIT NONE 
    … …  
    6870      !! Reference : Shchepetkin & McWilliams, 2005, Ocean Modelling.  
    6971      !!---------------------------------------------------------------------- 
    70       USE wrk_nemo, ONLY:   wrk_in_use, wrk_not_released 
    7172      USE oce     , ONLY:   tsa             ! tsa used as 2 3D workspace 
    72       USE wrk_nemo, ONLY:   zfu_t  => wrk_3d_1 , zfv_t  =>wrk_3d_4 , zfu_uw =>wrk_3d_6   ! 3D workspace 
    73       USE wrk_nemo, ONLY:   zfu_f  => wrk_3d_2 , zfv_f  =>wrk_3d_5 , zfv_vw =>wrk_3d_7 
    74       USE wrk_nemo, ONLY:   zfw    => wrk_3d_3 
    75       USE wrk_nemo, ONLY:   zlu_uu => wrk_4d_1 , zlv_vv=>wrk_4d_3   ! 4D workspace 
    76       USE wrk_nemo, ONLY:   zlu_uv => wrk_4d_2 , zlv_vu=>wrk_4d_4 
    7773      ! 
    7874      INTEGER, INTENT(in) ::   kt     ! ocean time-step index 
    … …  
    8177      REAL(wp) ::   zbu, zbv    ! temporary scalars 
    8278      REAL(wp) ::   zui, zvj, zfuj, zfvi, zl_u, zl_v   ! temporary scalars 
    83       REAL(wp), POINTER, DIMENSION(:,:,:) ::  zfu, zfv 
     79      REAL(wp), POINTER, DIMENSION(:,:,:  ) ::  zfu, zfv 
     80      REAL(wp), POINTER, DIMENSION(:,:,:  ) ::  zfu_t, zfv_t, zfu_f, zfv_f, zfu_uw, zfv_vw, zfw 
     81      REAL(wp), POINTER, DIMENSION(:,:,:,:) ::  zlu_uu, zlv_vv, zlu_uv, zlv_vu 
    8482      !!---------------------------------------------------------------------- 
    85  
     83      ! 
     84      IF( nn_timing == 1 )  CALL timing_start('dyn_adv_ubs') 
     85      ! 
     86      CALL wrk_alloc( jpi, jpj, jpk,       zfu_t , zfv_t , zfu_f , zfv_f, zfu_uw, zfv_vw, zfw ) 
     87      CALL wrk_alloc( jpi, jpj, jpk, jpts, zlu_uu, zlv_vv, zlu_uv, zlv_vu                     ) 
     88      zfu => tsa(:,:,:,1)  
     89      zfv => tsa(:,:,:,2)  
     90      ! 
    8691      IF( kt == nit000 ) THEN 
    8792         IF(lwp) WRITE(numout,*) 
    … …  
    8994         IF(lwp) WRITE(numout,*) '~~~~~~~~~~~' 
    9095      ENDIF 
    91  
    92       ! Check that required workspace arrays are not already in use 
    93       IF( wrk_in_use(3, 1,2,3,4,5,6,7) .OR. wrk_in_use(4, 1,2,3,4) ) THEN 
    94          CALL ctl_stop('dyn_adv_ubs: requested workspace array unavailable')   ;   RETURN 
    95       ENDIF 
    96       ! 
    97       zfu => tsa(:,:,:,1)  
    98       zfv => tsa(:,:,:,2)  
    9996      ! 
    10097      zfu_t(:,:,:) = 0._wp 
    … …  
    258255         &                       tab3d_2=va, clinfo2=           ' Va: ', mask2=vmask, clinfo3='dyn' ) 
    259256      ! 
    260       IF( wrk_not_released(3, 1,2,3,4,5,6,7) .OR.   & 
    261           wrk_not_released(4, 1,2,3,4)       )   CALL ctl_stop('dyn_adv_ubs: failed to release workspace array') 
     257      CALL wrk_dealloc( jpi, jpj, jpk,       zfu_t , zfv_t , zfu_f , zfv_f, zfu_uw, zfv_vw, zfw ) 
     258      CALL wrk_dealloc( jpi, jpj, jpk, jpts, zlu_uu, zlv_vv, zlu_uv, zlv_vu                     ) 
     259      ! 
     260      IF( nn_timing == 1 )  CALL timing_stop('dyn_adv_ubs') 
    262261      ! 
    263262   END SUBROUTINE dyn_adv_ubs 

  • branches/2011/dev_NEMO_MERGE_2011/NEMOGCM/NEMO/OPA_SRC/DYN/dynbfr.F90

    r3116 r3161  
    1818   USE in_out_manager  ! I/O manager 
    1919   USE prtctl          ! Print control 
     20   USE timing          ! Timing 
    2021 
    2122   IMPLICIT NONE 
    … …  
    5253      !!--------------------------------------------------------------------- 
    5354      ! 
    54       IF( .not. ln_bfrimp) THEN     ! only for explicit bottom friction form 
     55      IF( nn_timing == 1 )  CALL timing_start('dyn_bfr') 
     56      ! 
     57      IF( .NOT.ln_bfrimp) THEN     ! only for explicit bottom friction form 
    5558                                    ! implicit bfr is implemented in dynzdf_imp 
    5659                                    ! H. Liu,  Sept. 2011 
    … …  
    9194        ! 
    9295      ENDIF     ! end explicit bottom friction 
     96      ! 
     97      IF( nn_timing == 1 )  CALL timing_stop('dyn_bfr') 
     98      ! 
    9399   END SUBROUTINE dyn_bfr 
    94100 

  • branches/2011/dev_NEMO_MERGE_2011/NEMOGCM/NEMO/OPA_SRC/DYN/dynhpg.F90

    r3142 r3161  
    3737   USE lbclnk          ! lateral boundary condition  
    3838   USE lib_mpp         ! MPP library 
     39   USE wrk_nemo_2      ! Memory Allocation 
     40   USE timing          ! Timing 
    3941 
    4042   IMPLICIT NONE 
    … …  
    8082      !!---------------------------------------------------------------------- 
    8183      ! 
     84      IF( nn_timing == 1 )  CALL timing_start('dyn_hpg') 
     85      ! 
    8286      IF( l_trddyn ) THEN                    ! Temporary saving of ua and va trends (l_trddyn) 
    8387         ztrdu => tsa(:,:,:,1)  
    … …  
    104108      IF(ln_ctl)   CALL prt_ctl( tab3d_1=ua, clinfo1=' hpg  - Ua: ', mask1=umask,   & 
    105109         &                       tab3d_2=va, clinfo2=       ' Va: ', mask2=vmask, clinfo3='dyn' ) 
     110      ! 
     111      IF( nn_timing == 1 )  CALL timing_stop('dyn_hpg') 
    106112      ! 
    107113   END SUBROUTINE dyn_hpg 
    … …  
    436442      !! Reference: Shchepetkin and McWilliams, J. Geophys. Res., 108(C3), 3090, 2003 
    437443      !!---------------------------------------------------------------------- 
    438       USE wrk_nemo, ONLY:   wrk_in_use, wrk_not_released 
    439444      USE oce     , ONLY:   tsa                         ! (tsa) used as 2 3D workspace 
    440       USE wrk_nemo, ONLY:   drhox => wrk_3d_1  , dzx  => wrk_3d_2 
    441       USE wrk_nemo, ONLY:   drhou => wrk_3d_3  , dzu  => wrk_3d_4 , rho_i => wrk_3d_5 
    442       USE wrk_nemo, ONLY:   drhoy => wrk_3d_6  , dzy  => wrk_3d_7 
    443       USE wrk_nemo, ONLY:   drhov => wrk_3d_8  , dzv  => wrk_3d_9 , rho_j => wrk_3d_10 
    444       USE wrk_nemo, ONLY:   drhoz => wrk_3d_11 , dzz  => wrk_3d_12  
    445       USE wrk_nemo, ONLY:   drhow => wrk_3d_13 , dzw  => wrk_3d_14 
    446       USE wrk_nemo, ONLY:   rho_k => wrk_3d_15 
    447445      !! 
    448446      INTEGER, INTENT(in) ::   kt    ! ocean time-step index 
    … …  
    453451      REAL(wp) ::   z1_12, cffv, cffy   !    "         " 
    454452      REAL(wp), POINTER, DIMENSION(:,:,:) ::  zhpi, zhpj  
    455       !!---------------------------------------------------------------------- 
    456  
    457       IF( wrk_in_use(3, 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15) ) THEN 
    458          CALL ctl_stop('dyn:hpg_djc: requested workspace arrays unavailable')   ;   RETURN 
    459       ENDIF 
    460       ! 
     453      REAL(wp), POINTER, DIMENSION(:,:,:) ::  dzx, dzy, dzz, dzu, dzv, dzw 
     454      REAL(wp), POINTER, DIMENSION(:,:,:) ::  drhox, drhoy, drhoz, drhou, drhov, drhow 
     455      REAL(wp), POINTER, DIMENSION(:,:,:) ::  rho_i, rho_j, rho_k 
     456      !!---------------------------------------------------------------------- 
     457      ! 
     458      CALL wrk_alloc( jpi, jpj, jpk, dzx  , dzy  , dzz  , dzu  , dzv  , dzw   )  
     459      CALL wrk_alloc( jpi, jpj, jpk, drhox, drhoy, drhoz, drhou, drhov, drhow )  
     460      CALL wrk_alloc( jpi, jpj, jpk, rho_i, rho_j, rho_k                      )  
    461461      zhpi => tsa(:,:,:,1)  
    462462      zhpj => tsa(:,:,:,2)  
     463      ! 
    463464 
    464465      IF( kt == nit000 ) THEN 
    … …  
    657658      END DO 
    658659      ! 
    659       IF( wrk_not_released(3, 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15) )   & 
    660          CALL ctl_stop('dyn:hpg_djc: failed to release workspace arrays') 
     660      CALL wrk_dealloc( jpi, jpj, jpk, dzx  , dzy  , dzz  , dzu  , dzv  , dzw   )  
     661      CALL wrk_dealloc( jpi, jpj, jpk, drhox, drhoy, drhoz, drhou, drhov, drhow )  
     662      CALL wrk_dealloc( jpi, jpj, jpk, rho_i, rho_j, rho_k                      )  
    661663      ! 
    662664   END SUBROUTINE hpg_djc 
    … …  
    676678      !! 
    677679      !!---------------------------------------------------------------------- 
    678  
    679       USE wrk_nemo, ONLY:   wrk_in_use, wrk_not_released 
    680680      USE oce     , ONLY:   tsa                          ! (tsa) used as 2 3D workspace 
    681       USE wrk_nemo, ONLY:   zhpi => wrk_3d_3  
    682       USE wrk_nemo, ONLY:   zu   => wrk_3d_4  
    683       USE wrk_nemo, ONLY:   zv   => wrk_3d_5 
    684       USE wrk_nemo, ONLY:   fsp  => wrk_3d_6 
    685       USE wrk_nemo, ONLY:   xsp  => wrk_3d_7 
    686       USE wrk_nemo, ONLY:   asp  => wrk_3d_8 
    687       USE wrk_nemo, ONLY:   bsp  => wrk_3d_9 
    688       USE wrk_nemo, ONLY:   csp  => wrk_3d_10 
    689       USE wrk_nemo, ONLY:   dsp  => wrk_3d_11 
    690       !! 
    691681      !!---------------------------------------------------------------------- 
    692682      !! 
    … …  
    704694      INTEGER  :: zbhitwe, zbhitns 
    705695      REAL(wp), POINTER, DIMENSION(:,:,:) ::   zdeptht, zrhh  
    706       !!---------------------------------------------------------------------- 
    707  
    708       IF( wrk_in_use(3, 3,4,5,6,7,8,9,10,11) ) THEN 
    709          CALL ctl_stop('dyn:hpg_prj: requested workspace arrays unavailable')   ;   RETURN 
    710       ENDIF 
    711       ! 
     696      REAL(wp), POINTER, DIMENSION(:,:,:) ::   zhpi, zu, zv, fsp, xsp, asp, bsp, csp, dsp 
     697      !!---------------------------------------------------------------------- 
     698      ! 
     699      CALL wrk_alloc( jpi, jpj, jpk, zhpi, zu, zv, fsp, xsp, asp, bsp, csp, dsp )  
    712700      zdeptht => tsa(:,:,:,1)  
    713701      zrhh    => tsa(:,:,:,2)  
    714  
     702      ! 
    715703      IF( kt == nit000 ) THEN 
    716704         IF(lwp) WRITE(numout,*) 
    … …  
    964952        END DO 
    965953      END DO 
    966  
    967       ! 
    968       IF( wrk_not_released(3, 3,4,5,6,7,8,9,10,11) )   & 
    969          CALL ctl_stop('dyn:hpg_prj: failed to release workspace arrays') 
     954      ! 
     955      CALL wrk_dealloc( jpi, jpj, jpk, zhpi, zu, zv, fsp, xsp, asp, bsp, csp, dsp )  
    970956      ! 
    971957   END SUBROUTINE hpg_prj 

  • branches/2011/dev_NEMO_MERGE_2011/NEMOGCM/NEMO/OPA_SRC/DYN/dynkeg.F90

    r2977 r3161  
    1919   USE lib_mpp         ! MPP library 
    2020   USE prtctl          ! Print control 
     21   USE wrk_nemo_2      ! Memory Allocation 
     22   USE timing          ! Timing 
    2123 
    2224   IMPLICIT NONE 
    … …  
    5254      !!             - save this trends (l_trddyn=T) for post-processing 
    5355      !!---------------------------------------------------------------------- 
    54       USE wrk_nemo, ONLY:   wrk_in_use, wrk_not_released 
    5556      USE oce     , ONLY:   tsa             ! tsa used as 2 3D workspace 
    56       USE wrk_nemo, ONLY:   zhke  => wrk_3d_1                 ! 3D workspace 
    5757      !! 
    5858      INTEGER, INTENT( in ) ::   kt   ! ocean time-step index 
    … …  
    6060      INTEGER  ::   ji, jj, jk   ! dummy loop indices 
    6161      REAL(wp) ::   zu, zv       ! temporary scalars 
    62       REAL(wp), POINTER, DIMENSION(:,:,:) ::   ztrdu, ztrdv  
     62      REAL(wp), POINTER, DIMENSION(:,:,:) :: zhke 
     63      REAL(wp), POINTER, DIMENSION(:,:,:) :: ztrdu, ztrdv  
    6364      !!---------------------------------------------------------------------- 
    64  
    65       IF( wrk_in_use(3,1) ) THEN 
    66          CALL ctl_stop('dyn_keg: requested workspace array is unavailable')   ;   RETURN 
    67       ENDIF 
    68  
     65      ! 
     66      IF( nn_timing == 1 )  CALL timing_start('dyn_keg') 
     67      ! 
     68      CALL wrk_alloc( jpi, jpj, jpk, zhke ) 
     69      ! 
    6970      IF( kt == nit000 ) THEN 
    7071         IF(lwp) WRITE(numout,*) 
    … …  
    140141         &                       tab3d_2=va, clinfo2=       ' Va: ', mask2=vmask, clinfo3='dyn' ) 
    141142      ! 
    142       IF( wrk_not_released(3, 1) )   CALL ctl_stop('dyn_keg: failed to release workspace array') 
     143      CALL wrk_dealloc( jpi, jpj, jpk, zhke ) 
     144      ! 
     145      IF( nn_timing == 1 )  CALL timing_stop('dyn_keg') 
    143146      ! 
    144147   END SUBROUTINE dyn_keg 

  • branches/2011/dev_NEMO_MERGE_2011/NEMOGCM/NEMO/OPA_SRC/DYN/dynldf.F90

    r2715 r3161  
    2626   USE lib_mpp        ! distribued memory computing library 
    2727   USE lbclnk         ! ocean lateral boundary conditions (or mpp link) 
     28   USE wrk_nemo_2      ! Memory Allocation 
     29   USE timing          ! Timing 
     30 
    2831 
    2932   IMPLICIT NONE 
    … …  
    5154      !! ** Purpose :   compute the lateral ocean dynamics physics. 
    5255      !!---------------------------------------------------------------------- 
    53       USE wrk_nemo, ONLY:   wrk_in_use, wrk_not_released 
    54       USE wrk_nemo, ONLY:   ztrdu => wrk_3d_1 , ztrdv => wrk_3d_2 
    5556      ! 
    5657      INTEGER, INTENT(in) ::   kt   ! ocean time-step index 
    57       !!---------------------------------------------------------------------- 
    58  
    59       IF( wrk_in_use(3, 1,2) ) THEN 
    60          CALL ctl_stop('dyn_ldf: requested workspace arrays unavailable')   ;   RETURN 
    61       ENDIF 
     58      ! 
     59      REAL(wp), POINTER, DIMENSION(:,:,:) ::  ztrdu, ztrdv 
     60      !!---------------------------------------------------------------------- 
     61      ! 
     62      IF( nn_timing == 1 )  CALL timing_start('dyn_ldf') 
    6263      ! 
    6364      IF( l_trddyn )   THEN                      ! temporary save of ta and sa trends 
     65         CALL wrk_alloc( jpi, jpj, jpk, ztrdu, ztrdv ) 
    6466         ztrdu(:,:,:) = ua(:,:,:)  
    6567         ztrdv(:,:,:) = va(:,:,:)  
    … …  
    105107         ztrdv(:,:,:) = va(:,:,:) - ztrdv(:,:,:) 
    106108         CALL trd_mod( ztrdu, ztrdv, jpdyn_trd_ldf, 'DYN', kt ) 
     109         CALL wrk_dealloc( jpi, jpj, jpk, ztrdu, ztrdv ) 
    107110      ENDIF 
    108111      !                                          ! print sum trends (used for debugging) 
    … …  
    110113         &                       tab3d_2=va, clinfo2=       ' Va: ', mask2=vmask, clinfo3='dyn' ) 
    111114      ! 
    112       IF( wrk_not_released(3, 1,2) )   CALL ctl_stop('dyn_ldf: failed to release workspace arrays') 
     115      IF( nn_timing == 1 )  CALL timing_stop('dyn_ldf') 
    113116      ! 
    114117   END SUBROUTINE dyn_ldf 

  • branches/2011/dev_NEMO_MERGE_2011/NEMOGCM/NEMO/OPA_SRC/DYN/dynldf_bilap.F90

    r2715 r3161  
    2323   USE trdmod_oce      ! ocean variables trends 
    2424   USE lbclnk          ! ocean lateral boundary conditions (or mpp link) 
     25   USE wrk_nemo_2      ! Memory Allocation 
     26   USE timing          ! Timing 
    2527 
    2628   IMPLICIT NONE 
    … …  
    7476      !!               mixing trend. 
    7577      !!---------------------------------------------------------------------- 
    76       USE wrk_nemo, ONLY:   wrk_in_use, wrk_not_released 
    77       USE wrk_nemo, ONLY:   zcu => wrk_2d_1 , zcv => wrk_2d_2   ! 3D workspace 
    78       USE wrk_nemo, ONLY:   zuf => wrk_3d_3 , zut => wrk_3d_4   ! 3D workspace 
    79       USE wrk_nemo, ONLY:   zlu => wrk_3d_5 , zlv => wrk_3d_6 
    8078      ! 
    8179      INTEGER, INTENT(in) ::   kt   ! ocean time-step index 
    … …  
    8381      INTEGER  ::   ji, jj, jk                  ! dummy loop indices 
    8482      REAL(wp) ::   zua, zva, zbt, ze2u, ze2v   ! temporary scalar 
     83      REAL(wp), POINTER, DIMENSION(:,:  ) :: zcu, zcv 
     84      REAL(wp), POINTER, DIMENSION(:,:,:) :: zuf, zut, zlu, zlv 
    8585      !!---------------------------------------------------------------------- 
    86  
    87       IF( wrk_in_use(2, 1,2) .OR. wrk_in_use(3, 3,4,5,6) ) THEN 
    88          CALL ctl_stop('dyn_ldf_bilap : requested workspace arrays unavailable')   ;   RETURN 
    89       ENDIF 
    90  
     86      ! 
     87      IF( nn_timing == 1 )  CALL timing_start('dyn_ldf_bilap') 
     88      ! 
     89      CALL wrk_alloc( jpi, jpj,      zcu, zcv           ) 
     90      CALL wrk_alloc( jpi, jpj, jpk, zuf, zut, zlu, zlv )  
     91      ! 
    9192      IF( kt == nit000 .AND. lwp ) THEN 
    9293         WRITE(numout,*) 
    … …  
    207208      END DO                                           !   End of slab 
    208209      !                                                ! =============== 
    209       IF( wrk_not_released(2, 1,2)     .OR.   & 
    210           wrk_not_released(3, 3,4,5,6) )   CALL ctl_stop('dyn_ldf_bilap: failed to release workspace arrays') 
     210      CALL wrk_dealloc( jpi, jpj,      zcu, zcv           ) 
     211      CALL wrk_dealloc( jpi, jpj, jpk, zuf, zut, zlu, zlv )  
     212      ! 
     213      IF( nn_timing == 1 )  CALL timing_stop('dyn_ldf_bilap') 
    211214      ! 
    212215   END SUBROUTINE dyn_ldf_bilap 

  • branches/2011/dev_NEMO_MERGE_2011/NEMOGCM/NEMO/OPA_SRC/DYN/dynldf_bilapg.F90

    r2977 r3161  
    2727   USE lbclnk          ! ocean lateral boundary conditions (or mpp link) 
    2828   USE prtctl          ! Print control 
     29   USE wrk_nemo_2      ! Memory Allocation 
     30   USE timing          ! Timing 
     31 
    2932 
    3033   IMPLICIT NONE 
    … …  
    8487      !!              - save the trend in (zwk3,zwk4) ('key_trddyn') 
    8588      !!---------------------------------------------------------------------- 
    86       USE wrk_nemo, ONLY:   wrk_in_use, wrk_not_released 
    87       USE wrk_nemo, ONLY:   zwk1 => wrk_3d_3 , zwk2 => wrk_3d_4   ! 3D workspace 
    8889      USE oce     , ONLY:   tsa             ! tsa used as 2 3D workspace 
    8990      ! 
    … …  
    9192      ! 
    9293      INTEGER ::   ji, jj, jk                 ! dummy loop indices 
     94      REAL(wp), POINTER, DIMENSION(:,:,:) ::  zwk1, zwk2 
    9395      REAL(wp), POINTER, DIMENSION(:,:,:) ::  zwk3, zwk4 
    9496      !!---------------------------------------------------------------------- 
    95  
    96       IF( wrk_in_use(3, 3,4) ) THEN 
    97          CALL ctl_stop('dyn_ldf_bilapg: requested workspace arrays unavailable')   ;   RETURN 
    98       ENDIF 
    99       ! 
     97      ! 
     98      IF( nn_timing == 1 )  CALL timing_start('dyn_ldf_bilapg') 
     99      ! 
     100      CALL wrk_alloc( jpi, jpj, jpk, zwk1, zwk2 )  
    100101      zwk3 => tsa(:,:,:,1)  
    101102      zwk4 => tsa(:,:,:,2)  
    … …  
    105106         IF(lwp) WRITE(numout,*) 'dyn_ldf_bilapg : horizontal biharmonic operator in s-coordinate' 
    106107         IF(lwp) WRITE(numout,*) '~~~~~~~~~~~~~~' 
    107          zwk1(:,:,:) = 0.e0   ;   zwk3(:,:,:) = 0.e0 
    108          zwk2(:,:,:) = 0.e0   ;   zwk4(:,:,:) = 0.e0 
    109108         !                                      ! allocate dyn_ldf_bilapg arrays 
    110109         IF( dyn_ldf_bilapg_alloc() /= 0 )   CALL ctl_stop('STOP', 'dyn_ldf_bilapg: failed to allocate arrays') 
    111110      ENDIF 
     111      ! 
     112      zwk1(:,:,:) = 0.e0   ;   zwk3(:,:,:) = 0.e0 
     113      zwk2(:,:,:) = 0.e0   ;   zwk4(:,:,:) = 0.e0 
    112114 
    113115      ! Laplacian of (ub,vb) multiplied by ahm 
    … …  
    133135      END DO 
    134136      ! 
    135       IF( wrk_not_released(3, 3,4) )   CALL ctl_stop('dyn_ldf_bilapg: failed to release workspace arrays') 
     137      CALL wrk_dealloc( jpi, jpj, jpk, zwk1, zwk2 )  
     138      ! 
     139      IF( nn_timing == 1 )  CALL timing_stop('dyn_ldf_bilapg') 
    136140      ! 
    137141   END SUBROUTINE dyn_ldf_bilapg 
    … …  
    179183      !!      'key_trddyn' defined: the trend is saved for diagnostics. 
    180184      !!---------------------------------------------------------------------- 
    181       USE wrk_nemo, ONLY:   wrk_in_use, wrk_not_released 
    182       USE wrk_nemo, ONLY:   ziut => wrk_2d_1 , zjuf  => wrk_2d_2 , zjvt  => wrk_2d_3 
    183       USE wrk_nemo, ONLY:   zivf => wrk_2d_4 , zdku  => wrk_2d_5 , zdk1u => wrk_2d_6 
    184       USE wrk_nemo, ONLY:   zdkv => wrk_2d_7 , zdk1v => wrk_2d_8 
    185185      !! 
    186186      REAL(wp), DIMENSION(jpi,jpj,jpk), INTENT(in   ) ::   pu , pv    ! 1st call: before horizontal velocity  
    … …  
    196196      REAL(wp) ::   zbur, zbvr, zmkt, zmkf, zuav, zvav   !   -      - 
    197197      REAL(wp) ::   zuwslpi, zuwslpj, zvwslpi, zvwslpj   !   -      - 
    198       !!---------------------------------------------------------------------- 
    199  
    200       IF( wrk_in_use(2, 1,2,3,4,5,6,7,8) ) THEN 
    201          CALL ctl_stop('dyn:ldfguv: requested workspace arrays unavailable')   ;   RETURN 
    202       END IF 
     198      ! 
     199      REAL(wp), POINTER, DIMENSION(:,:) :: ziut, zjuf, zjvt, zivf, zdku, zdk1u, zdkv, zdk1v 
     200      !!---------------------------------------------------------------------- 
     201      ! 
     202      IF( nn_timing == 1 )  CALL timing_start('ldfguv') 
     203      ! 
     204      CALL wrk_alloc( jpi, jpj, ziut, zjuf, zjvt, zivf, zdku, zdk1u, zdkv, zdk1v )  
     205      ! 
    203206      !                               ! ********** !   ! =============== 
    204207      DO jk = 1, jpkm1                ! First step !   ! Horizontal slab 
    … …  
    456459      !                                                ! =============== 
    457460 
    458       IF( wrk_not_released(2, 1,2,3,4,5,6,7,8) )   CALL ctl_stop('dyn:ldfguv: failed to release workspace arrays') 
     461      CALL wrk_dealloc( jpi, jpj, ziut, zjuf, zjvt, zivf, zdku, zdk1u, zdkv, zdk1v )  
     462      ! 
     463      IF( nn_timing == 1 )  CALL timing_stop('ldfguv') 
    459464      ! 
    460465   END SUBROUTINE ldfguv 

  • branches/2011/dev_NEMO_MERGE_2011/NEMOGCM/NEMO/OPA_SRC/DYN/dynldf_iso.F90

    r2715 r3161  
    2929   USE lib_mpp         ! MPP library 
    3030   USE prtctl          ! Print control 
     31   USE wrk_nemo_2      ! Memory Allocation 
     32   USE timing          ! Timing 
    3133 
    3234   IMPLICIT NONE 
    … …  
    105107      !!      of the rotated operator in dynzdf module 
    106108      !!---------------------------------------------------------------------- 
    107       USE wrk_nemo, ONLY:   wrk_in_use, wrk_not_released 
    108       USE wrk_nemo, ONLY:   ziut  => wrk_2d_1 , zjuf  => wrk_2d_2 , zjvt => wrk_2d_3    ! 2D workspace 
    109       USE wrk_nemo, ONLY:   zivf  => wrk_2d_4 , zdku  => wrk_2d_5 , zdkv => wrk_2d_6    ! 2D workspace 
    110       USE wrk_nemo, ONLY:   zdk1u => wrk_2d_7 , zdk1v => wrk_2d_8 
    111109      ! 
    112110      INTEGER, INTENT( in ) ::   kt   ! ocean time-step index 
    … …  
    117115      REAL(wp) ::   zcoef0, zcoef3, zcoef4, zmkt, zmkf               !   -      - 
    118116      REAL(wp) ::   zuav, zvav, zuwslpi, zuwslpj, zvwslpi, zvwslpj   !   -      - 
     117      ! 
     118      REAL(wp), POINTER, DIMENSION(:,:) :: ziut, zjuf, zjvt, zivf, zdku, zdk1u, zdkv, zdk1v 
    119119      !!---------------------------------------------------------------------- 
    120  
    121       IF( wrk_in_use(2, 1,2,3,4,5,6,7,8) ) THEN 
    122          CALL ctl_stop('dyn_ldf_iso: requested workspace arrays unavailable')   ;   RETURN 
    123       END IF 
    124  
     120      ! 
     121      IF( nn_timing == 1 )  CALL timing_start('dyn_ldf_iso') 
     122      ! 
     123      CALL wrk_alloc( jpi, jpj, ziut, zjuf, zjvt, zivf, zdku, zdk1u, zdkv, zdk1v )  
     124      ! 
    125125      IF( kt == nit000 ) THEN 
    126126         IF(lwp) WRITE(numout,*) 
    … …  
    427427      END DO                                           !   End of slab 
    428428      !                                                ! =============== 
    429  
    430       IF( wrk_not_released(2, 1,2,3,4,5,6,7,8) )   CALL ctl_stop('dyn_ldf_iso: failed to release workspace arrays') 
     429      CALL wrk_dealloc( jpi, jpj, ziut, zjuf, zjvt, zivf, zdku, zdk1u, zdkv, zdk1v )  
     430      ! 
     431      IF( nn_timing == 1 )  CALL timing_stop('dyn_ldf_iso') 
    431432      ! 
    432433   END SUBROUTINE dyn_ldf_iso 

  • branches/2011/dev_NEMO_MERGE_2011/NEMOGCM/NEMO/OPA_SRC/DYN/dynldf_lap.F90

    r2715 r3161  
    2323   USE trdmod_oce      ! ocean variables trends 
    2424   USE ldfslp          ! iso-neutral slopes  
     25   USE timing          ! Timing 
    2526 
    2627   IMPLICIT NONE 
    … …  
    6869      !!---------------------------------------------------------------------- 
    6970      ! 
     71      IF( nn_timing == 1 )  CALL timing_start('dyn_ldf_lap') 
     72      ! 
    7073      IF( kt == nit000 ) THEN 
    7174         IF(lwp) WRITE(numout,*) 
    … …  
    9598      END DO                                           !   End of slab 
    9699      !                                                ! =============== 
     100      IF( nn_timing == 1 )  CALL timing_stop('dyn_ldf_lap') 
     101      ! 
    97102   END SUBROUTINE dyn_ldf_lap 
    98103 

  • branches/2011/dev_NEMO_MERGE_2011/NEMOGCM/NEMO/OPA_SRC/DYN/dynnept.F90

    r3116 r3161  
    3030   USE phycst 
    3131   USE lbclnk 
    32  
     32   USE wrk_nemo_2      ! Memory Allocation 
    3333 
    3434   IMPLICIT NONE 
    … …  
    102102      USE iom 
    103103      !! 
    104 !!    Local dynamic allocation 
    105104      INTEGER  ::   ji, jj, jk    ! dummy loop indices 
    106       REAL(wp), ALLOCATABLE, DIMENSION(:,:)   ::   ht       ! temporary 2D workspace 
    107       REAL(wp), ALLOCATABLE, DIMENSION(:,:)   ::   htn      ! temporary 2D workspace 
    108       REAL(wp), ALLOCATABLE, DIMENSION(:,:)   ::   tscale   ! temporary 2D workspace 
    109       REAL(wp), ALLOCATABLE, DIMENSION(:,:)   ::   tsp      ! temporary 2D workspace 
    110       REAL(wp), ALLOCATABLE, DIMENSION(:,:)   ::   hur_n    ! temporary 2D workspace 
    111       REAL(wp), ALLOCATABLE, DIMENSION(:,:)   ::   hvr_n    ! temporary 2D workspace 
    112       REAL(wp), ALLOCATABLE, DIMENSION(:,:)   ::   hu_n     ! temporary 2D workspace 
    113       REAL(wp), ALLOCATABLE, DIMENSION(:,:)   ::   hv_n     ! temporary 2D workspace 
    114       REAL(wp), ALLOCATABLE, DIMENSION(:,:,:) ::   znmask   ! temporary 3D array for nmask 
    115105      REAL(wp) :: unemin,unemax,vnemin,vnemax   ! extrema of (u*, v*) fields 
    116106      REAL(wp) :: zhdivmin,zhdivmax             ! extrema of horizontal divergence of (u*, v*) fields 
    … …  
    118108      REAL(wp) :: ustar,vstar                   ! (u*, v*) before tapering in shallow water 
    119109      REAL(wp) :: hramp                         ! depth over which Neptune vel. is ramped down 
    120       !! 
    121       NAMELIST/namdyn_nept/ ln_neptsimp,      & 
    122                             ln_smooth_neptvel,& 
    123              rn_tslse,        & 
    124              rn_tslsp,        & 
    125                             ln_neptramp,      & 
    126                             rn_htrmin,        & 
    127              rn_htrmax 
    128       !!---------------------------------------------------------------------- 
    129  
     110      ! 
     111      REAL(wp), POINTER, DIMENSION(:,:  ) :: ht, htn, tscale, tsp, hur_n, hvr_n, hu_n, hv_n       
     112      REAL(wp), POINTER, DIMENSION(:,:,:) :: znmask 
     113      !! 
     114      NAMELIST/namdyn_nept/ ln_neptsimp, ln_smooth_neptvel, rn_tslse, rn_tslsp,      & 
     115                            ln_neptramp, rn_htrmin, rn_htrmax 
     116      !!---------------------------------------------------------------------- 
     117      !                                                           ! Dynamically allocate local work arrays 
     118      CALL wrk_alloc( jpi, jpj     , ht, htn, tscale, tsp, hur_n, hvr_n, hu_n, hv_n  )  
     119      CALL wrk_alloc( jpi, jpj, jpk, znmask                                          )  
     120      ! 
    130121      ! Define the (simplified) Neptune parameters 
    131122      ! ========================================== 
    … …  
    179170!!    Perform dynamic allocation of shared module variables 
    180171      IF( dynnept_alloc() /= 0 )   CALL ctl_warn('dynnept_alloc: array allocate failed.') 
    181  
    182 !!    Dynamically allocate local work arrays 
    183       ALLOCATE( ht(jpi,jpj), htn(jpi,jpj), tscale(jpi,jpj), tsp(jpi,jpj),      & 
    184          &      hur_n(jpi,jpj), hvr_n(jpi,jpj), hu_n(jpi,jpj), hv_n(jpi,jpj),  & 
    185          &      znmask(jpi,jpj,jpk) ) 
    186172 
    187173      IF( .not. ln_rstart ) THEN      ! If restarting, these arrays are read from the restart file 
    … …  
    350336!!    Deallocate temporary workspace arrays, which are all local to 
    351337!!    this routine, except where passed as arguments to other routines 
    352       DEALLOCATE( ht, htn, tscale, tsp, hur_n, hvr_n, hu_n, hv_n, znmask ) 
    353  
     338      CALL wrk_dealloc( jpi, jpj     , ht, htn, tscale, tsp, hur_n, hvr_n, hu_n, hv_n  )  
     339      CALL wrk_dealloc( jpi, jpj, jpk, znmask                                          )  
     340      ! 
    354341   END SUBROUTINE dyn_nept_init 
    355342 
    … …  
    393380      INTEGER  ::   ji, jj, jk          ! dummy loop indices 
    394381      !!---------------------------------------------------------------------- 
    395  
    396  
     382      !     
    397383      IF(lwp) WRITE(numout,*) 
    398384      IF(lwp) WRITE(numout,*) 'dyn_nept_div_cur_init :' 
    … …  
    501487         ENDIF 
    502488         ! 
    503     lastkt = kt        ! Store kt 
    504     ! 
     489         lastkt = kt     ! Store kt 
     490        ! 
    505491      ENDIF 
    506492      ! 
    … …  
    530516 
    531517 
    532    SUBROUTINE dyn_nept_smooth_vel( htold, htnew, option ) 
     518   SUBROUTINE dyn_nept_smooth_vel( htold, htnew, ld_option ) 
    533519 
    534520      !!---------------------------------------------------------------------- 
    … …  
    539525      !! ** Action : - Updates the array htnew (output) with a smoothed 
    540526      !!               version of the (input) array htold. Form of smoothing 
    541       !!               algorithm is controlled by the (logical) argument option. 
    542       !!---------------------------------------------------------------------- 
    543  
    544       INTEGER                                   ::   ji, jj  ! dummy loop indices 
    545       REAL(wp), DIMENSION(jpi,jpj), INTENT(IN)  ::   htold   ! temporary 2D workspace 
    546       LOGICAL, INTENT(IN)                       ::   option  ! temporary 2D workspace 
    547       REAL(wp), DIMENSION(jpi,jpj)              ::   htnew   ! temporary 2D workspace 
    548       REAL(wp), ALLOCATABLE, DIMENSION(:,:)     ::   work    ! temporary 2D workspace 
    549       INTEGER,  ALLOCATABLE, DIMENSION(:,:)     ::   nb      ! temporary 2D workspace 
    550       INTEGER,  ALLOCATABLE, DIMENSION(:,:)     ::   iwork   ! temporary 2D workspace 
    551  
    552 !!    Dynamically allocate local work arrays 
    553       ALLOCATE( work(jpi,jpj), nb(jpi,jpj), iwork(jpi,jpj) ) 
    554  
     527      !!               algorithm is controlled by the (logical) argument ld_option. 
     528      !!---------------------------------------------------------------------- 
     529      REAL(wp), DIMENSION(jpi,jpj), INTENT(in   )  ::  htold      ! temporary 2D workspace 
     530      LOGICAL                     , INTENT(in   )  ::  ld_option  ! temporary 2D workspace 
     531      REAL(wp), DIMENSION(jpi,jpj), INTENT(inout)  ::  htnew      ! temporary 2D workspace 
     532      ! 
     533      INTEGER                           ::  ji, jj  ! dummy loop indices 
     534      INTEGER , POINTER, DIMENSION(:,:) ::  nb, iwork 
     535      REAL(wp), POINTER, DIMENSION(:,:) ::  work    ! temporary 2D workspace 
     536      !!---------------------------------------------------------------------- 
     537      ! 
     538      CALL wrk_alloc( jpi, jpj, nb, iwork )  
     539      CALL wrk_alloc( jpi, jpj, work      )  
     540      ! 
    555541      iwork(:,:) = 0 
    556542 
    … …  
    565551      !! htnew contains valid ocean depths from htold, or zero 
    566552 
    567       !! set work to a smoothed/averaged version of htnew; choice controlled by option 
     553      !! set work to a smoothed/averaged version of htnew; choice controlled by ld_option 
    568554      !! nb is set to the sum of the weights of the valid values used in work 
    569       IF( option ) THEN 
     555      IF( ld_option ) THEN 
    570556 
    571557         !! Apply scale-selective smoothing in determining work from htnew 
    … …  
    615601      END WHERE 
    616602 
    617 !!    Deallocate temporary workspace arrays, all local to this routine 
    618       DEALLOCATE( work, nb, iwork ) 
    619  
     603      !!    Deallocate temporary workspace arrays, all local to this routine 
     604      CALL wrk_dealloc( jpi, jpj, nb, iwork )  
     605      CALL wrk_dealloc( jpi, jpj, work      )  
     606      ! 
    620607   END SUBROUTINE dyn_nept_smooth_vel 
    621608 

  • branches/2011/dev_NEMO_MERGE_2011/NEMOGCM/NEMO/OPA_SRC/DYN/dynnxt.F90

    r3116 r3161  
    4444   USE agrif_opa_interp 
    4545#endif 
     46   USE timing          ! Timing 
    4647 
    4748   IMPLICIT NONE 
    … …  
    105106      REAL(wp), POINTER, DIMENSION(:,:,:) ::  ze3u_f, ze3v_f  
    106107      !!---------------------------------------------------------------------- 
    107  
     108      ! 
     109      IF( nn_timing == 1 )  CALL timing_start('dyn_nxt') 
    108110      ! 
    109111      ze3u_f => tsa(:,:,:,1)  
    … …  
    279281         &                       tab3d_2=vn, clinfo2=' Vn: '       , mask2=vmask ) 
    280282      !  
     283      IF( nn_timing == 1 )  CALL timing_stop('dyn_nxt') 
     284      ! 
    281285   END SUBROUTINE dyn_nxt 
    282286 

  • branches/2011/dev_NEMO_MERGE_2011/NEMOGCM/NEMO/OPA_SRC/DYN/dynspg.F90

    r3116 r3161  
    2828   USE lib_mpp        ! MPP library 
    2929   USE solver          ! solver initialization 
     30   USE wrk_nemo_2      ! Memory Allocation 
     31   USE timing          ! Timing 
     32 
    3033 
    3134   IMPLICIT NONE 
    … …  
    7376      !!        of the physical meaning of the results.  
    7477      !!---------------------------------------------------------------------- 
    75       USE wrk_nemo, ONLY:   wrk_in_use, wrk_not_released 
    76       USE wrk_nemo, ONLY:   ztrdu => wrk_3d_4 , ztrdv => wrk_3d_5    ! 3D workspace 
    7778      ! 
    7879      INTEGER, INTENT(in   ) ::   kt       ! ocean time-step index 
    … …  
    8182      INTEGER  ::   ji, jj, jk                             ! dummy loop indices 
    8283      REAL(wp) ::   z2dt, zg_2                             ! temporary scalar 
    83       !!---------------------------------------------------------------------- 
    84  
    85       IF( wrk_in_use(3, 4,5) ) THEN 
    86          CALL ctl_stop('dyn_spg: requested workspace arrays unavailable')   ;   RETURN 
    87       ENDIF 
     84      REAL(wp), POINTER, DIMENSION(:,:,:) ::  ztrdu, ztrdv 
     85      !!---------------------------------------------------------------------- 
     86      ! 
     87      IF( nn_timing == 1 )  CALL timing_start('dyn_spg') 
     88      ! 
    8889 
    8990!!gm NOTA BENE : the dynspg_exp and dynspg_ts should be modified so that  
    … …  
    9394 
    9495      IF( l_trddyn )   THEN                      ! temporary save of ta and sa trends 
     96         CALL wrk_alloc( jpi, jpj, jpk, ztrdu, ztrdv )  
    9597         ztrdu(:,:,:) = ua(:,:,:) 
    9698         ztrdv(:,:,:) = va(:,:,:) 
    … …  
    148150         END SELECT 
    149151         CALL trd_mod( ztrdu, ztrdv, jpdyn_trd_spg, 'DYN', kt ) 
     152         ! 
     153         CALL wrk_dealloc( jpi, jpj, jpk, ztrdu, ztrdv )  
    150154      ENDIF 
    151155      !                                          ! print mean trends (used for debugging) 
    … …  
    153157         &                       tab3d_2=va, clinfo2=       ' Va: ', mask2=vmask, clinfo3='dyn' ) 
    154158      ! 
    155       IF( wrk_not_released(3, 4,5) )   CALL ctl_stop('dyn_spg: failed to release workspace arrays') 
     159      IF( nn_timing == 1 )  CALL timing_stop('dyn_spg') 
    156160      ! 
    157161   END SUBROUTINE dyn_spg 
    … …  
    167171      INTEGER ::   ioptio 
    168172      !!---------------------------------------------------------------------- 
    169  
     173      ! 
     174      IF( nn_timing == 1 )  CALL timing_start('dyn_spg_init') 
     175      ! 
    170176      IF(lwp) THEN             ! Control print 
    171177         WRITE(numout,*) 
    … …  
    220226         IF( .NOT.ln_dynadv_vec )   CALL ctl_stop( 'Flux form not implemented for this free surface formulation' ) 
    221227      ENDIF 
    222  
     228      ! 
     229      IF( nn_timing == 1 )  CALL timing_stop('dyn_spg_init') 
    223230      ! 
    224231   END SUBROUTINE dyn_spg_init 

  • branches/2011/dev_NEMO_MERGE_2011/NEMOGCM/NEMO/OPA_SRC/DYN/dynspg_exp.F90

    r3116 r3161  
    2828   USE iom             ! I/O library 
    2929   USE restart         ! only for lrst_oce 
     30   USE timing          ! Timing 
     31 
    3032 
    3133   IMPLICIT NONE 
    … …  
    6567      INTEGER ::   ji, jj, jk   ! dummy loop indices 
    6668      !!---------------------------------------------------------------------- 
    67  
     69      ! 
     70      IF( nn_timing == 1 )  CALL timing_start('dyn_spg_exp') 
     71      ! 
    6872      IF( kt == nit000 ) THEN 
    6973         IF(lwp) WRITE(numout,*) 
    … …  
    100104      ENDIF 
    101105      ! 
     106      IF( nn_timing == 1 )  CALL timing_stop('dyn_spg_exp') 
     107      ! 
    102108   END SUBROUTINE dyn_spg_exp 
    103109 

  • branches/2011/dev_NEMO_MERGE_2011/NEMOGCM/NEMO/OPA_SRC/DYN/dynspg_flt.F90

    r3116 r3161  
    4949   USE agrif_opa_interp 
    5050#endif 
     51   USE timing          ! Timing 
    5152 
    5253   IMPLICIT NONE 
    … …  
    113114      !!---------------------------------------------------------------------- 
    114115      ! 
     116      IF( nn_timing == 1 )  CALL timing_start('dyn_spg_flt') 
     117      ! 
    115118      zub => tsa(:,:,:,1)  
    116119      zvb => tsa(:,:,:,2)  
    … …  
    350353      IF( lrst_oce ) CALL flt_rst( kt, 'WRITE' ) 
    351354      ! 
     355      IF( nn_timing == 1 )  CALL timing_stop('dyn_spg_flt') 
     356      ! 
    352357   END SUBROUTINE dyn_spg_flt 
    353358 

  • branches/2011/dev_NEMO_MERGE_2011/NEMOGCM/NEMO/OPA_SRC/DYN/dynspg_ts.F90

    r3156 r3161  
    4242   USE iom             ! IOM library 
    4343   USE restart         ! only for lrst_oce 
    44    USE zdf_oce 
     44   USE zdf_oce         ! Vertical diffusion 
     45   USE wrk_nemo_2      ! Memory Allocation 
     46   USE timing          ! Timing 
     47 
    4548 
    4649   IMPLICIT NONE 
    … …  
    108111      !! References : Griffies et al., (2003): A technical guide to MOM4. NOAA/GFDL 
    109112      !!--------------------------------------------------------------------- 
    110       USE wrk_nemo, ONLY:   wrk_in_use, wrk_not_released 
    111       USE wrk_nemo, ONLY:   zsshun_e => wrk_2d_1 , zsshb_e  => wrk_2d_2  , zhdiv => wrk_2d_3 
    112       USE wrk_nemo, ONLY:   zsshvn_e => wrk_2d_4 , zssh_sum => wrk_2d_5 
    113       USE wrk_nemo, ONLY:   zcu => wrk_2d_6  , zwx   => wrk_2d_7  , zua   => wrk_2d_8  , zbfru  => wrk_2d_9 
    114       USE wrk_nemo, ONLY:   zcv => wrk_2d_10 , zwy   => wrk_2d_11 , zva   => wrk_2d_12 , zbfrv  => wrk_2d_13 
    115       USE wrk_nemo, ONLY:   zun => wrk_2d_14 , zun_e => wrk_2d_15 , zub_e => wrk_2d_16 , zu_sum => wrk_2d_17 
    116       USE wrk_nemo, ONLY:   zvn => wrk_2d_18 , zvn_e => wrk_2d_19 , zvb_e => wrk_2d_20 , zv_sum => wrk_2d_21 
    117113      ! 
    118114      INTEGER, INTENT(in)  ::   kt   ! ocean time-step index 
    … …  
    127123      REAL(wp) ::   zv_spg, zv_cor, zv_sld, zv_asp            !   -      - 
    128124      REAL(wp) ::   ua_btm, va_btm                            !   -      - 
     125      ! 
     126      REAL(wp), POINTER, DIMENSION(:,:) :: zsshun_e, zsshvn_e, zsshb_e, zssh_sum, zhdiv  
     127      REAL(wp), POINTER, DIMENSION(:,:) :: zua, zva, zun, zvn, zun_e, zvn_e, zub_e, zvb_e  
     128      REAL(wp), POINTER, DIMENSION(:,:) :: zcu, zcv, zwx, zwy, zbfru, zbfrv, zu_sum, zv_sum 
    129129      !!---------------------------------------------------------------------- 
    130  
    131       IF( wrk_in_use(2,  1, 2, 3, 4, 5, 6, 7, 8, 9,10,     & 
    132          &              11,12,13,14,15,16,17,18,19,20,21 ) ) THEN 
    133          CALL ctl_stop( 'dyn_spg_ts: requested workspace arrays unavailable' )   ;   RETURN 
    134       ENDIF 
    135  
     130      ! 
     131      IF( nn_timing == 1 )  CALL timing_start('dyn_spg_ts') 
     132      ! 
     133      CALL wrk_alloc( jpi, jpj, zsshun_e, zsshvn_e, zsshb_e, zssh_sum, zhdiv     ) 
     134      CALL wrk_alloc( jpi, jpj, zua, zva, zun, zvn, zun_e, zvn_e, zub_e, zvb_e   ) 
     135      CALL wrk_alloc( jpi, jpj, zcu, zcv, zwx, zwy, zbfru, zbfrv, zu_sum, zv_sum ) 
     136      ! 
    136137      IF( kt == nit000 ) THEN             !* initialisation 
    137138         ! 
    … …  
    680681      IF( lrst_oce )   CALL ts_rst( kt, 'WRITE' ) 
    681682      ! 
    682       ! 
    683       IF( wrk_not_released(2,  1, 2, 3, 4, 5, 6, 7, 8, 9,10,         & 
    684          &                    11,12,13,14,15,16,17,18,19,20,21) )    & 
    685          CALL ctl_stop('dyn_spg_ts: failed to release workspace arrays') 
     683      CALL wrk_dealloc( jpi, jpj, zsshun_e, zsshvn_e, zsshb_e, zssh_sum, zhdiv     ) 
     684      CALL wrk_dealloc( jpi, jpj, zua, zva, zun, zvn, zun_e, zvn_e, zub_e, zvb_e   ) 
     685      CALL wrk_dealloc( jpi, jpj, zcu, zcv, zwx, zwy, zbfru, zbfrv, zu_sum, zv_sum ) 
     686      ! 
     687      IF( nn_timing == 1 )  CALL timing_stop('dyn_spg_ts') 
    686688      ! 
    687689   END SUBROUTINE dyn_spg_ts 

  • branches/2011/dev_NEMO_MERGE_2011/NEMOGCM/NEMO/OPA_SRC/DYN/dynvor.F90

    r3111 r3161  
    3434   USE prtctl         ! Print control 
    3535   USE in_out_manager ! I/O manager 
    36    USE lib_mpp 
     36   USE lib_mpp        ! MPP library 
     37   USE wrk_nemo_2     ! Memory Allocation 
     38   USE timing         ! Timing 
     39 
    3740 
    3841   IMPLICIT NONE 
    … …  
    7881      REAL(wp), POINTER, DIMENSION(:,:,:) ::  ztrdu, ztrdv 
    7982      !!---------------------------------------------------------------------- 
     83      ! 
     84      IF( nn_timing == 1 )  CALL timing_start('dyn_vor') 
    8085      ! 
    8186      IF( l_trddyn )   THEN 
    … …  
    183188         &                     tab3d_2=va, clinfo2=       ' Va: ', mask2=vmask, clinfo3='dyn' ) 
    184189      ! 
     190      IF( nn_timing == 1 )  CALL timing_stop('dyn_vor') 
     191      ! 
    185192   END SUBROUTINE dyn_vor 
    186193 
    … …  
    212219      !! References : Sadourny, r., 1975, j. atmos. sciences, 32, 680-689. 
    213220      !!---------------------------------------------------------------------- 
    214       USE wrk_nemo, ONLY:   wrk_in_use, wrk_not_released 
    215       USE wrk_nemo, ONLY:   zwx => wrk_2d_1 , zwy => wrk_2d_2 , zwz => wrk_2d_3     ! 2D workspace 
    216221      ! 
    217222      INTEGER , INTENT(in   )                         ::   kt     ! ocean time-step index 
    … …  
    223228      INTEGER  ::   ji, jj, jk   ! dummy loop indices 
    224229      REAL(wp) ::   zx1, zy1, zfact2, zx2, zy2   ! local scalars 
    225       !!---------------------------------------------------------------------- 
    226  
    227       IF( wrk_in_use(2, 1,2,3) ) THEN 
    228          CALL ctl_stop('dyn:vor_ene: requested workspace arrays unavailable')   ;   RETURN 
    229       ENDIF 
    230  
     230      REAL(wp), POINTER, DIMENSION(:,:) :: zwx, zwy, zwz 
     231      !!---------------------------------------------------------------------- 
     232      ! 
     233      IF( nn_timing == 1 )  CALL timing_start('vor_ene') 
     234      ! 
     235      CALL wrk_alloc( jpi, jpj, zwx, zwy, zwz )  
     236      ! 
    231237      IF( kt == nit000 ) THEN 
    232238         IF(lwp) WRITE(numout,*) 
    … …  
    292298      END DO                                           !   End of slab 
    293299      !                                                ! =============== 
    294       IF( wrk_not_released(2, 1,2,3) )   CALL ctl_stop('dyn:vor_ene: failed to release workspace arrays') 
     300      CALL wrk_dealloc( jpi, jpj, zwx, zwy, zwz )  
     301      ! 
     302      IF( nn_timing == 1 )  CALL timing_stop('vor_ene') 
    295303      ! 
    296304   END SUBROUTINE vor_ene 
    … …  
    328336      !! References : Sadourny, r., 1975, j. atmos. sciences, 32, 680-689. 
    329337      !!---------------------------------------------------------------------- 
    330       USE wrk_nemo, ONLY:   wrk_in_use, wrk_not_released 
    331       USE wrk_nemo, ONLY:   zwx => wrk_2d_4 , zwy => wrk_2d_5 , zwz => wrk_2d_6 , zww => wrk_2d_7   ! 2D workspace 
    332338      ! 
    333339      INTEGER, INTENT(in) ::   kt   ! ocean timestep index 
    … …  
    336342      REAL(wp) ::   zfact1, zua, zcua, zx1, zy1   ! local scalars 
    337343      REAL(wp) ::   zfact2, zva, zcva, zx2, zy2   !   -      - 
    338       !!---------------------------------------------------------------------- 
    339  
    340       IF( wrk_in_use(2, 4,5,6,7) ) THEN 
    341          CALL ctl_stop('dyn:vor_mix: requested workspace arrays unavailable')   ;   RETURN 
    342       ENDIF 
    343  
     344      REAL(wp), POINTER, DIMENSION(:,:) :: zwx, zwy, zwz, zww 
     345      !!---------------------------------------------------------------------- 
     346      ! 
     347      IF( nn_timing == 1 )  CALL timing_start('vor_mix') 
     348      ! 
     349      CALL wrk_alloc( jpi, jpj, zwx, zwy, zwz, zww )  
     350      ! 
    344351      IF( kt == nit000 ) THEN 
    345352         IF(lwp) WRITE(numout,*) 
    … …  
    412419      END DO                                           !   End of slab 
    413420      !                                                ! =============== 
    414       IF( wrk_not_released(2, 4,5,6,7) )   CALL ctl_stop('dyn:vor_mix: failed to release workspace arrays') 
     421      CALL wrk_dealloc( jpi, jpj, zwx, zwy, zwz, zww )  
     422      ! 
     423      IF( nn_timing == 1 )  CALL timing_stop('vor_mix') 
    415424      ! 
    416425   END SUBROUTINE vor_mix 
    … …  
    443452      !! References : Sadourny, r., 1975, j. atmos. sciences, 32, 680-689. 
    444453      !!---------------------------------------------------------------------- 
    445       USE wrk_nemo, ONLY:   wrk_in_use, wrk_not_released 
    446       USE wrk_nemo, ONLY:   zwx => wrk_2d_4, zwy => wrk_2d_5, zwz => wrk_2d_6    ! 2D workspace 
    447454      ! 
    448455      INTEGER , INTENT(in   )                         ::   kt     ! ocean time-step index 
    … …  
    454461      INTEGER  ::   ji, jj, jk           ! dummy loop indices 
    455462      REAL(wp) ::   zfact1, zuav, zvau   ! temporary scalars 
    456       !!---------------------------------------------------------------------- 
    457        
    458       IF( wrk_in_use(2, 4,5,6) ) THEN 
    459          CALL ctl_stop('dyn:vor_ens: requested workspace arrays unavailable')   ;   RETURN 
    460       END IF 
    461  
     463      REAL(wp), POINTER, DIMENSION(:,:) :: zwx, zwy, zwz, zww 
     464      !!---------------------------------------------------------------------- 
     465      ! 
     466      IF( nn_timing == 1 )  CALL timing_start('vor_ens') 
     467      ! 
     468      CALL wrk_alloc( jpi, jpj, zwx, zwy, zwz )  
     469      ! 
    462470      IF( kt == nit000 ) THEN 
    463471         IF(lwp) WRITE(numout,*) 
    … …  
    531539      END DO                                           !   End of slab 
    532540      !                                                ! =============== 
    533       IF( wrk_not_released(2, 4,5,6) )   CALL ctl_stop('dyn:vor_ens: failed to release workspace arrays') 
     541      CALL wrk_dealloc( jpi, jpj, zwx, zwy, zwz )  
     542      ! 
     543      IF( nn_timing == 1 )  CALL timing_stop('vor_ens') 
    534544      ! 
    535545   END SUBROUTINE vor_ens 
    … …  
    555565      !! References : Arakawa and Lamb 1980, Mon. Wea. Rev., 109, 18-36 
    556566      !!---------------------------------------------------------------------- 
    557       USE wrk_nemo, ONLY:   wrk_in_use, wrk_not_released 
    558       USE wrk_nemo, ONLY:   zwx  => wrk_2d_1 , zwy  => wrk_2d_2 ,  zwz => wrk_2d_3     ! 2D workspace 
    559       USE wrk_nemo, ONLY:   ztnw => wrk_2d_4 , ztne => wrk_2d_5  
    560       USE wrk_nemo, ONLY:   ztsw => wrk_2d_6 , ztse => wrk_2d_7 
    561 #if defined key_vvl 
    562       USE wrk_nemo, ONLY:   ze3f => wrk_3d_1                                           ! 3D workspace (lk_vvl=T) 
    563 #endif 
    564567      ! 
    565568      INTEGER , INTENT(in   )                         ::   kt     ! ocean time-step index 
    … …  
    569572      REAL(wp), INTENT(inout), DIMENSION(jpi,jpj,jpk) ::   pva    ! total v-trend 
    570573      !! 
    571       INTEGER  ::   ji, jj, jk         ! dummy loop indices 
    572       INTEGER  ::   ierr               ! local integer 
    573       REAL(wp) ::   zfac12, zua, zva   ! local scalars 
     574      INTEGER  ::   ji, jj, jk                                    ! dummy loop indices 
     575      INTEGER  ::   ierr                                          ! local integer 
     576      REAL(wp) ::   zfac12, zua, zva                              ! local scalars 
     577      !                                                           !  3D workspace  
     578      REAL(wp), POINTER    , DIMENSION(:,:  )         :: zwx, zwy, zwz 
     579      REAL(wp), POINTER    , DIMENSION(:,:  )         :: ztnw, ztne, ztsw, ztse 
     580#if defined key_vvl 
     581      REAL(wp), POINTER    , DIMENSION(:,:,:)         :: ze3f     !  3D workspace (lk_vvl=T) 
     582#endif 
    574583#if ! defined key_vvl 
    575       REAL(wp), ALLOCATABLE, DIMENSION(:,:,:), SAVE ::  ze3f     ! lk_vvl=F, ze3f=1/e3f saved one for all 
     584      REAL(wp), ALLOCATABLE, DIMENSION(:,:,:), SAVE   :: ze3f     ! lk_vvl=F, ze3f=1/e3f saved one for all 
    576585#endif 
    577586      !!---------------------------------------------------------------------- 
    578  
    579       IF( wrk_in_use(2, 1,2,3,4,5,6,7) .OR. wrk_in_use(3, 1) ) THEN 
    580          CALL ctl_stop('dyn:vor_een: requested workspace arrays unavailable')   ;   RETURN 
    581       ENDIF 
    582  
     587      ! 
     588      IF( nn_timing == 1 )  CALL timing_start('vor_een') 
     589      ! 
     590      CALL wrk_alloc( jpi, jpj,      zwx , zwy , zwz        )  
     591      CALL wrk_alloc( jpi, jpj,      ztnw, ztne, ztsw, ztse )  
     592#if defined key_vvl 
     593      CALL wrk_alloc( jpi, jpj, jpk, ze3f                   ) 
     594#endif 
     595      ! 
    583596      IF( kt == nit000 ) THEN 
    584597         IF(lwp) WRITE(numout,*) 
    … …  
    678691      END DO                                           !   End of slab 
    679692      !                                                ! =============== 
    680       IF( wrk_not_released(2, 1,2,3,4,5,6,7) .OR.   & 
    681           wrk_not_released(3, 1)             )   CALL ctl_stop('dyn:vor_een: failed to release workspace arrays') 
     693      CALL wrk_dealloc( jpi, jpj,      zwx , zwy , zwz        )  
     694      CALL wrk_dealloc( jpi, jpj,      ztnw, ztne, ztsw, ztse )  
     695#if defined key_vvl 
     696      CALL wrk_dealloc( jpi, jpj, jpk, ze3f                   ) 
     697#endif 
     698      ! 
     699      IF( nn_timing == 1 )  CALL timing_stop('vor_een') 
    682700      ! 
    683701   END SUBROUTINE vor_een 
    … …  
    713731      ! If energy, enstrophy or mixed advection of momentum in vector form change the value for masks 
    714732      ! at angles with three ocean points and one land point 
    715       IF( ln_vorlat .AND. (ln_dynvor_ene .OR. ln_dynvor_ens .OR. ln_dynvor_mix) ) THEN 
     733      IF( ln_vorlat .AND. ( ln_dynvor_ene .OR. ln_dynvor_ens .OR. ln_dynvor_mix ) ) THEN 
    716734         DO jk = 1, jpk 
    717735            DO jj = 2, jpjm1 

  • branches/2011/dev_NEMO_MERGE_2011/NEMOGCM/NEMO/OPA_SRC/DYN/dynzad.F90

    r2977 r3161  
    2121   USE lib_mpp         ! MPP library 
    2222   USE prtctl         ! Print control 
     23   USE wrk_nemo_2      ! Memory Allocation 
     24   USE timing          ! Timing 
    2325 
    2426   IMPLICIT NONE 
    … …  
    5355      !!              - Save the trends in (ztrdu,ztrdv) ('key_trddyn') 
    5456      !!---------------------------------------------------------------------- 
    55       USE wrk_nemo, ONLY:   wrk_in_use, wrk_not_released 
    56       USE wrk_nemo, ONLY:   zww   => wrk_2d_1                        ! 2D workspace 
    5757      USE oce     , ONLY:   tsa             ! tsa used as 2 3D workspace 
    58       USE wrk_nemo, ONLY:   ztrdu => wrk_3d_1 , ztrdv => wrk_3d_2    ! 3D workspace 
    5958      !! 
    6059      INTEGER, INTENT(in) ::   kt   ! ocean time-step inedx 
    … …  
    6362      REAL(wp) ::   zua, zva        ! temporary scalars 
    6463      REAL(wp), POINTER, DIMENSION(:,:,:) ::  zwuw , zwvw 
     64      REAL(wp), POINTER, DIMENSION(:,:  ) ::  zww 
     65      REAL(wp), POINTER, DIMENSION(:,:,:) ::  ztrdu, ztrdv 
    6566      !!---------------------------------------------------------------------- 
    66        
    67       IF( wrk_in_use(2, 1) .OR. wrk_in_use(3, 1,2) ) THEN  
    68          CALL ctl_stop('dyn_zad: requested workspace arrays unavailable')   ;   RETURN 
    69       ENDIF 
     67      ! 
     68      IF( nn_timing == 1 )  CALL timing_start('dyn_zad') 
     69      ! 
     70      CALL wrk_alloc( jpi, jpj, zww )  
    7071      ! 
    7172      zwuw  => tsa(:,:,:,1)  
    … …  
    7879 
    7980      IF( l_trddyn )   THEN         ! Save ua and va trends 
     81         CALL wrk_alloc( jpi, jpj, jpk, ztrdu, ztrdv )  
    8082         ztrdu(:,:,:) = ua(:,:,:)  
    8183         ztrdv(:,:,:) = va(:,:,:)  
    … …  
    121123         ztrdv(:,:,:) = va(:,:,:) - ztrdv(:,:,:) 
    122124         CALL trd_mod(ztrdu, ztrdv, jpdyn_trd_zad, 'DYN', kt) 
     125         CALL wrk_dealloc( jpi, jpj, jpk, ztrdu, ztrdv )  
    123126      ENDIF 
    124127      !                             ! Control print 
    … …  
    126129         &                       tab3d_2=va, clinfo2=       ' Va: ', mask2=vmask, clinfo3='dyn' ) 
    127130      ! 
    128       IF( wrk_not_released(2, 1)   .OR.   & 
    129           wrk_not_released(3, 1,2) )   CALL ctl_stop('dyn_zad: failed to release workspace arrays') 
     131      CALL wrk_dealloc( jpi, jpj, zww )  
     132      ! 
     133      IF( nn_timing == 1 )  CALL timing_stop('dyn_zad') 
    130134      ! 
    131135   END SUBROUTINE dyn_zad 

  • branches/2011/dev_NEMO_MERGE_2011/NEMOGCM/NEMO/OPA_SRC/DYN/dynzdf.F90

    r2715 r3161  
    2525   USE lib_mpp         ! MPP library 
    2626   USE prtctl          ! Print control 
     27   USE wrk_nemo_2      ! Memory Allocation 
     28   USE timing          ! Timing 
    2729 
    2830   IMPLICIT NONE 
    … …  
    5355      !! ** Purpose :   compute the vertical ocean dynamics physics. 
    5456      !!--------------------------------------------------------------------- 
    55       USE wrk_nemo, ONLY:   wrk_in_use, wrk_not_released 
    56       USE wrk_nemo, ONLY:   ztrdu => wrk_3d_1 , ztrdv => wrk_3d_2    ! 3D workspace 
    5757      !! 
    5858      INTEGER, INTENT( in ) ::   kt      ! ocean time-step index 
     59      ! 
     60      REAL(wp), POINTER, DIMENSION(:,:,:) ::  ztrdu, ztrdv 
    5961      !!--------------------------------------------------------------------- 
    60  
    61       IF( wrk_in_use(3, 1,2) ) THEN 
    62          CALL ctl_stop('dyn_zdf: requested workspace arrays unavailable')   ;   RETURN 
    63       END IF 
     62      ! 
     63      IF( nn_timing == 1 )  CALL timing_start('dyn_zdf') 
     64      ! 
    6465      !                                          ! set time step 
    6566      IF( neuler == 0 .AND. kt == nit000     ) THEN   ;   r2dt =      rdt   ! = rdtra (restart with Euler time stepping) 
    … …  
    6869 
    6970      IF( l_trddyn )   THEN                      ! temporary save of ta and sa trends 
     71         CALL wrk_alloc( jpi, jpj, jpk, ztrdu, ztrdv )  
    7072         ztrdu(:,:,:) = ua(:,:,:) 
    7173         ztrdv(:,:,:) = va(:,:,:) 
    … …  
    9092         ztrdv(:,:,:) = va(:,:,:) - ztrdv(:,:,:) 
    9193         CALL trd_mod( ztrdu, ztrdv, jpdyn_trd_zdf, 'DYN', kt ) 
     94         ! 
     95         CALL wrk_dealloc( jpi, jpj, jpk, ztrdu, ztrdv )  
    9296      ENDIF 
    9397      !                                          ! print mean trends (used for debugging) 
    … …  
    9599            &                    tab3d_2=va, clinfo2=       ' Va: ', mask2=vmask, clinfo3='dyn' ) 
    96100      ! 
    97       IF( wrk_not_released(3, 1,2) )   CALL ctl_stop('dyn_zdf: failed to release workspace arrays') 
     101      IF( nn_timing == 1 )  CALL timing_stop('dyn_zdf') 
    98102      ! 
    99103   END SUBROUTINE dyn_zdf 

  • branches/2011/dev_NEMO_MERGE_2011/NEMOGCM/NEMO/OPA_SRC/DYN/dynzdf_exp.F90

    r2977 r3161  
    2222   USE in_out_manager  ! I/O manager 
    2323   USE lib_mpp         ! MPP library 
     24   USE wrk_nemo_2      ! Memory Allocation 
     25   USE timing          ! Timing 
     26 
    2427 
    2528   IMPLICIT NONE 
    … …  
    5457      !! ** Action : - Update (ua,va) with the vertical diffusive trend 
    5558      !!--------------------------------------------------------------------- 
    56       USE wrk_nemo, ONLY:   wrk_in_use, wrk_not_released 
    5759      USE oce     , ONLY:   tsa             ! tsa used as 2 3D workspace 
    58       USE wrk_nemo, ONLY:   zwz => wrk_3d_3 , zww => wrk_3d_4   ! 3D workspace 
    5960      ! 
    6061      INTEGER , INTENT(in) ::   kt     ! ocean time-step index 
    … …  
    6465      REAL(wp) ::   zrau0r, zlavmr, zua, zva   ! local scalars 
    6566      REAL(wp), POINTER, DIMENSION(:,:,:) ::  zwx, zwy 
     67      REAL(wp), POINTER, DIMENSION(:,:,:) ::  zwz, zww 
    6668      !!---------------------------------------------------------------------- 
    67  
    68       IF( wrk_in_use(3, 3,4) ) THEN 
    69          CALL ctl_stop('dyn_zdf_exp: requested workspace arrays unavailable')   ;   RETURN 
    70       ENDIF 
     69      ! 
     70      IF( nn_timing == 1 )  CALL timing_start('dyn_zdf_exp') 
     71      ! 
     72      CALL wrk_alloc( jpi, jpj, jpk, zwz, zww )  
    7173      ! 
    7274      zwx => tsa(:,:,:,1)  
    … …  
    124126      END DO                           ! End of time splitting 
    125127      ! 
    126       IF( wrk_not_released(3, 3,4) )   CALL ctl_stop('dyn_zdf_exp: failed to release workspace arrays') 
     128      CALL wrk_dealloc( jpi, jpj, jpk, zwz, zww )  
     129      ! 
     130      IF( nn_timing == 1 )  CALL timing_stop('dyn_zdf_exp') 
    127131      ! 
    128132   END SUBROUTINE dyn_zdf_exp 

  • branches/2011/dev_NEMO_MERGE_2011/NEMOGCM/NEMO/OPA_SRC/DYN/dynzdf_imp.F90

    r3116 r3161  
    2121   USE lib_mpp         ! MPP library 
    2222   USE zdfbfr          ! bottom friction setup 
     23   USE wrk_nemo_2      ! Memory Allocation 
     24   USE timing          ! Timing 
    2325 
    2426   IMPLICIT NONE 
    … …  
    5557      !! ** Action : - Update (ua,va) arrays with the after vertical diffusive mixing trend. 
    5658      !!--------------------------------------------------------------------- 
    57       USE wrk_nemo, ONLY:   wrk_in_use, wrk_not_released 
    58       USE oce     , ONLY:   tsa             ! tsa used as 2 3D workspace 
    59       USE wrk_nemo, ONLY:   zwi => wrk_3d_3                 ! 3D workspace 
    60       !! 
    61       INTEGER , INTENT(in) ::   kt    ! ocean time-step index 
     59      USE oce     , ONLY:   tsa       ! tsa used as 2 3D workspace 
     60      !! 
     61      INTEGER , INTENT(in) ::  kt     ! ocean time-step index 
    6262      REAL(wp), INTENT(in) ::  p2dt   ! vertical profile of tracer time-step 
    6363      !! 
    … …  
    6969      REAL(wp) ::   zbfru, zbfrv  
    7070      REAL(wp) ::   zbfr_imp = 0._wp                        ! toggle (SAVE'd by assignment)  
     71      REAL(wp), POINTER, DIMENSION(:,:,:) ::  zwi 
    7172      REAL(wp), POINTER, DIMENSION(:,:,:) ::  zwd, zws 
    7273      !!---------------------------------------------------------------------- 
    73       !!---------------------------------------------------------------------- 
    74  
    75       IF( wrk_in_use(3, 3) ) THEN 
    76          CALL ctl_stop('dyn_zdf_imp: requested workspace array unavailable')   ;   RETURN 
    77       END IF 
     74      ! 
     75      IF( nn_timing == 1 )  CALL timing_start('dyn_zdf_imp') 
     76      ! 
     77      CALL wrk_alloc( jpi, jpj, jpk, zwi )  
    7878      ! 
    7979      zwd => tsa(:,:,:,1)  
    … …  
    251251      END DO 
    252252      ! 
    253       IF( wrk_not_released(3, 3) )   CALL ctl_stop('dyn_zdf_imp: failed to release workspace array') 
    254       ! 
    255  
     253      CALL wrk_dealloc( jpi, jpj, jpk, zwi )  
     254      ! 
     255      IF( nn_timing == 1 )  CALL timing_stop('dyn_zdf_imp') 
     256      ! 
    256257   END SUBROUTINE dyn_zdf_imp 
    257258 

  • branches/2011/dev_NEMO_MERGE_2011/NEMOGCM/NEMO/OPA_SRC/DYN/sshwzv.F90

    r3116 r3161  
    3939   USE asminc          ! Assimilation increment 
    4040#endif 
     41   USE wrk_nemo_2      ! Memory Allocation 
     42   USE timing          ! Timing 
    4143 
    4244   IMPLICIT NONE 
    … …  
    7577      !! Reference  : Leclair, M., and G. Madec, 2009, Ocean Modelling. 
    7678      !!---------------------------------------------------------------------- 
    77       USE wrk_nemo, ONLY: wrk_in_use, wrk_not_released 
    7879      USE oce     , ONLY: tsa             ! tsa used as 2 3D workspace 
    79       USE wrk_nemo, ONLY: zhdiv => wrk_2d_1, z2d => wrk_2d_2 
    8080      !! 
    8181      INTEGER, INTENT(in) ::   kt   ! time step 
    … …  
    8383      INTEGER  ::   ji, jj, jk   ! dummy loop indices 
    8484      REAL(wp) ::   zcoefu, zcoefv, zcoeff, z2dt, z1_2dt, z1_rau0   ! local scalars 
     85      REAL(wp), POINTER, DIMENSION(:,:  ) ::  z2d, zhdiv 
    8586      REAL(wp), POINTER, DIMENSION(:,:,:) ::  z3d 
    8687      !!---------------------------------------------------------------------- 
    87  
    88       IF( wrk_in_use(2, 1,2) ) THEN 
    89          CALL ctl_stop('ssh_wzv: requested workspace arrays unavailable')   ;   RETURN 
    90       ENDIF 
    91  
     88      ! 
     89      IF( nn_timing == 1 )  CALL timing_start('ssh_wzv') 
     90      ! 
     91      CALL wrk_alloc( jpi, jpj, z2d, zhdiv )  
     92      ! 
    9293      IF( kt == nit000 ) THEN 
    9394         ! 
    … …  
    242243      IF(ln_ctl)   CALL prt_ctl( tab2d_1=ssha, clinfo1=' ssha  - : ', mask1=tmask, ovlap=1 ) 
    243244      ! 
    244       IF( wrk_not_released(2, 1,2) )   CALL ctl_stop('ssh_wzv: failed to release workspace arrays') 
     245      CALL wrk_dealloc( jpi, jpj, z2d, zhdiv )  
     246      ! 
     247      IF( nn_timing == 1 )  CALL timing_stop('ssh_wzv') 
    245248      ! 
    246249   END SUBROUTINE ssh_wzv 
    … …  
    271274      REAL(wp) ::   zec      ! temporary scalar 
    272275      !!---------------------------------------------------------------------- 
    273  
     276      ! 
     277      IF( nn_timing == 1 )  CALL timing_start('ssh_nxt') 
     278      ! 
    274279      IF( kt == nit000 ) THEN 
    275280         IF(lwp) WRITE(numout,*) 
    … …  
    356361      IF(ln_ctl)   CALL prt_ctl( tab2d_1=sshb, clinfo1=' sshb  - : ', mask1=tmask, ovlap=1 ) 
    357362      ! 
     363      IF( nn_timing == 1 )  CALL timing_stop('ssh_nxt') 
     364      ! 
    358365   END SUBROUTINE ssh_nxt 
    359366 

  • branches/2011/dev_NEMO_MERGE_2011/NEMOGCM/NEMO/OPA_SRC/nemogcm.F90

    r3139 r3161  
    5656   USE phycst          ! physical constant                  (par_cst routine) 
    5757   USE trdmod          ! momentum/tracers trends       (trd_mod_init routine) 
    58    USE asminc          ! assimilation increments       (asm_inc_init routine) 
    5958   USE asmtrj          ! writing out state trajectory 
    60    USE sshwzv          ! vertical velocity used in asm 
    6159   USE diaptr          ! poleward transports           (dia_ptr_init routine) 
    6260   USE diadct          ! sections transports           (dia_dct_init routine) 
    … …  
    7068   USE c1d             ! 1D configuration 
    7169   USE step_c1d        ! Time stepping loop for the 1D configuration 
    72    USE dynnept         ! simplified form of Neptune effect 
    7370#if defined key_top 
    7471   USE trcini          ! passive tracer initialisation 

  • branches/2011/dev_NEMO_MERGE_2011/NEMOGCM/NEMO/OPA_SRC/step.F90

    r3139 r3161  
    3636   USE agrif_opa_sponge ! Momemtum and tracers sponges 
    3737#endif 
    38    USE asminc           ! assimilation increments    (tra_asm_inc, dyn_asm_inc routines) 
    39    USE dynnept          ! simplified form of Neptune effect 
    4038 
    4139   IMPLICIT NONE 

  • branches/2011/dev_NEMO_MERGE_2011/NEMOGCM/NEMO/OPA_SRC/step_oce.F90

    r3139 r3161  
    4545   USE dynspg_oce       ! surface pressure gradient        (dyn_spg routine) 
    4646   USE dynspg           ! surface pressure gradient        (dyn_spg routine) 
     47   USE dynnept          ! simp. form of Neptune effect(dyn_nept_cor routine) 
     48 
    4749   USE dynnxt           ! time-stepping                    (dyn_nxt routine) 
    4850 
    … …  
    8991   USE floats           ! floats computation               (flo_stp routine) 
    9092 
     93   USE asminc           ! assimilation increments      (tra_asm_inc routine) 
     94   !                                                   (dyn_asm_inc routine) 
     95 
    9196   USE stpctl           ! time stepping control            (stp_ctl routine) 
    9297   USE restart          ! ocean restart                    (rst_wri routine) 
Note: See TracChangeset for help on using the changeset viewer.