Moving average with mask in Fortran - fortran

Question

I have to calculate the moving average of a masked dataset with dimensions (7320,8520) in Fortran. I wrote a subroutine that receives the data (TS) and outputs the averaged data (TS_NEW). The problem is that the code is taking too long to run (it actually never finishes, despite not running into memory issues). I wonder if there's a way to make the code more efficient. Below is the code I wrote:
SUBROUTINE avgwin(ts,winsize,size1,size2,sizelat,sizelon,ts_new)
implicit none
double precision, dimension(size1,size2),INTENT(IN) :: ts
double precision, dimension(winsize,winsize) :: store
double precision, dimension(sizelon,sizelat),INTENT(OUT) :: ts_new
integer :: j,k
integer :: A, B
integer,INTENT(IN) :: winsize,size1,size2,sizelat,sizelon
logical, dimension(size1,size2) :: mask,mask2
double precision :: SUMVAR, COUNTVAR
A=1
B=1
mask = ts > 0 !Mask to highlight all the OK values
mask2 = ts < 0 !Mask to highlight all the values to be discarded
do j=1,sizelat !Looping through latitude
do k=1,sizelon !Looping through longitude
if (ALL(mask2(k:k+winsize-1,j:j+winsize-1)) .eqv. .true.) then
ts_new(B,A) = -100 !Adds a fill value if all the elements are to be discarded
B=B+1
else
SUMVAR = sum(ts(k:k+winsize-1,j:j+winsize-1), MASK=mask(k:k+winsize-1,j:j+winsize-1))
COUNTVAR = count(mask(k:k+winsize-1,j:j+winsize-1))
ts_new(B,A) = SUMVAR/COUNTVAR
B=B+1
end if
end do
B=1
A=A+1
end do
END SUBROUTINE
program test
implicit none
double precision, dimension(7320,8520) :: DATA
double precision, dimension(:,:),allocatable :: DATA_NEW
integer :: sizelat, sizelon, i, j, len1, len2, winsize
integer, dimension(3) :: sizes
len1 = 7320
len2 = 8520
do i=1,8520
do j=1,7320
DATA(j,i)= i !Just for testing purposes
end do
end do
sizes(1:3) = (/300,301,302/)
do w=1,3
winsize = sizes(w)
sizelon = len1-winsize+1
sizelat = len2-winsize+1
allocate(DATA_NEW(sizelon,sizelat))
CALL avgwin(DATA,winsize,len1,len2,sizelat,sizelon,DATANEW)
end do
end program test

Answer 1

Though not sure if this meets the OP's purpose, how about first collecting data along one dimension and then collecting the processed data again along another dimension (i.e., partial summation)? For example, if we consider a simpler problem of summing data( 1:L, 1:L ) over moving window of size w, there may be three different ways to achieve this:
program main
implicit none
real, allocatable, dimension(:,:) :: data, direct, part1, part2
integer :: i1, i2, L, S, w
real :: t1, t2
L = 2000
w = 50
S = L - w + 1
allocate( data( L, L ), direct( S, S ), &
part1( L, S ), part2( S, S ) )
!> test data
do i2 = 1, L
do i1 = 1, L
data( i1, i2 ) = mod( i1 + i2, 2 )
enddo
enddo
!> method 1: direct sum (cost = O( S^2 * w^2 ))
call cpu_time( t1 )
do i2 = 1, S
do i1 = 1, S
direct( i1, i2 ) = sum( data( i1:(i1 + w - 1), i2:(i2 + w - 1) ) )
enddo
enddo
call cpu_time( t2 )
print *, "time (s) = ", t2 - t1
!> method 2: partial sum (cost = O( S^2 * w * 2 ))
call cpu_time( t1 )
do i2 = 1, S
do i1 = 1, L
part1( i1, i2 ) = sum( data( i1, i2:(i2 + w - 1) ) )
enddo
enddo
do i2 = 1, S
do i1 = 1, S
part2( i1, i2 ) = sum( part1( i1:(i1 + w - 1), i2 ) )
enddo
enddo
call cpu_time( t2 )
print *, "time (s) = ", t2 - t1
print *, "error = ", maxval( abs( part2 - direct ) )
!> method 3: an improved version of method 2 (cost = O( S^2 ))
call cpu_time( t1 )
do i1 = 1, L
part1( i1, 1 ) = sum( data( i1, 1:w ) )
do i2 = 2, S
part1( i1, i2 ) = part1( i1, i2-1 ) &
- data( i1, i2-1 ) + data( i1, i2+w-1 )
enddo
enddo
do i2 = 1, S
part2( 1, i2 ) = sum( part1( 1:w, i2 ) )
do i1 = 2, S
part2( i1, i2 ) = part2( i1-1, i2 ) &
- part1( i1-1, i2 ) + part1( i1+w-1, i2 )
enddo
enddo
call cpu_time( t2 )
print *, "time (s) = ", t2 - t1
print *, "error = ", maxval( abs( part2 - direct ) )
end program
Then, gfortran-7.2 -O3 test.f90 seems to give some nice speedup:
time (s) = 9.64789867
time (s) = 0.345023155
error = 0.00000000
time (s) = 8.60958099E-02
error = 0.00000000
To calculate moving average with mask, a similar approach may work somehow. If we search the net, there may be other (better) approaches/libraries for such moving average, because it is very common calculation...