Changeset 156

Timestamp:

11/10/17 16:53:10 (6 years ago)

Author:

dumas

Message:

New marais version. Previous versions are buggy

File:

• trunk/SOURCES/flottab2-0.7.f90 (modified) (2 diffs)

trunk/SOURCES/flottab2-0.7.f90

@@ -746 +746 @@
     call determin_front_tof ! version simplifiee
 
-    call determin_marais
-
     ! pour sorties initMIP:
     debug_3D(:,:,118) = ice(:,:)*(1-mk(:,:))
@@ -1322 +1320 @@
 subroutine determin_marais
 
-!$ USE OMP_LIB
-
-implicit none
-integer :: indice
-integer :: label         ! no des taches rencontrées dans le mask
-integer :: label_max     ! no temporaire maxi de tache rencontrées
-!      integer :: mask_nb = 4
-integer,parameter :: mask_nb = 2   ! version ou on ne compte pas les diagonales
-integer :: vartemp       ! variable temporaire pour reorganiser compt
-!     integer,dimension(mask_nb) :: mask
-integer,dimension(mask_nb) :: mask
-
-integer,dimension(nx,ny)        :: table_out_marais      !< pour les numeros des taches
-integer,dimension(0:n_ta_max)     :: compt_marais        !< contient les equivalence entre les taches
-integer,dimension(0:n_ta_max)     :: nb_pts_marais !< indique le nombre de points par tache
-logical,dimension(0:n_ta_max)     :: marais      !< T si flottants entoure de poses, F sinon
- 
+  !$ USE OMP_LIB
+
+  implicit none
+  
+  integer :: indice
+  integer :: label         ! no des taches rencontrées dans le mask
+  integer :: label_max     ! no temporaire maxi de tache rencontrées
+  integer,parameter :: mask_nb = 2   ! version ou on ne compte pas les diagonales
+  integer,dimension(mask_nb) :: mask ! numero de tache des points adjacents
+
+  integer,dimension(nx,ny)          :: table_out_marais    !< numeros de tache d'un point ij
+  integer,dimension(0:n_ta_max)     :: compt_marais        !< contient les equivalence entre les taches
+  integer,dimension(0:n_ta_max)     :: nb_pts_marais       !< indique le nombre de points par tache
+  logical,dimension(0:n_ta_max)     :: marais              !< T si flottants entoure de poses, F sinon
+
+
 ! 1-initialisation
 !-----------------
-label_max=1      ! numero de la tache, la premiere tache est notée 1
-label=1
-do i=1,n_ta_max
-   compt_marais(i)=i
-enddo
-!$OMP PARALLEL
-!$OMP WORKSHARE
-table_out_marais(:,:) = 0
-marais(:)  = .true.
-nb_pts_marais(:) = 0
-!$OMP END WORKSHARE
-!$OMP END PARALLEL
+  label_max=1      ! numero de la tache, la premiere tache est notée 1
+  label=1
+  do i=1,n_ta_max
+    compt_marais(i)=i
+  enddo
+  !$OMP PARALLEL
+  !$OMP WORKSHARE
+  table_out_marais(:,:) = 0
+  marais(:)  = .true.
+  nb_pts_marais(:) = 0
+  !$OMP END WORKSHARE
+  !$OMP END PARALLEL
 
 ! 2-reperage des taches
 !----------------------
 
-do j=2,ny-1
-  do i=2,nx-1
-
-
-
-     IF ((ice(i,j).ge.1).and.flot(i,j)) THEN ! on est sur la glace qui flotte-------------------!
-     !IF ((ice(i,j).ge.1).and.flot(i,j).and.(H(i,j).gt.1.)) THEN ! on est sur la glace qui flotte-------------------!
-                
-        !write (*,*) "un point qui nous interesse!",i,j
-        
+  do j=2,ny-1
+    do i=2,nx-1
+      if ((ice(i,j).ge.1).and.flot(i,j)) then ! on est sur la glace qui flotte-------------------!
+
         if (((ice(i-1,j).ge.1).and.flot(i-1,j)).or.((ice(i,j-1).ge.1).and.flot(i,j-1))) then   !masque de 2 cases adjacentes
-        !if (((ice(i-1,j).ge.1).and.flot(i-1,j).and.(H(i-1,j).gt.1.)).or.((ice(i,j-1).ge.1).and.flot(i,j-1).and.(H(i,j-1).gt.1.))) then   !masque de 2 cases adjacentes
-           !      un des voisins est deja en glace
-           mask(1) = table_out_marais(i-1,j)
-           mask(2) = table_out_marais(i,j-1) 
-           label = label_max
-
-           !on determine la valeur de la tache minimun (>0) presente ds le masque
-           do indice=1,mask_nb
-              if (mask(indice).gt.0) label=min(label,mask(indice))
-           enddo
-
-           !on fixe la valeur de la tache voisine minimun au point etudie (via label)
-           table_out_marais(i,j)=label
+          !  un des voisins est deja en glace
+          mask(1) = table_out_marais(i-1,j)
+          mask(2) = table_out_marais(i,j-1) 
+          label = label_max
+
+          ! on determine la valeur de la tache minimun (>0) presente ds le masque
+          do indice=1,mask_nb
+            if (mask(indice).gt.0) label=min(label,mask(indice))
+          enddo
+
+          ! on fixe la valeur de la tache voisine minimun au point etudie (via label)
+          table_out_marais(i,j)=label
            
-           !si un des voisins n'est pas glace alors la tache n'est pas un marais
-           if ( (ice(i+1,j).eq.0) .or. (ice(i,j+1).eq.0) .or. (ice(i-1,j).eq.0) .or. (ice(i,j-1).eq.0) ) then
-              marais(label)=.false.
-           endif
-
-           ! si 2 taches differentes sont dans le masque, il faut les identifier dans compt
-           ! i.e. les plus grands numeros correspondent au plus petit 
-           ! on lui affecte le numero de la tache fondamentale avec un signe -
-           ! pour indiquer le changement
-
-           do indice=1,mask_nb
-              if(mask(indice).gt.label) then
-                 compt_marais(mask(indice))=-label
-              endif
-           enddo
-           
+          !si un des voisins n'est pas glace alors la tache n'est pas un marais
+          if ( (ice(i+1,j).eq.0) .or. (ice(i,j+1).eq.0) .or. (ice(i-1,j).eq.0) .or. (ice(i,j-1).eq.0) ) then
+            marais(label)=.false.
+          endif
+
+          ! si 2 taches differentes sont dans le masque, il faut les identifier dans compt_marais
+          ! on lui affecte le numero de la tache fondamentale
+
+                                                                   ! exemple on est sur le point X : 5  X
+          do indice=1,mask_nb                                      !                                   20
+            if(mask(indice).gt.label) then                         ! mask(2)=20 > 5             
+              compt_marais(mask(indice))=label                     ! compt_marais(20)=5
+              if (.not.marais(mask(indice))) marais(label)=.false. ! si la tache n'etais pas un marais => marais =.false.  marais(-(-5))=.false.               
+              where (table_out_marais(:,:).eq.mask(indice))        ! where table_out_marais(:,:)=mask(2)=20
+                table_out_marais(:,:)=label                        ! table_out_marais(:,:)=label=5                 
+              endwhere                                                
+            endif
+          enddo
            
         else !aucun des voisins est une tache
-           table_out_marais(i,j)= label_max
-           compt_marais(label_max)=label_max
+          table_out_marais(i,j)= label_max
+          compt_marais(label_max)=label_max
            
-           !si un des voisins n'est pas glace alors la tache n'est pas un marais
-           if ( (ice(i+1,j).eq.0) .or. (ice(i,j+1).eq.0) .or. (ice(i-1,j).eq.0) .or. (ice(i,j-1).eq.0) ) then
-              marais(label_max)=.false.
-           endif
-
-           
-           label_max  = label_max+1
-           if (label_max.gt.n_ta_max) print*,'trop de taches=',label_max 
+          ! si un des voisins n'est pas glace alors la tache n'est pas un marais
+          if ( (ice(i+1,j).eq.0) .or. (ice(i,j+1).eq.0) .or. (ice(i-1,j).eq.0) .or. (ice(i,j-1).eq.0) ) then
+            marais(label_max)=.false.
+          endif
+          label_max  = label_max+1
+          if (label_max.gt.n_ta_max) print*,'ATTENTION trop de taches=',label_max 
         endif
-
-
-     else           !on est pas sur une tache----------------------------------------------
+      else          ! on est pas sur une tache--------------------------------------------
         table_out_marais(i,j)=0    ! Pas necessaire (reecrit 0 sur 0)             
-     endif          !---------------------------------------------------------------------
-
-
+      endif         !---------------------------------------------------------------------
+    enddo
   enddo
-enddo
-
- marais(0)=.false.
-
-! On reorganise compt en ecrivant le numero de la tache fondamentale
-! i.e. du plus petit numero present sur la tache (Sans utiliser de recursivité)
-! On indique aussi le nb de point que contient chaque taches (nb_pts_tache)
-
-do indice=1,label_max
-   vartemp = compt_marais(indice)
-   if (compt_marais(indice).lt.0) then 
-      compt_marais(indice)= compt_marais(-vartemp)
-      if (.not.marais(indice)) marais(-vartemp)=.false.
-   endif    
-enddo
-
-!$OMP PARALLEL
-!$OMP DO REDUCTION(+:nb_pts_marais)
-do j=1,ny
-   do i=1,nx
+
+  marais(0)=.false.
+
+  !$OMP PARALLEL
+  !$OMP DO
+  do j=1,ny
+    do i=1,nx
       if (table_out_marais(i,j).ne.0) then
-         table_out_marais(i,j)=compt_marais(table_out_marais(i,j))  
-         nb_pts_marais(compt_marais(table_out_marais(i,j)))= nb_pts_marais(compt_marais(table_out_marais(i,j)))+1   
+        nb_pts_marais(compt_marais(table_out_marais(i,j)))= nb_pts_marais(compt_marais(table_out_marais(i,j)))+1   
       endif
-   enddo
-enddo
-!$OMP END DO
-!$OMP END PARALLEL
-
-do j=1,ny
-   do i=1,nx
       flot_marais(i,j) = marais(table_out_marais(i,j))
-   enddo
-enddo
-
-debug_3D(:,:,122)=real(table_out_marais(:,:))
+    enddo
+  enddo
+  !$OMP END DO
+  !$OMP END PARALLEL
+
+  debug_3D(:,:,122)=real(table_out_marais(:,:))
 
 end subroutine determin_marais