Changeset 729 in lmdz_wrf

Timestamp:

Apr 26, 2016, 6:52:24 PM (9 years ago)

Author:

lfita

Message:

Fixing issue on the right values for the coarse lon/lat

Location:

trunk/tools

Files:

• module_ForInterpolate.F90 (modified) (6 diffs)
• nc_var_tools.py (modified) (6 diffs)

trunk/tools/module_ForInterpolate.F90

@@ -197 +197 @@
 END SUBROUTINE CoarselonlatFind
 
-SUBROUTINE CoarseInterpolate(projlon, projlat, lonvs, latvs, percen, mindiff, ivar, newvar, newvarin, &
-  newvarinpt, newvarindiff, dimx, dimy, Ninpts)
+SUBROUTINE CoarseInterpolate(inpts, projlon, projlat, lonvs, latvs, percen, mindiff, ivar, newvar,    &
+  newvarin, newvarinpt, newvarindiff, dimx, dimy, Ninpts)
 ! Subroutine which finds the closest grid point within a projection throughout a first guest 
 !   approche from percentages of the whole domain
@@ -210 +210 @@
   REAL(r_k), DIMENSION(dimx,dimy), INTENT(in)            :: projlon, projlat
   INTEGER, INTENT(in)                                    :: Ninpts
+  INTEGER, DIMENSION(Ninpts), INTENT(in)                 :: inpts
   REAL(r_k), DIMENSION(Ninpts), INTENT(in)               :: ivar, lonvs, latvs
   REAL(r_k)                                              :: mindiff, percen
@@ -229 +230 @@
 
 !!!!!!! Variables
+! inpts: relative position of the values to interpolate
 ! dimx, dimy: dimension length of the target interpolation
 ! proj[lon/lat]: longitudes and latitudes of the target interpolation
@@ -248 +250 @@
   extremelat = (/ MINVAL(projlat), MAXVAL(projlat) /)
 
-  PRINT *,'  ' // TRIM(fname) //' fraction:', dimx, ' ,', dimy, ' %', percen
-
-  dfracdx = INT(1./percen)
-  dfracdy = INT(1./percen)
+  PRINT *,'  ' // TRIM(fname) //' total space:', dimx, ', ', dimy, ' %', percen
+
+  dfracdx = INT(1./percen+1)
+  dfracdy = INT(1./percen+1)
   fracdx = INT(dimx*percen)
   fracdy = INT(dimy*percen)
+  PRINT *,'  ' // TRIM(fname) //' fraction:', dfracdx, ', ', dfracdy, ' freq:', fracdx,', ',fracdy
 
   IF (ALLOCATED(fractionlon)) DEALLOCATE(fractionlon)
@@ -272 +275 @@
   DO i=1,dfracdx
     DO j=1,dfracdy
-      fractionlon(i,j) = projlon(fracdx*(i-1),fracdy*(j-1))
-      fractionlat(i,j) = projlat(fracdx*(i-1),fracdy*(j-1))
+      fractionlon(i,j) = projlon(fracdx*(i-1)+1,fracdy*(j-1)+1)
+      fractionlat(i,j) = projlat(fracdx*(i-1)+1,fracdy*(j-1)+1)
+!      PRINT *,'i,j:',i,', ',j,' frac ij:',fracdx*(i-1),', ',fracdy*(j-1),' lonlat:', fractionlon(i,j),&
+!        ', ',fractionlat(i,j)
     END DO
   END DO
 
   PRINT *,'  ' // TRIM(fname) // ' fractions of:'
-  PRINT *,' lon _______'
-  PRINT *,fractionlon
+  PRINT *,' lon _______ (',dfracdx,', ',dfracdy,')'
+  DO i=1,dfracdx
+    PRINT *,fractionlon(i,:)
+  END DO
   PRINT *,' lat_______'
-  PRINT *,fractionlat
+  DO i=1,dfracdx
+    PRINT *,fractionlat(i,:)
+  END DO
 
   DO iv=1,Ninpts
@@ -292 +301 @@
 
         IF (ilonlat(1) >= 0 .AND. ilonlat(1) >= 0) THEN
-          newvar(ilonlat(1),ilonlat(2)) = ivar(iv)
-          newvarin(ilonlat(1),ilonlat(2)) = iv
-          newvarinpt(iv) = 1
-          newvarindiff(iv) = mindiffLl
+          newvar(ilonlat(1),ilonlat(2)) = ivar(inpts(iv))
+          newvarin(ilonlat(1),ilonlat(2)) = inpts(iv)
+          newvarinpt(inpts(iv)) = 1
+          newvarindiff(inpts(iv)) = mindiffLl
 !          PRINT *,'Lluis iv:', newvarin(ilonlat(1),ilonlat(2)), ' localized:', newvarinpt(iv),        &
 !            ' values:', newvar(ilonlat(1),ilonlat(2)), ' invalues:', ivar(iv), ' mindist:',           &

trunk/tools/nc_var_tools.py

@@ -19443 +19443 @@
       foudre: f2py -m module_ForInterpolate --f90exec=/usr/bin/gfortran-4.7 -c module_ForInterpolate.F90 module_generic.F90 >& run_f2py.log
       ciclad: f2py --f90flags="-fPIC" -L/opt/canopy-1.3.0/Canopy_64bit/System/lib/ -L/usr/lib64/ -L/opt/canopy-1.3.0/Canopy_64bit/System/lib/ -m module_ForInterpolate -c module_ForInterpolate.F90 module_generic.F90
-      values= [lonmame],[latname],[fillVal],[resolution],[kind],[lonlatProjfile],[fracd],[fracs]
+      values= [lonmame],[latname],[fillVal],[resolution],[kind],[lonlatProjfile],[ipoint],[fracd],[fracs]
         [lonname]: name of the longitude variable
         [latname]: name of the latitude variable
@@ -19458 +19458 @@
          'Goode': Goode projection
         [lonlatProjfile]: file with the lon,lat of the desired projection. 'None' to be computed and written on fly
+        [ipoint]: initial point to use for the interpolation (0, the first)
         [fracd]: Percentage of the fractions within perform the first guess search
         [fracs]: Number of grid points to perform the syncronization with the file and the computed values
@@ -19475 +19476 @@
 
     arguments = '[lonmame],[latname],[fillVal],[resolution],[kind],' +               \
-      '[lonlatProjfile],[fracd],[fracs]'
+      '[lonlatProjfile],[ipoint],[fracd],[fracs]'
     check_arguments(fname, values, arguments, ',')
 
@@ -19493 +19494 @@
     kind = values.split(',')[4]
     Projfile = values.split(',')[5]
-    fracd = np.float(values.split(',')[6])
-    fracs = int(values.split(',')[7])
+    ipoint = int(values.split(',')[6])
+    fracd = np.float(values.split(',')[7])
+    fracs = int(values.split(',')[8])
 
     if Projfile == 'None':
@@ -19724 +19726 @@
 # Error at 150024, 150025, 151709, 153421
     print '  ' + fname + ': from:', Ninpts,'re-locating:',Nptsf,'points...'
-#    fracs = 100000
     if kind == 'Goode':
 #        newvar,newvarin,newvarinpt,newvarindiff =                                    \
 #          fin.module_forinterpolate.coarseinterpolate(projlon, projlat, lonvs,       \
 #          latvs, percen, mindiff, ivar, dimx, dimy, ninpts)
-        for ir in range(0,Ninpts,fracs):
+        for ir in range(ipoint,Ninpts,fracs):
             iri = ir
             ire = ir + fracs + 1
             print iri,',',ire
 #            percendone(iri,Ninpts,0.5,'done:')
+            pts = np.arange(iri,ire,1, dtype='int32')
             lonvss = lonvs[iri:ire].astype('float64')
             latvss = latvs[iri:ire].astype('float64')
@@ -19739 +19741 @@
 
             newvar,newvarin,newvarinpt,newvarindiff =                                \
-              fin.module_forinterpolate.coarseinterpolate(projlon, projlat,          \
+              fin.module_forinterpolate.coarseinterpolate(pts, projlon, projlat,     \
               lonvss, latvss, np.float64(fracd), np.float64(mindiff), ovars)
             newnc.sync()