source: trunk/SOURCES/Hudson_files/bmelt_hudson_mod.f90 @ 4

!> \file bmelt_hudson_mod.f90
!! Module qui calcule la fusion basale (grounded ou ice shelves).
!<

!> \namespace bmelt_hudson
!! Module qui calcule la fusion basale (grounded ou ice shelves)
!! \author CatRitz
!! \date juillet 2005
!! @note pour les ice shelves Antarctique, tient compte des différentes régions
!! A choisir dans le module_choix
!! @note Used module
!! @note   - use module3D_phy
!! @note   - USE output_hudson
!<

MODULE  bmelt_hudson    ! cat juillet 2005

! calcule la fusion basale (grounded ou ice shelves)
! pour les ice shelves Antarctique, tient compte des différentes régions
! A choisir dans le module_choix

  USE module3D_phy
!jalv pour acceder a deltavolshelf pour la fusion basale
  USE output_hudson
  implicit none


  REAL,dimension(nx,ny) ::  bmgrz       !< fusion basale a la grounding zone
  real,dimension(nx,ny) ::  bmshelf     !< fusion basale sous shelf
  real :: bsupshelf  !< fusion basale en plus tous les x ans (oscillation de la fusion basale dans le temps)

CONTAINS

!> SUBROUTINE: init_bmelt
!! Cette routine fait l'initialisation pour la fusion basale.
!<

  subroutine init_bmelt
! Cette routine fait l'initialisation pour la fusion basale.

!    ecriture dans le fichier parametres
    write(42,*)'fusion basale sous les ice shelves : bmelt-hudson'
    write(42,*)'-------------------------------------------------------'
 
    bms_init: do j=1,ny
       do i=1,nx
!          if ((sealevel-BSOC(i,j)).lt.600) then
!             bmshelf(i,j)=0.2 ! 0.45!   0.65  
!             bmgrz(i,j)=0.2 ! 0.45 !  0.65
!          else      
!             bmshelf(i,j)= 10.  
!             bmgrz(i,j)= 10.

          bmshelf(i,j)=(sealevel-BSOC(i,j))/200  ! jalv: eq lineaire en fonction de la profondeur de la mer
          bmgrz(i,j)=bmshelf(i,j)
!          endif
       enddo
    enddo bms_init

    bsupshelf=1.

print*, 'sealevel', sealevel


    return
  end subroutine init_bmelt

!> SUBROUTINE: bmeltshelf
!! Cette routine calcule la fusion basale proprement dite
!<
  subroutine bmeltshelf

! cette routine calcule la fusion basale proprement dite

    integer :: ngr           ! nombre de voisins flottants

    call shortoutput 
    do j=2,ny-1
       do i=2,nx-1
 
          shelf: if (flot(i,j)) then    ! partie flottante
   
             bmelt(i,j)=bmshelf(i,j)

             if (fbm(i,j))  bmelt(i,j)=bmgrz(i,j)


!jalv: parametrisation de la fusion basale en fonction de
!      la derive du volume de la partie flottante par rapport
!      au temps. La variable est deltavolshelfdt, calculé dans 
!      output_hudson...


!jalv: parametrisation de la fusion basale en fonction de la dervie du volume flottant par rapport au temps:

!             IF (time.GT.1000.) THEN
             IF (time.GT.30000.) THEN 
!                if (deltaVOLshelfdt.gt.0.) then
                if (((memdeltaVOLshelf(1)+memdeltaVOLshelf(500)+memdeltaVOLshelf(1000)+memdeltaVOLshelf(1500))/4).gt.0.) then
!                   bmshelf(i,j)=bmshelf(i,j)+20.
!                   bmgrz(i,j)=bmgrz(i,j)+20.
!                   bmelt(i,j)=bmshelf(i,j)
                   bsupshelf=50.
                end if
                
!                if (deltaVOLshelfdt.le.0.) then
                if (((memdeltaVOLshelf(1)+memdeltaVOLshelf(500)+memdeltaVOLshelf(1000)+memdeltaVOLshelf(1500))/4).le.0.) then
!                   bmshelf(i,j)=bmshelf(i,j)-20.
!                   bmgrz(i,j)=bmgrz(i,j)-20.
!                   bmelt(i,j)=bmshelf(i,j)    
                   bsupshelf=-14.
                end if
       
!                print*,'bmelt(134,76)',  bmelt(134,76)      
             ENDIF


! a modifier si on veut faire varier la fusion basale dans le temps :
             if (time.gt.30000.) then
                bmelt(i,j)=bmelt(i,j)+bsupshelf
             endif

! ATTENTION LE BLOC SUIVANT SERT A FAIRE DES ICE SHELVES STATIONNAIRES
! igrdline est défini dans itnitial1

             if (igrdline.eq.1) then
                corrbmelt(i,j)=corrbmelt(i,j)+hdot(i,j)*0.8
                bmelt(i,j)=bmelt(i,j)+corrbmelt(i,j)
             endif


          else         ! point posé, on compte le nombre de voisins flottants
             ngr=0
             if (flot(i+1,j)) ngr=ngr+1
             if (flot(i-1,j)) ngr=ngr+1
             if (flot(i,j+1)) ngr=ngr+1
             if (flot(i,j-1)) ngr=ngr+1

!   la fusion des points limites est une combinaison entre valeur posée et valeur flottante
!   en fonction du nombre de points flottants
             bmelt(i,j)= ngr/4.*bmgrz(i,j)*coefbmshelf+(1.-ngr/4.)*bmelt(i,j)

          endif shelf
       end do
    end do

    return
  end subroutine  bmeltshelf



END MODULE  bmelt_hudson