anchor.diff:  						starty=max(1, j-windowsize)
   						endy  =min(ny,j+windowsize)
   						! then compute the mean within that window (sum/n)
  +						! note, artifacts near the borders (mentioned in ydim==3) don't affect this
  +						! because the borders *should* be well away from the domain
  +						! if the forcing data are not much larger than the model domain this *could* create issues
   						wind(i,j,k)=sum(inputwind(startx:endx,starty:endy,k)) &
   									/ ((endx-startx+1)*(endy-starty+1))
   					endif
  
positive.code: 		nx=size(wind,1)
  		ny=size(wind,2) !note, this is Z for the high-res domain (ydim=3)
  		nz=size(wind,3) !note, this could be the Y or Z dimension depending on ydim
  		
  		! this is ~20MB that has to be allocated deallocated every call...
  		allocate(inputwind(nx,ny,nz)) ! Can't be module level because nx,ny,nz could change between calls, 
  									  ! could be part of a "smoothable" object to avoid allocate-deallocating constantly
  		
  		inputwind=wind !make a copy so we always use the unsmoothed data when computing the smoothed data
  		if (((windowsize*2+1)>nx).and.(ydim==3)) then
  			write(*,*) "WARNING can not operate if windowsize*2+1 is larger than nx"
  
negative.code: 		!$omp shared(wind,inputwind)
  		allocate(rowsums(nx)) !this is only used when ydim=3, so nz is really ny
  		allocate(rowmeans(nx)) !this is only used when ydim=3, so nz is really ny
  		nrows=windowsize*2+1
  		ncols=windowsize*2+1
  		!$omp do schedule(static)
  		do j=1,ny
  			
  			! so we pre-compute the sum over rows for each column in the current window
  			if (ydim==3) then
  				rowsums=inputwind(1:nx,j,1)*(windowsize+1)
  				do i=1,windowsize
  					rowsums=rowsums+inputwind(1:nx,j,i)
  				enddo
  			endif
  			! don't parallelize over this loop because it is much more efficient to be able to assume
  			! that you ran the previous row in serial for the slow (ydim=3) case
  