main_mpi.f90

FDS为火灾动力学模拟软件源代码,该软件为开源项目,代码语言主要为FORTRAN,可在WINDOWS和LINUX下编译运行,详细说明可参考http://fire.nist.gov/fds/官方网址

 
   IF (DEBUG) THEN
      WRITE(0,*) NM,' sending data to ',NOM,' code=',CODE, ' tag=',TAGS(NM,NOM,CODE)
   ENDIF
 
   M =>MESHES(NM)
   M3=>MESHES(NM)%OMESH(NOM)
   M4=>MESHES(NOM)
 
   SNODE = NOM-1
   RNODE = NM-1
 
   TAG = TAGS(NM,NOM,CODE)
 
   INITIALIZE_SEND_IF: IF (CODE==0) THEN
 
      IF (NIC(NOM,NM)>0) THEN
         ALLOCATE(M3%SPKG1(NIC(NOM,NM)*(3+N_SPECIES)+1))
         ALLOCATE(M3%SPKG2(NIC(NOM,NM)*(9+N_SPECIES)+1))
         ALLOCATE(M3%SPKG3(NIC(NOM,NM)*(6      )+1))
      ENDIF
 
      N_REQ=N_REQ+1
      CALL MPI_ISEND(M%IJKW(1,1),12*M%NEWC, MPI_INTEGER,SNODE,TAG,MPI_COMM_WORLD,REQ(N_REQ),IERR)
 
      IF (NIC(NOM,NM)>0)  ALLOCATE(M3%WSPKG((NRA*NSB+1)*NIC(NOM,NM)+1))
 
      IF (DROPLET_FILE .AND.  (NIC(NOM,NM)>0 .OR. NIC(NM,NOM)>0)) THEN
         ALLOCATE(M3%S_RDBUF(13*N_DROP_ADOPT_MAX))
         ALLOCATE(M3%S_IDBUF( 2*N_DROP_ADOPT_MAX))
         ALLOCATE(M3%S_LDBUF(   N_DROP_ADOPT_MAX))
      ENDIF
 
   ENDIF INITIALIZE_SEND_IF
 
   SEND_PREDICTOR_IF: IF (CODE==1) THEN
 
      IF (NIC(NOM,NM)>0) THEN
         LL = 0
         IWW = 0
         PACK_SPKG1: DO IW=1,M4%NEWC
            IF (M3%IJKW(9,IW)/=NM .OR. M3%BOUNDARY_TYPE(IW)/=INTERPOLATED_BOUNDARY) CYCLE PACK_SPKG1
            IWW = IWW + 1
            II = M3%IJKW(10,IW)
            JJ = M3%IJKW(11,IW)
            KK = M3%IJKW(12,IW)
            M3%SPKG1(LL+1) = REAL(IW,EB)
            M3%SPKG1(LL+2) = M%TMP(II,JJ,KK)
            M3%SPKG1(LL+3) = M%H(II,JJ,KK)
            IF (N_SPECIES>0) M3%SPKG1(LL+4:LL+3+N_SPECIES) = M%YYS(II,JJ,KK,1:N_SPECIES)
            LL = LL+3+N_SPECIES
         ENDDO PACK_SPKG1
         M3%SPKG1(IWW*(3+N_SPECIES)+1) = -999.0_EB
         N_REQ=N_REQ+1
         CALL MPI_ISEND(M3%SPKG1(1),IWW*(3+N_SPECIES)+1, MPI_DOUBLE_PRECISION,SNODE,TAG,MPI_COMM_WORLD, REQ(N_REQ),IERR)
      ENDIF
 
   ENDIF SEND_PREDICTOR_IF
 
   SEND_CORRECTOR_IF: IF (CODE==0 .OR. CODE==2) THEN
 
      N_REQ=N_REQ+1
      CALL MPI_ISEND(M%BOUNDARY_TYPE(0),M%NEWC+1, MPI_INTEGER,SNODE,TAG,MPI_COMM_WORLD, REQ(N_REQ),IERR)
 
      IF (CODE==2 .AND. NIC(NOM,NM)>0) THEN
         LL = 0
         IWW = 0
         PACK_SPKG2: DO IW=1,M4%NEWC
            IF (M3%IJKW(9,IW)/=NM .OR. M3%BOUNDARY_TYPE(IW)/=INTERPOLATED_BOUNDARY) CYCLE PACK_SPKG2
            IWW = IWW + 1
            II = M3%IJKW(10,IW)
            JJ = M3%IJKW(11,IW)
            KK = M3%IJKW(12,IW)
            M3%SPKG2(LL+1) = REAL(IW,EB)
            M3%SPKG2(LL+2) = M%TMP(II,JJ,KK)
            M3%SPKG2(LL+3) = M%H(II,JJ,KK)
            M3%SPKG2(LL+4) = M%U(II,JJ,KK)
            M3%SPKG2(LL+5) = M%V(II,JJ,KK)
            M3%SPKG2(LL+6) = M%W(II,JJ,KK)
            M3%SPKG2(LL+7) = M%U(II-1,JJ,KK)
            M3%SPKG2(LL+8) = M%V(II,JJ-1,KK)
            M3%SPKG2(LL+9) = M%W(II,JJ,KK-1)
            IF (N_SPECIES>0) M3%SPKG2(LL+10:LL+9+N_SPECIES) = M%YY(II,JJ,KK,1:N_SPECIES)
            LL = LL+9+N_SPECIES
         ENDDO PACK_SPKG2
         M3%SPKG2(IWW*(9+N_SPECIES)+1) = -999.0_EB
         N_REQ=N_REQ+1
         CALL MPI_ISEND(M3%SPKG2(1),IWW*(9+N_SPECIES)+1, MPI_DOUBLE_PRECISION,SNODE,TAG,MPI_COMM_WORLD, REQ(N_REQ),IERR)
      ENDIF
 
      SEND_RADIATION: IF ( NIC(NOM,NM)>0 .AND. EXCHANGE_RADIATION .AND. CODE==2) THEN
         IWW=0
         LL =0
         PACK_WSPKG: DO IW=1,M4%NEWC
            IF (M3%IJKW(9,IW)/=NM .OR. M3%BOUNDARY_TYPE(IW)/=INTERPOLATED_BOUNDARY) CYCLE PACK_WSPKG
            IWW = IWW+1
            LL  = LL +1
            M3%WSPKG(LL) = REAL(IW,EB)
            DO NN2=1,NSB
               DO NN1=1,NRA
                  LL = LL + 1
                  M3%WSPKG(LL) = M3%WALL(IW)%ILW(NN1,NN2)
               ENDDO
            ENDDO
         ENDDO PACK_WSPKG
         M3%WSPKG(LL+1) = -999.0_EB
         N_REQ=N_REQ+1
         CALL MPI_ISEND(M3%WSPKG(1),(NRA*NSB+1)*IWW+1, MPI_DOUBLE_PRECISION,SNODE,TAG,MPI_COMM_WORLD, REQ(N_REQ),IERR)
      ENDIF SEND_RADIATION
 
   ENDIF SEND_CORRECTOR_IF
 
   ! Get Number of Droplet Orphans
 
   IF (DROPLET_FILE) THEN
      N_REQ=N_REQ+1
      CALL MPI_ISEND(M3%N_DROP_ORPHANS, 1,MPI_INTEGER,SNODE,TAG,MPI_COMM_WORLD,REQ(N_REQ),IERR)
   ENDIF
 
   ! Sending/Receiving Droplet Buffer Arrays
 
   IF_SEND_DROPLETS: IF (DROPLET_FILE) THEN 
 
      NC = 13
      DO N=1,MIN(M3%N_DROP_ORPHANS,N_DROP_ADOPT_MAX)
         M3%S_RDBUF((N-1)*NC+1)  = M3%DROPLET(N)%X
         M3%S_RDBUF((N-1)*NC+2)  = M3%DROPLET(N)%Y
         M3%S_RDBUF((N-1)*NC+3)  = M3%DROPLET(N)%Z
         M3%S_RDBUF((N-1)*NC+4)  = M3%DROPLET(N)%TMP
         M3%S_RDBUF((N-1)*NC+5)  = M3%DROPLET(N)%U
         M3%S_RDBUF((N-1)*NC+6)  = M3%DROPLET(N)%V
         M3%S_RDBUF((N-1)*NC+7)  = M3%DROPLET(N)%W
         M3%S_RDBUF((N-1)*NC+8)  = M3%DROPLET(N)%R
         M3%S_RDBUF((N-1)*NC+9)  = M3%DROPLET(N)%PWT
         M3%S_RDBUF((N-1)*NC+10) = M3%DROPLET(N)%A_X
         M3%S_RDBUF((N-1)*NC+11) = M3%DROPLET(N)%A_Y
         M3%S_RDBUF((N-1)*NC+12) = M3%DROPLET(N)%A_Z
         M3%S_RDBUF((N-1)*NC+13) = M3%DROPLET(N)%T
      ENDDO
      BUFFER_SIZE = NC*MIN(M3%N_DROP_ORPHANS,N_DROP_ADOPT_MAX)
      BUFFER_SIZE = MAX(1,BUFFER_SIZE)
      N_REQ=N_REQ+1
      CALL MPI_ISEND(M3%S_RDBUF(1),BUFFER_SIZE, MPI_DOUBLE_PRECISION,SNODE,TAG,MPI_COMM_WORLD, REQ(N_REQ),IERR)
 
      NC = 2
      DO N=1,MIN(M3%N_DROP_ORPHANS,N_DROP_ADOPT_MAX)
         M3%S_IDBUF((N-1)*NC+1) = M3%DROPLET(N)%IOR
         M3%S_IDBUF((N-1)*NC+2) = M3%DROPLET(N)%CLASS
      ENDDO
      BUFFER_SIZE = NC*MIN(M3%N_DROP_ORPHANS,N_DROP_ADOPT_MAX)
      BUFFER_SIZE = MAX(1,BUFFER_SIZE)
      N_REQ=N_REQ+1
      CALL MPI_ISEND(M3%S_IDBUF(1),BUFFER_SIZE, MPI_INTEGER,SNODE,TAG,MPI_COMM_WORLD,REQ(N_REQ),IERR)
 
      NC = 1
      DO N=1,MIN(M3%N_DROP_ORPHANS,N_DROP_ADOPT_MAX)
         M3%S_LDBUF((N-1)*NC+1) = M3%DROPLET(N)%SHOW
      ENDDO
      BUFFER_SIZE = NC*MIN(M3%N_DROP_ORPHANS,N_DROP_ADOPT_MAX)
      BUFFER_SIZE = MAX(1,BUFFER_SIZE)
      N_REQ=N_REQ+1
      CALL MPI_ISEND(M3%S_LDBUF(1),BUFFER_SIZE, MPI_LOGICAL,SNODE,TAG,MPI_COMM_WORLD,REQ(N_REQ),IERR)
 
      M3%N_DROP_ORPHANS = 0
 
   ENDIF IF_SEND_DROPLETS
 
ENDDO SEND_OTHER_MESH_LOOP
 
! Receive Messages (NOM is the receiver, NM is the sender)
 
CALL MPI_WAITALL(N_REQ,REQ(1:N_REQ),ARRAY_OF_STATUSES,IERR)
 
NOM = MYID+1
 
MESH_LOOP: DO NM=1,NMESHES
 
   IF (NIC(NOM,NM)==0 .AND. NIC(NM,NOM)==0) CYCLE MESH_LOOP
 
   IF (CODE>0) THEN
      IF (.NOT.ACTIVE_MESH(NM) .OR. .NOT.ACTIVE_MESH(NOM))  CYCLE MESH_LOOP
   ENDIF
 
   IF (DEBUG) THEN
      WRITE(0,*) NOM,' receiving data from ',NM, ' code=',CODE,' tag=',TAGS(NM,NOM,CODE)
   ENDIF
 
   M =>MESHES(NM)
   M2=>MESHES(NOM)%OMESH(NM)
   M4=>MESHES(NOM)
 
   SNODE = NOM-1
   RNODE = NM-1
 
   TAG = TAGS(NM,NOM,CODE)
 
   INITIALIZE_RECEIVE_IF: IF (CODE==0 .AND. RADIATION) THEN
      DO IW=1,M%NEWC
         IF (M2%IJKW(9,IW)==NOM) THEN
            ALLOCATE(M2%WALL(IW)%ILW(NRA,NSB))
            M2%WALL(IW)%ILW = SIGMA*TMPA4*RPI
         ENDIF
      ENDDO
   ENDIF INITIALIZE_RECEIVE_IF
 
   RECEIVE_PREDICTOR_IF: IF (CODE==1) THEN
      IF (NIC(NOM,NM)>0) THEN
         LL = 0
         UNPACK_RPKG1: DO 
            IW = NINT(M2%RPKG1(LL+1))
            IF (IW==-999) EXIT UNPACK_RPKG1
            II = M4%IJKW(10,IW)
            JJ = M4%IJKW(11,IW)
            KK = M4%IJKW(12,IW)
            M2%TMP(II,JJ,KK) = M2%RPKG1(LL+2)
            M2%H(II,JJ,KK)   = M2%RPKG1(LL+3)
            IF (N_SPECIES>0) M2%YYS(II,JJ,KK,1:N_SPECIES)= M2%RPKG1(LL+4:LL+3+N_SPECIES)
            LL = LL+3+N_SPECIES
         ENDDO UNPACK_RPKG1
      ENDIF
   ENDIF RECEIVE_PREDICTOR_IF
 
   RECEIVE_CORRECTOR_IF: IF (CODE==0 .OR. CODE==2) THEN
 
      IF (CODE==2 .AND. NIC(NOM,NM)>0) THEN
         LL = 0
         UNPACK_RPKG2: DO 
            IW = NINT(M2%RPKG2(LL+1))
            IF (IW==-999) EXIT UNPACK_RPKG2
            II = M4%IJKW(10,IW)
            JJ = M4%IJKW(11,IW)
            KK = M4%IJKW(12,IW)
            M2%TMP(II,JJ,KK) = M2%RPKG2(LL+2)
            M2%H(II,JJ,KK)   = M2%RPKG2(LL+3)
            M2%U(II,JJ,KK)   = M2%RPKG2(LL+4)
            M2%V(II,JJ,KK)   = M2%RPKG2(LL+5)
            M2%W(II,JJ,KK)   = M2%RPKG2(LL+6)
            M2%U(II-1,JJ,KK) = M2%RPKG2(LL+7)
            M2%V(II,JJ-1,KK) = M2%RPKG2(LL+8)
            M2%W(II,JJ,KK-1) = M2%RPKG2(LL+9)
            IF (N_SPECIES>0) M2%YY(II,JJ,KK,1:N_SPECIES)= M2%RPKG2(LL+10:LL+9+N_SPECIES)
            LL = LL+9+N_SPECIES
         ENDDO UNPACK_RPKG2
      ENDIF
 
      RECEIVE_RADIATION: IF ( NIC(NOM,NM)>0 .AND. EXCHANGE_RADIATION  .AND. CODE==2) THEN
         LL =0
         UNPACK_WRPKG: DO 
            LL  = LL + 1
            IW = NINT(M2%WRPKG(LL))
            IF (IW==-999) EXIT UNPACK_WRPKG
            DO NN2=1,NSB
               DO NN1=1,NRA
                  LL = LL + 1
                  M4%WALL(IW)%ILW(NN1,NN2) = M2%WRPKG(LL)
               ENDDO
            ENDDO
         ENDDO UNPACK_WRPKG
      ENDIF RECEIVE_RADIATION
 
   ENDIF RECEIVE_CORRECTOR_IF
 
   ! Get Number of Droplet Orphans
 
   IF (DROPLET_FILE) THEN
      M2%N_DROP_ADOPT = MIN(M2%N_DROP_ADOPT,N_DROP_ADOPT_MAX)
      IF (M4%NLP+M2%N_DROP_ADOPT>M4%NLPDIM) CALL RE_ALLOCATE_DROPLETS(1,NOM,0,N_DROP_ADOPT_MAX)
   ENDIF
 
   ! Sending/Receiving Droplet Buffer Arrays
 
   IF_RECEIVE_DROPLETS: IF (DROPLET_FILE) THEN 
      IF_DROPLETS_SENT: IF (M2%N_DROP_ADOPT>0) THEN
 
         NC = 13
         DO N=M4%NLP+1,M4%NLP+M2%N_DROP_ADOPT
            NN = N-M4%NLP-1
            M4%DROPLET(N)%X   = M2%R_RDBUF((NN)*NC+1) 
            M4%DROPLET(N)%Y   = M2%R_RDBUF((NN)*NC+2) 
            M4%DROPLET(N)%Z   = M2%R_RDBUF((NN)*NC+3) 
            M4%DROPLET(N)%TMP = M2%R_RDBUF((NN)*NC+4) 
            M4%DROPLET(N)%U   = M2%R_RDBUF((NN)*NC+5) 
            M4%DROPLET(N)%V   = M2%R_RDBUF((NN)*NC+6) 
            M4%DROPLET(N)%W   = M2%R_RDBUF((NN)*NC+7) 
            M4%DROPLET(N)%R   = M2%R_RDBUF((NN)*NC+8) 
            M4%DROPLET(N)%PWT = M2%R_RDBUF((NN)*NC+9) 
            M4%DROPLET(N)%A_X = M2%R_RDBUF((NN)*NC+10) 
            M4%DROPLET(N)%A_Y = M2%R_RDBUF((NN)*NC+11) 
            M4%DROPLET(N)%A_Z = M2%R_RDBUF((NN)*NC+12) 
            M4%DROPLET(N)%T   = M2%R_RDBUF((NN)*NC+13) 
         ENDDO
 
         NC = 2
         DO N=M4%NLP+1,M4%NLP+M2%N_DROP_ADOPT
            NN = N-M4%NLP-1
            M4%DROPLET(N)%IOR    = M2%R_IDBUF((NN)*NC+1) 
            M4%DROPLET(N)%CLASS  = M2%R_IDBUF((NN)*NC+2) 
         ENDDO
 
         NC = 1
         DO N=M4%NLP+1,M4%NLP+M2%N_DROP_ADOPT
            NN = N-M4%NLP-1
            M4%DROPLET(N)%SHOW = M2%R_LDBUF((NN)*NC+1)  
         ENDDO
 
         M4%NLP = M4%NLP + M2%N_DROP_ADOPT
 
      ENDIF IF_DROPLETS_SENT
   ENDIF IF_RECEIVE_DROPLETS
 
ENDDO MESH_LOOP
 
TUSED(11,:)=TUSED(11,:) + SECOND() - TNOW
END SUBROUTINE MESH_EXCHANGE
 
 

SUBROUTINE WRITE_STRINGS
 
! Write character strings out to the .smv file
 
INTEGER :: N,NOM,N_STRINGS_DUM
CHARACTER(80), ALLOCATABLE, DIMENSION(:) :: STRING_DUM
 
! All meshes send their STRINGs to node 0
 
IF (MYID>0) THEN
   CALL MPI_SEND(MESHES(MYID+1)%N_STRINGS,1,MPI_INTEGER, 0,1,MPI_COMM_WORLD,IERR)
   IF (MESHES(MYID+1)%N_STRINGS>0)  CALL MPI_SEND(MESHES(MYID+1)%STRING(1),MESHES(MYID+1)%N_STRINGS*80, &
       MPI_CHARACTER,0,MYID,MPI_COMM_WORLD,IERR)
ENDIF
 
! Node 0 receives the STRINGs and writes them to the .smv file
 
IF (MYID==0) THEN
   DO N=1,MESHES(1)%N_STRINGS
      WRITE(LU_SMV,'(A)') TRIM(MESHES(1)%STRING(N))
   ENDDO
   OTHER_MESH_LOOP: DO NOM=2,NMESHES 
      CALL MPI_RECV(N_STRINGS_DUM,1,MPI_INTEGER, NOM-1,1,MPI_COMM_WORLD,STATUS,IERR)
      IF (N_STRINGS_DUM>0) THEN
         ALLOCATE(STRING_DUM(N_STRINGS_DUM))
         CALL MPI_RECV(STRING_DUM(1),N_STRINGS_DUM*80, MPI_CHARACTER,NOM-1,NOM-1, MPI_COMM_WORLD,STATUS,IERR)
         DO N=1,N_STRINGS_DUM
            WRITE(LU_SMV,'(A)') TRIM(STRING_DUM(N))
         ENDDO
         DEALLOCATE(STRING_DUM)
      ENDIF
   ENDDO OTHER_MESH_LOOP
ENDIF
 
! All STRING arrays are zeroed out
 
MESHES(MYID+1)%N_STRINGS = 0
 
END SUBROUTINE WRITE_STRINGS
 
 

SUBROUTINE EXCHANGE_DIAGNOSTICS
 
INTEGER  :: NOM,NM,NECYC
REAL(EB) :: T_SUM, TNOW
 
TNOW = SECOND()
NM = MYID+1

T_SUM = 0.
SUM_LOOP: DO I=2,N_TIMERS
   IF (I==9 .OR. I==10) CYCLE SUM_LOOP
   T_SUM = T_SUM + TUSED(I,NM)
ENDDO SUM_LOOP
 
NECYC          = MAX(1,NTCYC(NM)-NCYC(NM))
T_PER_STEP(NM) = (T_SUM-T_ACCUM(NM))/REAL(NECYC,EB)
T_ACCUM(NM)    = T_SUM
NCYC(NM)       = NTCYC(NM)
 
CALL MPI_GATHER(T_ACCUM(MYID+1),1,MPI_DOUBLE_PRECISION, T_ACCUM,1,MPI_DOUBLE_PRECISION,0, MPI_COMM_WORLD,IERR)
CALL MPI_GATHER(T_PER_STEP(MYID+1),1,MPI_DOUBLE_PRECISION, T_PER_STEP,1,MPI_DOUBLE_PRECISION,0, MPI_COMM_WORLD,IERR)
CALL MPI_GATHER(NTCYC(MYID+1),1,MPI_INTEGER, NTCYC,1,MPI_INTEGER,0, MPI_COMM_WORLD,IERR)
CALL MPI_GATHER(HRR(MYID+1),1,MPI_DOUBLE_PRECISION, HRR,1,MPI_DOUBLE_PRECISION,0, MPI_COMM_WORLD,IERR)
CALL MPI_GATHER(RHRR(MYID+1),1,MPI_DOUBLE_PRECISION, RHRR,1,MPI_DOUBLE_PRECISION,0, MPI_COMM_WORLD,IERR)
 
IF (MYID>0) THEN
 
   CALL MPI_SEND(MESHES(MYID+1)%DT,1,MPI_DOUBLE_PRECISION, 0,1,MPI_COMM_WORLD,IERR)
   CALL MPI_SEND(MESHES(MYID+1)%CFL,1,MPI_DOUBLE_PRECISION, 0,1,MPI_COMM_WORLD,IERR)
   CALL MPI_SEND(MESHES(MYID+1)%DIVMX,1,MPI_DOUBLE_PRECISION, 0,1,MPI_COMM_WORLD,IERR)
   CALL MPI_SEND(MESHES(MYID+1)%DIVMN,1,MPI_DOUBLE_PRECISION, 0,1,MPI_COMM_WORLD,IERR)
   CALL MPI_SEND(MESHES(MYID+1)%RESMAX,1,MPI_DOUBLE_PRECISION, 0,1,MPI_COMM_WORLD,IERR)
   CALL MPI_SEND(MESHES(MYID+1)%POIS_PTB,1,MPI_DOUBLE_PRECISION, 0,1,MPI_COMM_WORLD,IERR)
   CALL MPI_SEND(MESHES(MYID+1)%POIS_ERR,1,MPI_DOUBLE_PRECISION, 0,1,MPI_COMM_WORLD,IERR)
   CALL MPI_SEND(MESHES(MYID+1)%VN,1,MPI_DOUBLE_PRECISION, 0,1,MPI_COMM_WORLD,IERR)
   CALL MPI_SEND(MESHES(MYID+1)%ICFL,1,MPI_INTEGER, 0,1,MPI_COMM_WORLD,IERR)
   CALL MPI_SEND(MESHES(MYID+1)%JCFL,1,MPI_INTEGER, 0,1,MPI_COMM_WORLD,IERR)
   CALL MPI_SEND(MESHES(MYID+1)%KCFL,1,MPI_INTEGER, 0,1,MPI_COMM_WORLD,IERR)
   CALL MPI_SEND(MESHES(MYID+1)%IMX,1,MPI_INTEGER, 0,1,MPI_COMM_WORLD,IERR)
   CALL MPI_SEND(MESHES(MYID+1)%JMX,1,MPI_INTEGER, 0,1,MPI_COMM_WORLD,IERR)
   CALL MPI_SEND(MESHES(MYID+1)%KMX,1,MPI_INTEGER, 0,1,MPI_COMM_WORLD,IERR)
   CALL MPI_SEND(MESHES(MYID+1)%IMN,1,MPI_INTEGER, 0,1,MPI_COMM_WORLD,IERR)
   CALL MPI_SEND(MESHES(MYID+1)%JMN,1,MPI_INTEGER, 0,1,MPI_COMM_WORLD,IERR)
   CALL MPI_SEND(MESHES(MYID+1)%KMN,1,MPI_INTEGER, 0,1,MPI_COMM_WORLD,IERR)
   CALL MPI_SEND(MESHES(MYID+1)%IRM,1,MPI_INTEGER, 0,1,MPI_COMM_WORLD,IERR)
   CALL MPI_SEND(MESHES(MYID+1)%JRM,1,MPI_INTEGER, 0,1,MPI_COMM_WORLD,IERR)
   CALL MPI_SEND(MESHES(MYID+1)%KRM,1,MPI_INTEGER, 0,1,MPI_COMM_WORLD,IERR)
   CALL MPI_SEND(MESHES(MYID+1)%I_VN,1,MPI_INTEGER, 0,1,MPI_COMM_WORLD,IERR)
   CALL MPI_SEND(MESHES(MYID+1)%J_VN,1,MPI_INTEGER, 0,1,MPI_COMM_WORLD,IERR)
   CALL MPI_SEND(MESHES(MYID+1)%K_VN,1,MPI_INTEGER, 0,1,MPI_COMM_WORLD,IERR)
   CALL MPI_SEND(MESHES(MYID+1)%NLP,1,MPI_INTEGER, 0,1,MPI_COMM_WORLD,IERR)

ELSE 

   DO NOM=2,NMESHES
      CALL MPI_RECV(MESHES(NOM)%DT,1,MPI_DOUBLE_PRECISION, NOM-1,1,MPI_COMM_WORLD,STATUS,IERR)
      CALL MPI_RECV(MESHES(NOM)%CFL,1,MPI_DOUBLE_PRECISION, NOM-1,1,MPI_COMM_WORLD,STATUS,IERR)
      CALL MPI_RECV(MESHES(NOM)%DIVMX,1,MPI_DOUBLE_PRECISION, NOM-1,1,MPI_COMM_WORLD,STATUS,IERR)
      CALL MPI_RECV(MESHES(NOM)%DIVMN,1,MPI_DOUBLE_PRECISION, NOM-1,1,MPI_COMM_WORLD,STATUS,IERR)
      CALL MPI_RECV(MESHES(NOM)%RESMAX,1,MPI_DOUBLE_PRECISION, NOM-1,1,MPI_COMM_WORLD,STATUS,IERR)
      CALL MPI_RECV(MESHES(NOM)%POIS_PTB,1,MPI_DOUBLE_PRECISION, NOM-1,1,MPI_COMM_WORLD,STATUS,IERR)
      CALL MPI_RECV(MESHES(NOM)%POIS_ERR,1,MPI_DOUBLE_PRECISION, NOM-1,1,MPI_COMM_WORLD,STATUS,IERR)
      CALL MPI_RECV(MESHES(NOM)%VN,1,MPI_DOUBLE_PRECISION, NOM-1,1,MPI_COMM_WORLD,STATUS,IERR)
      CALL MPI_RECV(MESHES(NOM)%ICFL,1,MPI_INTEGER, NOM-1,1,MPI_COMM_WORLD,STATUS,IERR)
      CALL MPI_RECV(MESHES(NOM)%JCFL,1,MPI_INTEGER, NOM-1,1,MPI_COMM_WORLD,STATUS,IERR)
      CALL MPI_RECV(MESHES(NOM)%KCFL,1,MPI_INTEGER, NOM-1,1,MPI_COMM_WORLD,STATUS,IERR)
      CALL MPI_RECV(MESHES(NOM)%IMX,1,MPI_INTEGER, NOM-1,1,MPI_COMM_WORLD,STATUS,IERR)
      CALL MPI_RECV(MESHES(NOM)%JMX,1,MPI_INTEGER, NOM-1,1,MPI_COMM_WORLD,STATUS,IERR)
      CALL MPI_RECV(MESHES(NOM)%KMX,1,MPI_INTEGER, NOM-1,1,MPI_COMM_WORLD,STATUS,IERR)
      CALL MPI_RECV(MESHES(NOM)%IMN,1,MPI_INTEGER, NOM-1,1,MPI_COMM_WORLD,STATUS,IERR)
      CALL MPI_RECV(MESHES(NOM)%JMN,1,MPI_INTEGER, NOM-1,1,MPI_COMM_WORLD,STATUS,IERR)
      CALL MPI_RECV(MESHES(NOM)%KMN,1,MPI_INTEGER, NOM-1,1,MPI_COMM_WORLD,STATUS,IERR)
      CALL MPI_RECV(MESHES(NOM)%IRM,1,MPI_INTEGER, NOM-1,1,MPI_COMM_WORLD,STATUS,IERR)
      CALL MPI_RECV(MESHES(NOM)%JRM,1,MPI_INTEGER, NOM-1,1,MPI_COMM_WORLD,STATUS,IERR)
      CALL MPI_RECV(MESHES(NOM)%KRM,1,MPI_INTEGER, NOM-1,1,MPI_COMM_WORLD,STATUS,IERR)
      CALL MPI_RECV(MESHES(NOM)%I_VN,1,MPI_INTEGER, NOM-1,1,MPI_COMM_WORLD,STATUS,IERR)