MODULE dissip_gcm_mod
  USE icosa

  TYPE(t_field),POINTER,SAVE :: f_gradrot(:)
  TYPE(t_request),POINTER :: req_dissip(:) 
  TYPE(t_field),POINTER,SAVE :: f_due(:)
 
  INTEGER,PARAMETER :: nitergdiv=1
  INTEGER,PARAMETER :: nitergrot=1
  INTEGER,PARAMETER :: niterdivgrad=1

  REAL,ALLOCATABLE,SAVE :: tau_graddiv(:)
  REAL,ALLOCATABLE,SAVE :: tau_gradrot(:)
  REAL,ALLOCATABLE,SAVE :: tau_divgrad(:)
  
  REAL,SAVE :: cgraddiv
  REAL,SAVE :: cgradrot
  REAL,SAVE :: cdivgrad
  
  INTEGER :: idissip
  REAL    :: dtdissip
  
CONTAINS

  SUBROUTINE allocate_dissip
  USE icosa
  IMPLICIT NONE  
    CALL allocate_field(f_gradrot,field_u,type_real,llm)
    CALL allocate_field(f_due,field_u,type_real,llm)
    ALLOCATE(tau_graddiv(llm))
    ALLOCATE(tau_gradrot(llm))    
    ALLOCATE(tau_divgrad(llm))
  END SUBROUTINE allocate_dissip
 
  SUBROUTINE init_dissip(dt)
  USE icosa
  USE disvert_mod
  
  IMPLICIT NONE
  REAL,INTENT(IN)       :: dt
  
  TYPE(t_field),POINTER :: f_u(:)
  TYPE(t_field),POINTER :: f_du(:)
  REAL(rstd),POINTER    :: u(:)
  REAL(rstd),POINTER    :: du(:)
  TYPE(t_field),POINTER :: f_theta(:)
  TYPE(t_field),POINTER :: f_dtheta(:)
  REAL(rstd),POINTER    :: theta(:)
  REAL(rstd),POINTER    :: dtheta(:)
  REAL(rstd)            :: dumax
  REAL(rstd)            :: dthetamax
  REAL(rstd)            :: r
  REAL(rstd)            :: tau
  REAL(rstd)            :: zz, zvert, fact
  INTEGER               :: l
  
            
  INTEGER :: i,j,n,ind,it

    CALL allocate_dissip
    CALL allocate_field(f_u,field_u,type_real)
    CALL allocate_field(f_du,field_u,type_real)
    CALL allocate_field(f_theta,field_t,type_real)
    CALL allocate_field(f_dtheta,field_t,type_real)

    tau_graddiv(:)=5000
    CALL getin("tau_graddiv",tau)
    tau_graddiv(:)=tau
    
    tau_gradrot(:)=5000
    CALL getin("tau_gradrot",tau)
    tau_gradrot(:)=tau
    

    tau_divgrad(:)=5000
    CALL getin("tau_divgrad",tau)
    tau_divgrad(:)=tau
  
    CALL create_request(field_u,req_dissip)

    DO ind=1,ndomain
      DO i=ii_begin,ii_end
        CALL request_add_point(ind,i,jj_begin-1,req_dissip,rup)
        CALL request_add_point(ind,i+1,jj_begin-1,req_dissip,lup)
      ENDDO

      DO j=jj_begin,jj_end
        CALL request_add_point(ind,ii_end+1,j,req_dissip,left)
        CALL request_add_point(ind,ii_end+1,j-1,req_dissip,lup)
      ENDDO    
    
      DO i=ii_begin,ii_end
        CALL request_add_point(ind,i,jj_end+1,req_dissip,ldown)
        CALL request_add_point(ind,i-1,jj_end+1,req_dissip,rdown)
      ENDDO    

      DO j=jj_begin,jj_end
        CALL request_add_point(ind,ii_begin-1,j,req_dissip,right)
        CALL request_add_point(ind,ii_begin-1,j+1,req_dissip,rdown)
      ENDDO   

      DO i=ii_begin+1,ii_end-1
        CALL request_add_point(ind,i,jj_begin,req_dissip,right)
        CALL request_add_point(ind,i,jj_end,req_dissip,right)
      ENDDO
    
      DO j=jj_begin+1,jj_end-1
        CALL request_add_point(ind,ii_begin,j,req_dissip,rup)
        CALL request_add_point(ind,ii_end,j,req_dissip,rup)
      ENDDO   

      CALL request_add_point(ind,ii_begin+1,jj_begin,req_dissip,left)
      CALL request_add_point(ind,ii_begin,jj_begin+1,req_dissip,ldown)
      CALL request_add_point(ind,ii_begin+1,jj_end,req_dissip,left)
      CALL request_add_point(ind,ii_end,jj_begin+1,req_dissip,ldown)
     
    ENDDO


    cgraddiv=-1
    cdivgrad=-1
    cgradrot=-1
  
    CALL RANDOM_SEED()
    
    DO ind=1,ndomain
      CALL swap_dimensions(ind)
      CALL swap_geometry(ind)
      u=f_u(ind)

      DO j=jj_begin,jj_end
        DO i=ii_begin,ii_end
          n=(j-1)*iim+i
          CALL RANDOM_NUMBER(r)
          u(n+u_right)=r-0.5
          CALL RANDOM_NUMBER(r)
          u(n+u_lup)=r-0.5
          CALL RANDOM_NUMBER(r)
          u(n+u_ldown)=r-0.5
       ENDDO
      ENDDO
        
    ENDDO
  


    DO it=1,500

      CALL transfert_request(f_u,req_dissip)
      CALL transfert_request(f_u,req_dissip)

      dumax=0
      DO ind=1,ndomain
        CALL swap_dimensions(ind)
        CALL swap_geometry(ind)
        u=f_u(ind)
        du=f_du(ind)
        CALL gradiv(u,du,1)
      ENDDO
      CALL transfert_request(f_du,req_dissip)
      CALL transfert_request(f_du,req_dissip)
      
      DO ind=1,ndomain
        CALL swap_dimensions(ind)
        CALL swap_geometry(ind)
        u=f_u(ind)
        du=f_du(ind)
        
        DO j=jj_begin,jj_end
          DO i=ii_begin,ii_end
            n=(j-1)*iim+i
            if (le(n+u_right)>1e-100) dumax=MAX(dumax,ABS(du(n+u_right)))
            if (le(n+u_lup)>1e-100) dumax=MAX(dumax,ABS(du(n+u_lup)))
            if (le(n+u_ldown)>1e-100) dumax=MAX(dumax,ABS(du(n+u_ldown)))
          ENDDO
        ENDDO
      ENDDO

      DO ind=1,ndomain
        CALL swap_dimensions(ind)
        CALL swap_geometry(ind)
        u=f_u(ind)
        du=f_du(ind)
        u=du/dumax
      ENDDO
      PRINT *,"gradiv : it :",it ,": dumax",dumax

    ENDDO 
    PRINT *,"gradiv : dumax",dumax
    
    cgraddiv=dumax**(-1./nitergdiv)
    PRINT *,"cgraddiv : ",cgraddiv

    DO ind=1,ndomain
      CALL swap_dimensions(ind)
      CALL swap_geometry(ind)
      u=f_u(ind)

     DO j=jj_begin,jj_end
        DO i=ii_begin,ii_end
          n=(j-1)*iim+i
          CALL RANDOM_NUMBER(r)
          u(n+u_right)=r-0.5
          CALL RANDOM_NUMBER(r)
          u(n+u_lup)=r-0.5
          CALL RANDOM_NUMBER(r)
          u(n+u_ldown)=r-0.5
       ENDDO
      ENDDO
        
    ENDDO


    DO it=1,500
 
      CALL transfert_request(f_u,req_dissip)
      CALL transfert_request(f_u,req_dissip)

      dumax=0
      DO ind=1,ndomain
        CALL swap_dimensions(ind)
        CALL swap_geometry(ind)
        u=f_u(ind)
        du=f_du(ind)
        CALL gradrot(u,du,1)
      ENDDO

      CALL transfert_request(f_du,req_dissip)
      CALL transfert_request(f_du,req_dissip)
      
      DO ind=1,ndomain
        CALL swap_dimensions(ind)
        CALL swap_geometry(ind)
        u=f_u(ind)
        du=f_du(ind)
        
        DO j=jj_begin,jj_end
          DO i=ii_begin,ii_end
            n=(j-1)*iim+i
            if (le(n+u_right)>1e-100) dumax=MAX(dumax,ABS(du(n+u_right)))
            if (le(n+u_lup)>1e-100) dumax=MAX(dumax,ABS(du(n+u_lup)))
            if (le(n+u_ldown)>1e-100) dumax=MAX(dumax,ABS(du(n+u_ldown)))
          ENDDO
        ENDDO
      ENDDO
      
      DO ind=1,ndomain
        CALL swap_dimensions(ind)
        CALL swap_geometry(ind)
        u=f_u(ind)
        du=f_du(ind)
        u=du/dumax
      ENDDO
      
!      PRINT *,"gradrot : it :",it ,": dumax",(dumax+dumaxm1)/2
      PRINT *,"gradrot : it :",it ,": dumax",dumax

    ENDDO 
    PRINT *,"gradrot : dumax",dumax
  
    cgradrot=dumax**(-1/nitergrot) 
    PRINT *,"cgradrot : ",cgradrot
   


    DO ind=1,ndomain
      CALL swap_dimensions(ind)
      CALL swap_geometry(ind)
      theta=f_theta(ind)
 
       DO j=jj_begin,jj_end
          DO i=ii_begin,ii_end
            n=(j-1)*iim+i
            CALL RANDOM_NUMBER(r)
            theta(n)=r-0.5
         ENDDO
        ENDDO
        
    ENDDO

    DO it=1,500

      CALL transfert_request(f_theta,req_i1)

      dthetamax=0
      DO ind=1,ndomain
        CALL swap_dimensions(ind)
        CALL swap_geometry(ind)
        theta=f_theta(ind)
        dtheta=f_dtheta(ind)
        CALL divgrad(theta,dtheta,1)
      ENDDO
!      CALL writefield("divgrad",f_dtheta)

      CALL transfert_request(f_dtheta,req_i1)
      
      DO ind=1,ndomain
        CALL swap_dimensions(ind)
        CALL swap_geometry(ind)
        theta=f_theta(ind)
        dtheta=f_dtheta(ind)
        
        DO j=jj_begin,jj_end
          DO i=ii_begin,ii_end
            n=(j-1)*iim+i
            dthetamax=MAX(dthetamax,ABS(dtheta(n)))
          ENDDO
        ENDDO
      ENDDO

      PRINT *,"divgrad : it :",it ,": dthetamax",dthetamax

      DO ind=1,ndomain
        CALL swap_dimensions(ind)
        CALL swap_geometry(ind)
        theta=f_theta(ind)
        dtheta=f_dtheta(ind)
        theta=dtheta/dthetamax
      ENDDO
    ENDDO 

!    CALL writefield("divgrad",f_dtheta)
    PRINT *,"divgrad : divgrad",dthetamax
  
    cdivgrad=dthetamax**(-1/niterdivgrad) 
    PRINT *,"cdivgrad : ",cdivgrad
    





     
    fact=2
    DO l=1,llm
       zz= 1. - preff/presnivs(l)
       zvert=fact-(fact-1)/(1+zz*zz)
       tau_graddiv(l) = tau_graddiv(l)/zvert
       tau_gradrot(l) = tau_gradrot(l)/zvert
       tau_divgrad(l) = tau_divgrad(l)/zvert
    ENDDO
       
!    idissip=INT(MIN(tetagdiv,tetagrot)/(2.*dt))
!    idissip=MAX(1,idissip)
!    dtdissip=idissip*dt
!    PRINT *,"idissip",idissip," dtdissip ",dtdissip

  END SUBROUTINE init_dissip 
 
  
  SUBROUTINE dissip(f_ue,f_due,f_ps,f_theta_rhodz,f_dtheta_rhodz)
  USE icosa
  USE theta2theta_rhodz_mod
  IMPLICIT NONE
    TYPE(t_field),POINTER :: f_ue(:)
    TYPE(t_field),POINTER :: f_due(:)
    TYPE(t_field),POINTER :: f_ps(:)
    TYPE(t_field),POINTER :: f_theta_rhodz(:)
    TYPE(t_field),POINTER :: f_dtheta_rhodz(:)
    REAL(rstd),POINTER         :: ue(:,:)
    REAL(rstd),POINTER         :: due(:,:)
    REAL(rstd),POINTER         :: ps(:)
    REAL(rstd),POINTER         :: theta_rhodz(:,:)
    REAL(rstd),POINTER         :: dtheta_rhodz(:,:)

    REAL(rstd)                 :: theta(iim*jjm,llm)
    REAL(rstd)                 :: du_dissip(3*iim*jjm,llm)
    REAL(rstd)                 :: dtheta_dissip(iim*jjm,llm)
    REAL(rstd)                 :: dtheta_rhodz_dissip(iim*jjm,llm)

    INTEGER :: ind
    INTEGER :: l,i,j,n
    
    CALL transfert_request(f_ue,req_e1)
    CALL transfert_request(f_ue,req_e1)
    CALL transfert_request(f_theta_rhodz,req_i1)
    CALL transfert_request(f_ps,req_i1)

    DO ind=1,ndomain
      CALL swap_dimensions(ind)
      CALL swap_geometry(ind)
      ue=f_ue(ind)
      due=f_due(ind) 
      ps=f_ps(ind) 
      theta_rhodz=f_theta_rhodz(ind)
      dtheta_rhodz=f_dtheta_rhodz(ind) 

!$OMP PARALLEL DEFAULT(SHARED)
     CALL compute_dissip(ue,due,ps,theta_rhodz,dtheta_rhodz)
!$OMP END PARALLEL
      
    ENDDO
      
  END SUBROUTINE dissip


  SUBROUTINE compute_dissip(ue,due,ps,theta_rhodz,dtheta_rhodz)
  USE icosa
  USE theta2theta_rhodz_mod
  IMPLICIT NONE
    REAL(rstd)         :: ue(3*iim*jjm,llm)
    REAL(rstd)         :: due(3*iim*jjm,llm)
    REAL(rstd)         :: ps(iim*jjm)
    REAL(rstd)         :: theta_rhodz(iim*jjm,llm)
    REAL(rstd)         :: dtheta_rhodz(iim*jjm,llm)

    REAL(rstd),SAVE,ALLOCATABLE :: theta(:,:)
    REAL(rstd),SAVE,ALLOCATABLE :: du_dissip(:,:)
    REAL(rstd),SAVE,ALLOCATABLE :: dtheta_dissip(:,:)
    REAL(rstd),SAVE,ALLOCATABLE :: dtheta_rhodz_dissip(:,:)

    INTEGER :: ind
    INTEGER :: l,i,j,n

!$OMP BARRIER
!$OMP MASTER
      ALLOCATE(theta(iim*jjm,llm))
      ALLOCATE(du_dissip(3*iim*jjm,llm))
      ALLOCATE(dtheta_dissip(iim*jjm,llm))
      ALLOCATE(dtheta_rhodz_dissip(iim*jjm,llm))
!$OMP END MASTER
!$OMP BARRIER
    
      CALL gradiv(ue,du_dissip,llm)
      DO l=1,llm
!$OMP DO
        DO j=jj_begin,jj_end
          DO i=ii_begin,ii_end
            n=(j-1)*iim+i
            due(n+u_right,l)=due(n+u_right,l)+du_dissip(n+u_right,l)/tau_graddiv(l)*0.5
            due(n+u_lup,l)=due(n+u_lup,l)+du_dissip(n+u_lup,l)/tau_graddiv(l)*0.5
            due(n+u_ldown,l)=due(n+u_ldown,l)+du_dissip(n+u_ldown,l)/tau_graddiv(l)*0.5
          ENDDO
        ENDDO
      ENDDO
      
      CALL gradrot(ue,du_dissip,llm)

      DO l=1,llm
!$OMP DO
        DO j=jj_begin,jj_end
          DO i=ii_begin,ii_end
            n=(j-1)*iim+i
            due(n+u_right,l)=due(n+u_right,l)+du_dissip(n+u_right,l)/tau_gradrot(l)*0.5
            due(n+u_lup,l)=due(n+u_lup,l)+du_dissip(n+u_lup,l)/tau_gradrot(l)*0.5
            due(n+u_ldown,l)=due(n+u_ldown,l)+du_dissip(n+u_ldown,l)/tau_gradrot(l)*0.5
          ENDDO
        ENDDO
      ENDDO 
      
      CALL compute_theta_rhodz2theta(ps,theta_rhodz,theta,1)
      CALL divgrad(theta,dtheta_dissip,llm)
      CALL compute_theta2theta_rhodz(ps,dtheta_dissip,dtheta_rhodz_dissip,0)

      DO l=1,llm
!$OMP DO
        DO j=jj_begin,jj_end
          DO i=ii_begin,ii_end
            n=(j-1)*iim+i
            dtheta_rhodz(n,l)=dtheta_rhodz(n,l)+dtheta_rhodz_dissip(n,l)/tau_divgrad(l)*0.5
          ENDDO
        ENDDO
      ENDDO 

!$OMP BARRIER
!$OMP MASTER
      DEALLOCATE(theta)
      DEALLOCATE(du_dissip)
      DEALLOCATE(dtheta_dissip)
      DEALLOCATE(dtheta_rhodz_dissip)
!$OMP END MASTER
!$OMP BARRIER      

  END SUBROUTINE compute_dissip
  
  
  SUBROUTINE gradiv(ue,gradivu_e,ll)
  USE icosa
  IMPLICIT NONE
    INTEGER,INTENT(IN)     :: ll
    REAL(rstd),INTENT(IN)  :: ue(iim*3*jjm,ll)
    REAL(rstd),INTENT(OUT) :: gradivu_e(iim*3*jjm,ll)
    REAL(rstd),SAVE,ALLOCATABLE :: divu_i(:,:)
    
    INTEGER :: i,j,n,l

!$OMP BARRIER
!$OMP MASTER
      ALLOCATE(divu_i(iim*jjm,ll))
!$OMP END MASTER
!$OMP BARRIER

    DO l=1,ll
!$OMP DO
      DO j=jj_begin,jj_end
        DO i=ii_begin,ii_end
          n=(j-1)*iim+i
          divu_i(n,l)=1./Ai(n)*(ne(n,right)*ue(n+u_right,l)*le(n+u_right)  +  &
                             ne(n,rup)*ue(n+u_rup,l)*le(n+u_rup)        +  &  
                             ne(n,lup)*ue(n+u_lup,l)*le(n+u_lup)        +  &  
                             ne(n,left)*ue(n+u_left,l)*le(n+u_left)     +  &  
                             ne(n,ldown)*ue(n+u_ldown,l)*le(n+u_ldown)  +  &  
                             ne(n,rdown)*ue(n+u_rdown,l)*le(n+u_rdown))
        ENDDO
      ENDDO
    ENDDO
    
    DO l=1,ll
!$OMP DO
      DO j=jj_begin,jj_end
        DO i=ii_begin,ii_end
 
          n=(j-1)*iim+i
 
          gradivu_e(n+u_right,l)=-1/de(n+u_right)*(ne(n,right)*divu_i(n,l)+ ne(n+t_right,left)*divu_i(n+t_right,l) )       

          gradivu_e(n+u_lup,l)=-1/de(n+u_lup)*(ne(n,lup)*divu_i(n,l)+ ne(n+t_lup,rdown)*divu_i(n+t_lup,l))       
    
          gradivu_e(n+u_ldown,l)=-1/de(n+u_ldown)*(ne(n,ldown)*divu_i(n,l)+ne(n+t_ldown,rup)*divu_i(n+t_ldown,l) )

        ENDDO
      ENDDO
    ENDDO

    DO l=1,ll
!$OMP DO
      DO j=jj_begin,jj_end
        DO i=ii_begin,ii_end
          n=(j-1)*iim+i
          gradivu_e(n+u_right,l)=gradivu_e(n+u_right,l)*cgraddiv
          gradivu_e(n+u_lup,l)=gradivu_e(n+u_lup,l)*cgraddiv
          gradivu_e(n+u_ldown,l)=gradivu_e(n+u_ldown,l)*cgraddiv
        ENDDO
      ENDDO
    ENDDO

!$OMP BARRIER
!$OMP MASTER
      DEALLOCATE(divu_i)
!$OMP END MASTER
!$OMP BARRIER

    
  END SUBROUTINE gradiv
  
  SUBROUTINE divgrad(theta,divgrad_i,ll)
  USE icosa
  IMPLICIT NONE
    INTEGER,INTENT(IN)     :: ll
    REAL(rstd),INTENT(IN)  :: theta(iim*jjm,ll)
    REAL(rstd),INTENT(OUT) :: divgrad_i(iim*jjm,ll)
    REAL(rstd),SAVE,ALLOCATABLE :: grad_e(:,:)

    INTEGER :: i,j,n,l

!$OMP BARRIER
!$OMP MASTER
      ALLOCATE(grad_e(3*iim*jjm,ll))
!$OMP END MASTER
!$OMP BARRIER
        
    DO l=1,ll
!$OMP DO
      DO j=jj_begin-1,jj_end+1
        DO i=ii_begin-1,ii_end+1
   
          n=(j-1)*iim+i
 
          grad_e(n+u_right,l)=-1/de(n+u_right)*(ne(n,right)*theta(n,l)+ ne(n+t_right,left)*theta(n+t_right,l) )        

          grad_e(n+u_lup,l)=-1/de(n+u_lup)*(ne(n,lup)*theta(n,l)+ ne(n+t_lup,rdown)*theta(n+t_lup,l ))       
    
          grad_e(n+u_ldown,l)=-1/de(n+u_ldown)*(ne(n,ldown)*theta(n,l)+ne(n+t_ldown,rup)*theta(n+t_ldown,l) )

        ENDDO
      ENDDO
    ENDDO
    
    
    DO l=1,ll
!$OMP DO
      DO j=jj_begin,jj_end
        DO i=ii_begin,ii_end
          n=(j-1)*iim+i
          divgrad_i(n,l)=1./Ai(n)*(ne(n,right)*grad_e(n+u_right,l)*le(n+u_right)  +  &
                             ne(n,rup)*grad_e(n+u_rup,l)*le(n+u_rup)              +  &  
                             ne(n,lup)*grad_e(n+u_lup,l)*le(n+u_lup)              +  &  
                             ne(n,left)*grad_e(n+u_left,l)*le(n+u_left)           +  &  
                             ne(n,ldown)*grad_e(n+u_ldown,l)*le(n+u_ldown)        +  &  
                             ne(n,rdown)*grad_e(n+u_rdown,l)*le(n+u_rdown))
        ENDDO
      ENDDO
    ENDDO
   
    DO l=1,ll
!$OMP DO
      DO j=jj_begin,jj_end
        DO i=ii_begin,ii_end
          n=(j-1)*iim+i
          divgrad_i(n,l)=divgrad_i(n,l)*cdivgrad
        ENDDO
      ENDDO
    ENDDO

!$OMP BARRIER
!$OMP MASTER
      DEALLOCATE(grad_e)
!$OMP END MASTER
!$OMP BARRIER

  END SUBROUTINE divgrad

    
  SUBROUTINE gradrot(ue,gradrot_e,ll)
  USE icosa
  IMPLICIT NONE
    INTEGER,INTENT(IN)     :: ll
    REAL(rstd),INTENT(IN)  :: ue(iim*3*jjm,ll)
    REAL(rstd),INTENT(OUT) :: gradrot_e(iim*3*jjm,ll)
    REAL(rstd),SAVE,ALLOCATABLE  :: rot_v(:,:)

    INTEGER :: i,j,n,l

!$OMP BARRIER
!$OMP MASTER
      ALLOCATE(rot_v(2*iim*jjm,ll))
!$OMP END MASTER
!$OMP BARRIER
     
    DO l=1,ll
!$OMP DO
      DO j=jj_begin-1,jj_end+1
        DO i=ii_begin-1,ii_end+1
          n=(j-1)*iim+i
        
          rot_v(n+z_up,l)= 1./Av(n+z_up)*(  ne(n,rup)*ue(n+u_rup,l)*de(n+u_rup)                     &
                                + ne(n+t_rup,left)*ue(n+t_rup+u_left,l)*de(n+t_rup+u_left)          &
                                - ne(n,lup)*ue(n+u_lup,l)*de(n+u_lup) ) 
                              
          rot_v(n+z_down,l) = 1./Av(n+z_down)*( ne(n,ldown)*ue(n+u_ldown,l)*de(n+u_ldown)                 &
                                     + ne(n+t_ldown,right)*ue(n+t_ldown+u_right,l)*de(n+t_ldown+u_right)  &
                                     - ne(n,rdown)*ue(n+u_rdown,l)*de(n+u_rdown) )
  
        ENDDO
      ENDDO
    ENDDO                              
  
    DO l=1,ll
!$OMP DO
      DO j=jj_begin,jj_end
        DO i=ii_begin,ii_end
          n=(j-1)*iim+i
  
          gradrot_e(n+u_right,l)=1/le(n+u_right)*ne(n,right)*(rot_v(n+z_rdown,l)-rot_v(n+z_rup,l)) 
         
          gradrot_e(n+u_lup,l)=1/le(n+u_lup)*ne(n,lup)*(rot_v(n+z_up,l)-rot_v(n+z_lup,l)) 
        
          gradrot_e(n+u_ldown,l)=1/le(n+u_ldown)*ne(n,ldown)*(rot_v(n+z_ldown,l)-rot_v(n+z_down,l))
        
        ENDDO
      ENDDO
    ENDDO

    DO l=1,ll
!$OMP DO
      DO j=jj_begin,jj_end
        DO i=ii_begin,ii_end
          n=(j-1)*iim+i
    
          gradrot_e(n+u_right,l)=gradrot_e(n+u_right,l)*cgradrot       
          gradrot_e(n+u_lup,l)=gradrot_e(n+u_lup,l)*cgradrot
          gradrot_e(n+u_ldown,l)=gradrot_e(n+u_ldown,l)*cgradrot
        
        ENDDO
      ENDDO
    ENDDO  
    
!$OMP BARRIER
!$OMP MASTER
      DEALLOCATE(rot_v)
!$OMP END MASTER
!$OMP BARRIER 
   
  END SUBROUTINE gradrot


END MODULE dissip_gcm_mod