Merge pull request #11 from Parallel-in-Time/fix_rnd_numbers

Fix rnd numbers

Author: danielru

src/run_timestepper.f90

@@ -67,9 +67,9 @@ PROGRAM run_timestepper
 
 ! Load initial value
 ALLOCATE(Q(-2:Nx+3,-2:Ny+3,-2:Nz+3))
-OPEN(unit=100, file='q0.dat', ACTION='read', STATUS='old')
-READ(100,'(F35.25)') Q
-CLOSE(100)
+OPEN(unit=11, file='q0.dat', ACTION='read', STATUS='old')
+READ(11,'(F35.25)') Q
+CLOSE(11)
 
 ! Output
 IF (be_verbose) THEN
@@ -108,4 +108,4 @@ PROGRAM run_timestepper
 CALL FinalizeTimestepper
 CALL MPI_FINALIZE(ierr)
 
-END PROGRAM run_timestepper
+END PROGRAM run_timestepper

test/src/advection_boundaries_test.f90

@@ -13,16 +13,27 @@ PROGRAM advection_boundaries_test
 DOUBLE PRECISION, PARAMETER :: pi = 3.1415926535897932_8 ! underscore indicates rounding to real(8) precision
 DOUBLE PRECISION, ALLOCATABLE, DIMENSION(:,:,:,:) :: Q, RQ, Qbc, RQbc
 DOUBLE PRECISION :: dx, dy, dz, x, y, z
-INTEGER :: Nx, Ny, Nz, i, j, k, order, Nthreads, nt, seed, time1(8)
+INTEGER :: Nx, Ny, Nz, i, j, k, order, Nthreads, nt, seed_size, clock
+INTEGER, PARAMETER :: N_min = 6, N_max = 128
 
-CALL DATE_AND_TIME(values=time1)
-seed = 1000*time1(7)+time1(8)
-CALL SRAND(seed)
+INTEGER, ALLOCATABLE, DIMENSION(:) :: seed
+REAL :: random_real
+
+CALL RANDOM_SEED(size = seed_size)
+ALLOCATE(seed(seed_size))
+CALL SYSTEM_CLOCK(count = clock)
+seed = clock +  37 * (/ (i - 1, i = 1, seed_size) /)
+CALL RANDOM_SEED(put = seed)
+DEALLOCATE(seed)
 
 ! Generate random values of Nx, Ny, Nz that are at least 6, to exclude too small domains
-Nx = 6 + INT( RAND()*128 )
-Ny = 6 + INT( RAND()*128 )
-Nz = 6 + INT( RAND()*128 )
+CALL RANDOM_NUMBER(random_real)
+Nx = N_min + FLOOR( (N_max+1-N_min)*random_real )
+CALL RANDOM_NUMBER(random_real)
+Ny = N_min + FLOOR( (N_max+1-N_min)*random_real )
+CALL RANDOM_NUMBER(random_real)
+Nz = N_min + FLOOR( (N_max+1-N_min)*random_real )
+
 Nthreads = 8
 
 ALLOCATE(Q(   -2:Nx+3,-2:Ny+3,-2:Nz+3,0:Nthreads-1))
@@ -111,4 +122,4 @@ PROGRAM advection_boundaries_test
 
 PRINT*, '\x1B[32m[0] -- Successful: GetRHSAdvection produces identical results when ghost-cells are filled manually or through the boundaries module.\x1B[0m'
 
-END PROGRAM advection_boundaries_test
+END PROGRAM advection_boundaries_test

test/src/advection_test.f90

@@ -25,37 +25,43 @@ PROGRAM Upwind_Test
 DOUBLE PRECISION, DIMENSION(Nthreads)             :: runtimes
 INTEGER                                           :: i, j, k, r, nt, ierr, mpi_thread_provided, i_add, j_add, k_add
 
-INTEGER :: Nx, Ny, Nz, i_start, i_end, j_start, j_end, k_start, k_end, seed, time1(8), order
+INTEGER, ALLOCATABLE, DIMENSION(:) :: seed
+
+INTEGER :: Nx, Ny, Nz, i_start, i_end, j_start, j_end, k_start, k_end, seed_size, clock, order
+REAL :: random_real
 
 LOGICAL, PARAMETER, DIMENSION(3) :: do_test = (/ .true. , .true., .true. /)
 
 CALL MPI_INIT_THREAD(MPI_THREAD_FUNNELED, mpi_thread_provided, ierr)
 
 ! Create two random value for the offsets
-CALL DATE_AND_TIME(values=time1)
-seed = 1000*time1(7)+time1(8)
-CALL SRAND(seed)
+CALL RANDOM_SEED(size = seed_size)
+ALLOCATE(seed(seed_size))
+CALL SYSTEM_CLOCK(count = clock)
+seed = clock +  37 * (/ (i - 1, i = 1, seed_size) /)
+CALL RANDOM_SEED(put = seed)
+DEALLOCATE(seed)
 
 IF (do_test(1)) THEN
 
     ! Test for order 1 and 5
     DO order=1,5,4
 
-        Nx = 128 + INT( RAND()*128 )
-        Ny = 128 + INT( RAND()*128 )
-        Nz = 128 + INT( RAND()*128 )
+        Nx = random_integer(128, 256)
+        Ny = random_integer(128, 256)
+        Nz = random_integer(128, 256)
 
         ! Generate three random integers between -256 and +256
-        i_start = INT( RAND()*(256+1+256) )-256
-        j_start = INT( RAND()*(256+1+256) )-256
-        k_start = INT( RAND()*(256+1+256) )-256
+        i_start = random_integer(-256, 256)
+        j_start = random_integer(-256, 256)
+        k_start = random_integer(-256, 256)
 
         ! Then generate three more positive random integers between 3 and 32.
         ! In initialization, the used buffer is enlarged by these numbers to verify the routine
         ! can correctly work on a subset of the allocated buffer
-        i_add = 3 + INT( RAND()*32 )
-        j_add = 3 + INT( RAND()*32 )
-        k_add = 3 + INT( RAND()*32 )
+        i_add = random_integer(3, 32)
+        j_add = random_integer(3, 32)
+        k_add = random_integer(3, 32)
 
         ! The first test makes sure that a constant Q leads to a zero flux divergence. This is
         ! for running 1 to 8 concurrent calls to GetRHS. Also, the time is measured in some 
@@ -80,7 +86,7 @@ PROGRAM Upwind_Test
             CALL OMP_SET_NUM_THREADS(nt)
 
             ! fill Q with constant random value
-            q_val = RAND(1)
+            CALL RANDOM_NUMBER(q_val)
 
             !$OMP PARALLEL DO schedule(static)
             DO i=0,nt-1
@@ -134,21 +140,21 @@ PROGRAM Upwind_Test
 ! TEST 2: Make sure that if Q is constant in one dimension, so is the resulting RQ
 IF (do_test(2)) THEN
 
-        Nx = 32 + INT( RAND()*32 )
-        Ny = 32 + INT( RAND()*32 )
-        Nz = 32 + INT( RAND()*32 )
+        Nx = random_integer(32, 64)
+        Ny = random_integer(32, 64)
+        Nz = random_integer(32, 64)
 
         ! Generate three random integers between -256 and +256
-        i_start = INT( RAND()*(256+1+256) )-256
-        j_start = INT( RAND()*(256+1+256) )-256
-        k_start = INT( RAND()*(256+1+256) )-256
+        i_start = random_integer(-256, 256)
+        j_start = random_integer(-256, 256)
+        k_start = random_integer(-256, 256)
 
         ! Then generate three more positive random integers between 3 and 32.
         ! In initialization, the used buffer is enlarged by these numbers to verify the routine
         ! can correctly work on a subset of the allocated buffer
-        i_add = 3 + INT( RAND()*32 )
-        j_add = 3 + INT( RAND()*32 )
-        k_add = 3 + INT( RAND()*32 )
+        i_add = random_integer(3, 32)
+        j_add = random_integer(3, 32)
+        k_add = random_integer(3, 32)
 
         ! The first test makes sure that a constant Q leads to a zero flux divergence. This is
         ! for running 1 to 8 concurrent calls to GetRHS. Also, the time is measured in some 
@@ -295,16 +301,16 @@ PROGRAM Upwind_Test
             dz = 1.0/DBLE(Nz)
 
             ! Generate three random integers between -256 and +256
-            i_start = INT( RAND()*(256+1+256) )-256
-            j_start = INT( RAND()*(256+1+256) )-256
-            k_start = INT( RAND()*(256+1+256) )-256
+            i_start = random_integer(-256, 256)
+            j_start = random_integer(-256, 256)
+            k_start = random_integer(-256, 256)
 
-            ! Then generate three more positive random integers between 3 and 32.
+            ! Then generate three more positive random integers between 3 and 8.
             ! In initialization, the used buffer is enlarged by these numbers to verify the routine
             ! can correctly work on a subset of the allocated buffer
-            i_add = 3 + INT( RAND()*8 )
-            j_add = 3 + INT( RAND()*8 )
-            k_add = 3 + INT( RAND()*8 )
+            i_add = random_integer(3, 8)
+            j_add = random_integer(3, 8)
+            k_add = random_integer(3, 8)
 
             i_end = i_start + Nx - 1
             j_end = j_start + Ny - 1
@@ -412,4 +418,14 @@ PROGRAM Upwind_Test
     PRINT*, '\x1B[32m[0] -- Successful: Advection module returns zero for constant input and produces expected rates of convergence. \x1B[0m'
 END IF
 
-END PROGRAM Upwind_Test
+CONTAINS
+        FUNCTION random_integer(vmin, vmax) RESULT(val)
+                INTEGER, INTENT(IN)  :: vmin, vmax
+                INTEGER              :: val
+
+                CALL RANDOM_NUMBER(random_real)
+                val = vmin + FLOOR( (vmax+1-vmin)*random_real )
+
+        END FUNCTION random_integer
+
+END PROGRAM Upwind_Test

test/src/boundaries_test.f90

@@ -8,16 +8,25 @@ PROGRAM boundaries_test
 
 DOUBLE PRECISION, ALLOCATABLE, DIMENSION(:,:,:) :: Q, Qall
 DOUBLE PRECISION :: dx, dy, dz, x, y, z
-INTEGER :: Nx, Ny, Nz, seed, time1(8), i, j, k
-
-CALL DATE_AND_TIME(values=time1)
-seed = 1000*time1(7)+time1(8)
-CALL SRAND(seed)
+INTEGER :: Nx, Ny, Nz, seed_size, i, j, k, clock
+INTEGER, PARAMETER :: N_min = 25, N_max = 256
+INTEGER, ALLOCATABLE, DIMENSION(:) :: seed
+REAL random_real
+
+CALL RANDOM_SEED(size = seed_size)
+ALLOCATE(seed(seed_size))
+CALL SYSTEM_CLOCK(count = clock)
+seed = clock +  37 * (/ (i - 1, i = 1, seed_size) /)
+CALL RANDOM_SEED(put = seed)
+DEALLOCATE(seed)
 
 ! Create random integer values for Nx, Ny, Nz
-Nx = 25 + INT(RAND()*256)
-Ny = 25 + INT(RAND()*256)
-Nz = 25 + INT(RAND()*256)
+CALL RANDOM_NUMBER(random_real)
+Nx = N_min + FLOOR( (N_max+1-N_min)*random_real )
+CALL RANDOM_NUMBER(random_real)
+Ny = N_min + FLOOR( (N_max+1-N_min)*random_real )
+CALL RANDOM_NUMBER(random_real)
+Nz = N_min + FLOOR( (N_max+1-N_min)*random_real )
 
 dx = 1.0/DBLE(Nx)
 dy = 1.0/DBLE(Ny)
@@ -106,4 +115,4 @@ PROGRAM boundaries_test
 
 PRINT*, '\x1B[32m[0] -- Successful: Ghost cell values generated by boundaries module match directly inserted values.\x1B[0m'
 
-END PROGRAM boundaries_test
+END PROGRAM boundaries_test