Changeset 2319 in lmdz_wrf for trunk/tools


Ignore:
Timestamp:
Feb 5, 2019, 5:04:56 PM (6 years ago)
Author:
lfita
Message:

Finally working for 1D lon/lat variables from CMIP5 !!

Location:
trunk/tools
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • trunk/tools/module_scientific.f90

    r2318 r2319  
    56635663    INTEGER                                              :: ii3, ss1, ss2, ss3
    56645664    INTEGER                                              :: Ncounts, Nin
     5665    INTEGER, DIMENSION(1)                                :: dmaxvarin
    56655666    CHARACTER(len=3)                                     :: val1S, val2S
    56665667    CHARACTER(len=30)                                    :: val3S
     
    56995700    ss3 = 3 + 1
    57005701    ii3 = 1 + 1
     5702
     5703    dmaxvarin = UBOUND(varin)
    57015704
    57025705    ! Let's be efficient?
     
    57495752          ELSE
    57505753            i1 = gridsin(s1,s2,s3,1,idv)
    5751             varout(s1,s2,s3,1) = varin(i1)
    5752             varout(s1,s2,s3,2) = varin(i1)
    5753             varout(s1,s2,s3,3) = varin(i1)
    5754             varout(s1,s2,s3,4) = varin(i1)*varin(i1)
    5755             varout(s1,s2,s3,5) = zeroRK
    5756             varout(s1,s2,s3,6) = varin(i1)
    5757             varout(s1,s2,s3,7) = Nin*1.
     5754            IF (i1 > 0 .AND. i1 <= dmaxvarin(1)) THEN
     5755              varout(s1,s2,s3,1) = varin(i1)
     5756              varout(s1,s2,s3,2) = varin(i1)
     5757              varout(s1,s2,s3,3) = varin(i1)
     5758              varout(s1,s2,s3,4) = varin(i1)*varin(i1)
     5759              varout(s1,s2,s3,5) = zeroRK
     5760              varout(s1,s2,s3,6) = varin(i1)
     5761              varout(s1,s2,s3,7) = Nin*1.
     5762            END IF
    57585763          END IF
    57595764        END DO
  • trunk/tools/nc_var_tools.py

    r2315 r2319  
    2787327873        newlonbndsv = np.zeros((4,sdimy,sdimx), dtype=np.float)
    2787427874        newlatbndsv = np.zeros((4,sdimy,sdimx), dtype=np.float)
    27875         print 'Lluis shapes olonbnds1D:', olonbnds1D.shape
    2787627875        for j in range(sdimy):
    2787727876            for i in range(sdimx):
     
    2840428403                getvarybndst = ydimvarbnds2D.transpose()
    2840528404
    28406                 Ngridsint, gridsint, areast, percenst =                              \
     28405                Ngridsint, gridsint, areas2Dt, areast, percenst =                    \
    2840728406                  fsci.module_scientific.grid_spacepercen(xcavals=reflont,           \
    2840828407                  ycavals=reflatt, xbavals=refvarxbndst, ybavals=refvarybndst,       \
     
    2842028419                gridsin = gridsin - 1
    2842128420
     28421                areas2D = areas2Dt.transpose()
    2842228422                areas = areast.transpose()
    2842328423                percens = percenst.transpose()
     
    2849728497
    2849828498            gridsin = np.zeros((2,Ngridsinmax,1,Nslices), dtype=int)
    28499             areas = np.ones(tuple(varfinalshape), dtype=np.float)*gen.fillValueF
     28499            areas = np.ones((Ngridsinmax,1,Nslices), dtype=np.float)*gen.fillValueF
    2850028500            percens = np.zeros((Ngridsinmax,1,Nslices), dtype=np.float)
    2850128501           
     
    2853828538                    gridsin[1,0:Nt,0,islc] = ainds[0:Nt,0]
    2853928539                    gridsin[0,0:Nt,0,islc] = ainds[0:Nt,1]
     28540                    areas[0:Nt,0,islc] = 1.
    2854028541                    percens[0:Nt,0,islc] = 1.
    28541                     for iv in range(Nt):
    28542                         i = ainds[iv,0]
    28543                         j = ainds[iv,1]
    28544                         areas[j,i] = 1.
    2854528542
    2854628543            # Values for file
     
    2863228629            innewvar.setncattr('coordinates',' '.join(Scgrid[::-1]))
    2863328630
    28634             anewvar = onewnc.createVariable(dn+'gridarea','f',tuple(varfinaldims),   \
     28631            anewvar = onewnc.createVariable(dn+'gridarea','f',tuple(Spgrid),         \
    2863528632              fill_value = gen.fillValueF)
    2863628633            basicvardef(anewvar ,dn+'gridarea', "area of the grids cells from " +    \
    2863728634             dn, vu)
    2863828635            anewvar.setncattr('coordinates',' '.join(varfinaldims[::-1]))
    28639             anewvar[:] = areas[:]
     28636            anewvar[:] = areas[0:Ngridsinmax,...]
    2864028637
    2864128638            aanewvar = onewnc.createVariable(dn+'area','f',tuple(Srgrid),            \
     
    2865428651                j = 0
    2865528652                for i in range(Nslices):
     28653                    slicearea = 0.
    2865628654                    innewvar[:,0:Ngridsin[j,i],i] = gridsin[:,0:Ngridsin[j,i],j,i]
    2865728655                    pnewvar[0:Ngridsin[j,i],i]= percens[0:Ngridsin[j,i],j,i]
    28658                     slicearea = 0.
    28659                     for iv in range(Ngridsin[j,i]):
    28660                         ix = gridsin[1,iv,j,i]
    28661                         iy = gridsin[0,iv,j,i]
    28662                         slicearea = slicearea + areas[iy,ix]*percens[iv,j,i]
     28656                    slicearea = np.sum(areas[:,j,i]*percens[:,j,i])
    2866328657                    aanewvar[i]= slicearea
    2866428658            elif len(dv.shape) == 2:
     
    2868928683                            ag = np.abs(fsci.module_scientific.shoelace_area_polygon(nvertex=4, poly=apolygon))
    2869028684                            slicearea = slicearea + ag*percens[iv,j,i]
    28691                             aa = aa + areas[iy,ix]
     28685                            aa = aa + areas[iv,j,i]
    2869228686                            pp = pp + percens[iv,j,i]
    2869328687                        if np.isnan(slicearea):
     
    2869928693                                ix = gridsin[1,iv,j,i]
    2870028694                                iy = gridsin[0,iv,j,i]
    28701                                 print iv, iy, ix, areas[iy,ix], percens[j,i]
     28695                                print iv, iy, ix, areas[iv,j,i], percens[iv,j,i]
    2870228696                            quit(-1)
    2870328697                        aanewvar[j,i]= slicearea
     
    2883528829                    for iv in range(Nin):
    2883628830                        pA = oslicepA[inpointsA[iv,jB,iB,jA,iA],jA,iA]
     28831                        aA = oslicepA[inpointsA[iv,jB,iB,jA,iA],jA,iA]
    2883728832                        pB = oslicepB[inpointsB[iv,jB,iB,jA,iA],jB,iB]
     28833                        aB = oslicepB[inpointsB[iv,jB,iB,jA,iA],jB,iB]
    2883828834                        pnewvar[iv,jB,iB,jA,iA]= pA*pB
    2883928835                        ixA = sliceinA[1,inpointsA[iv,jB,iB,jA,iA],jA,iA]
    2884028836                        iyA = sliceinA[0,inpointsA[iv,jB,iB,jA,iA],jA,iA]
    28841                         aA = osliceaA[iyA,ixA]
    2884228837                        ixB = sliceinB[1,inpointsB[iv,jB,iB,jA,iA],jB,iB]
    2884328838                        iyB = sliceinB[0,inpointsB[iv,jB,iB,jA,iA],jB,iB]
    28844                         aB = osliceaB[iyB,ixB]
    2884528839                        anewvar[iv,jB,iB,jA,iA]= (aA*pA)*(aB*pB)
    2884628840                        slicearea = slicearea + (aA*pA)*(aB*pB)
     
    2891828912
    2891928913                # Getting respective A & B
    28920                 for jc in range(dyC):
    28921                     for ic in range(dxC):
    28922                         print jc, ic, 'Lluis shapes NpointsABt[jc,ic,:,:]', NpointsABt[jc,ic,:,:].shape, \
    28923                         'pointsABt[jc,ic,:,:]', NpointsABt[jc,ic,:,:].shape, 'sliceNAt', sliceNAt.shape, \
    28924                         'sliceinAt', sliceinAt.shape, 'A dx dy dxy:', dxA, dyA, dxyAB,                   \
    28925                         'B dx dy dxy:', dxA, dyA, dxA
    28926                        
    28927                         NptsAt, inptsAt, inpA, inpB = fsci.module_scientific.coincident_gridsin2d( \
    28928                           npointsa=NpointsABt[jc,ic,:,:], pointsa=pointsABt[jc,ic,:,:], npointsb=sliceNAt,\
    28929                           pointsb=sliceinAt, dxa=dxA, dya=dyA, dxya=dxyAB, dxb=dxA, dyb=dyA, dxyb=dxyA)
    28930                         NpointsA[jc,ic,j,i,:,:] = NptsAt.transpose()
    28931                         inpointsA[:,jc,ic,j,i,:,:] = inptsAt.transpose()
    28932 
    28933                         NptsBt, inptsBt, inpA, inpB = fsci.module_scientific.coincident_gridsin2d( \
    28934                           npointsa=NpointsABt[jc,ic,:,:], pointsa=pointsABt[jc,ic,:,:], npointsb=sliceNBt,\
    28935                           pointsb=sliceinBt, dxa=dxA, dya=dyA, dxya=dxyAB, dxb=dxB, dyb=dyB, dxyb=dxyB)
    28936                         NpointsB[jc,ic,j,i,:,:] = NptsAt.transpose()
    28937                         inpointsB[:,jc,ic,j,i,:,:] = inptsAt.transpose()
     28914                #for jc in range(dyC):
     28915                #    for ic in range(dxC):
     28916                #        print jc, ic, 'Lluis shapes NpointsABt[jc,ic,:,:]', NpointsABt[jc,ic,:,:].shape, \
     28917                #        'pointsABt[jc,ic,:,:]', NpointsABt[jc,ic,:,:].shape, 'sliceNAt', sliceNAt.shape, \
     28918                #        'sliceinAt', sliceinAt.shape, 'A dx dy dxy:', dxA, dyA, dxyAB,                   \
     28919                #        'B dx dy dxy:', dxA, dyA, dxA
     28920                #       
     28921                #        NptsAt, inptsAt, inpA, inpB = fsci.module_scientific.coincident_gridsin2d( \
     28922                #          npointsa=NpointsABt[jc,ic,:,:], pointsa=pointsABt[jc,ic,:,:], npointsb=sliceNAt,\
     28923                #          pointsb=sliceinAt, dxa=dxA, dya=dyA, dxya=dxyAB, dxb=dxA, dyb=dyA, dxyb=dxyA)
     28924                #        NpointsA[jc,ic,j,i,:,:] = NptsAt.transpose()
     28925                #        inpointsA[:,jc,ic,j,i,:,:] = inptsAt.transpose()
     28926                #
     28927                #        NptsBt, inptsBt, inpA, inpB = fsci.module_scientific.coincident_gridsin2d( \
     28928                #          npointsa=NpointsABt[jc,ic,:,:], pointsa=pointsABt[jc,ic,:,:], npointsb=sliceNBt,\
     28929                #          pointsb=sliceinBt, dxa=dxA, dya=dyA, dxya=dxyAB, dxb=dxB, dyb=dyB, dxyb=dxyB)
     28930                #        NpointsB[jc,ic,j,i,:,:] = NptsAt.transpose()
     28931                #        inpointsB[:,jc,ic,j,i,:,:] = inptsAt.transpose()
    2893828932
    2893928933                # Remembering that it is python (C-like...)
    28940                 inpointsAB = inpointsAB-1
    28941                 inpointsC = inpointsC-1
     28934                inpointsAB[:,:,:,j,i,:,:] = inpointsAB[:,:,:,j,i,:,:]-1
     28935                inpointsC[:,:,:,j,i,:,:] = inpointsC[:,:,:,j,i,:,:]-1
    2894228936
    2894328937        maxNpointsABC = np.max(NpointsABC)
     
    2895028944   
    2895128945        newvar = onewnc.createVariable(dn+'Ngrid','i', tuple(Srgrid))
    28952         print 'Lluis shapes: newvar', newvar.shape, 'NpointsABC:', NpointsABC.shape, 'Srgrid:', Srgrid
    2895328946        newvar[:] = NpointsABC[:]
    2895428947        basicvardef(newvar, dn+'Ngrid', "number of grids cells from slice " +        \
     
    2897928972          "grids cells from " + newslcvarns[0] + " laying within " + newslcvarns[1], '1')
    2898028973        pnewvar.setncattr('coordinates',' '.join(Spgrid[::-1]))
    28981 
    28982         print 'Lluis shapes NpointsANC:', NpointsABC.shape, 'pointsABC:', pointsABC.shape, \
    28983           'inpoints AB:', inpointsAB.shape, 'sliceinAB:', sliceinAB.shape, 'oslicepAB:',   \
    28984           oslicepAB.shape, 'osliceaAB:', osliceaAB.shape, 'inpoints C:', inpointsC.shape,  \
    28985           'sliceinC:', sliceinC.shape, 'oslicepC:', oslicepC.shape, 'osliceaC:', osliceaC.shape
    2898628974        ixA = -1
    2898728975        iyA = -1
     
    2899728985                            for iC in range(dxC):
    2899828986                                Nin = NpointsABC[jC,iC,jB,iB,jA,iA]
    28999                                 innewvar[:,0:Nin,jC,iC,jB,iB,jA,iA] = pointsABC[:,0:Nin,jC,iC,jB,iB,jA,iA]
     28987                                innewvar[:,0:Nin,jC,iC,jB,iB,jA,iA] =                \
     28988                                  pointsABC[:,0:Nin,jC,iC,jB,iB,jA,iA]
    2900028989                                aanewvar[jC,iC,jB,iB,jA,iA]= gen.fillValueF
    2900128990                                anewvar[:,jC,iC,jB,iB,jA,iA]= gen.fillValueF
     
    2900328992                                slicearea = 0.
    2900428993                                for iv in range(Nin):
    29005                                     pA = oslicepAB[inpointsAB[iv,jC,iC,jB,iB,jA,iA],jB,iB,jA,iA]
    29006                                     pB = oslicepC[inpointsC[iv,jC,iC,jB,iB,jA,iA],jC,iC]
     28994                                    ivAB = inpointsAB[iv,jC,iC,jB,iB,jA,iA]
     28995                                    ivC = inpointsC[iv,jC,iC,jB,iB,jA,iA]
     28996                                    pA = oslicepAB[ivAB,jB,iB,jA,iA]
     28997                                    pB = oslicepC[ivC,jC,iC]
     28998                                    aA = osliceaAB[ivAB,jB,iB,jA,iA]
     28999                                    aB = osliceaC[ivC,jC,iC]
     29000                                    ixAB = sliceinAB[1,ivAB,jB,iB,jA,iA]
     29001                                    iyAB = sliceinAB[0,ivAB,jB,iB,jA,iA]
     29002                                    ixC = sliceinC[1,ivC,jC,iC]
     29003                                    iyC = sliceinC[0,ivC,jC,iC]
     29004                                    anewvar[iv,jC,iC,jB,iB,jA,iA]= (aA*pA)*(aB*pB)
    2900729005                                    pnewvar[iv,jC,iC,jB,iB,jA,iA]= pA*pB
    29008                                     ixAB = sliceinAB[1,inpointsAB[iv,jC,iC,jB,iB,jA,iA],jB,iB,jA,iA]
    29009                                     iyAB = sliceinAB[0,inpointsAB[iv,jC,iC,jB,iB,jA,iA],jB,iB,jA,iA]
    29010                                     ixA = inpointsA[1,NpointsA[iv,jC,iC,jB,iB,jA,iA],jC,iC,jB,iB,jA,iA]
    29011                                     iyA = inpointsA[0,NpointsA[iv,jC,iC,jB,iB,jA,iA],jC,iC,jB,iB,jA,iA]
    29012                                     ixB = inpointsB[1,NpointsB[iv,jC,iC,jB,iB,jA,iA],jC,iC,jB,iB,jA,iA]
    29013                                     iyB = inpointsB[0,NpointsB[iv,jC,iC,jB,iB,jA,iA],jC,iC,jB,iB,jA,iA]
    29014                                     ixC = sliceinC[1,inpointsC[iv,jC,iC,jB,iB,jA,iA],jC,iC]
    29015                                     iyC = sliceinC[0,inpointsC[iv,jC,iC,jB,iB,jA,iA],jC,iC]
    29016                                     print jA,iA,jB,iB,jC,iC,':',iyA,ixA,iyB,ixB,iyC,ixC
    29017                                     aA = osliceaAB[iyB,ixB,iyA,ixA]
    29018                                     aB = osliceaC[iyC,ixC]
    29019                                     anewvar[iv,jC,iC,jB,iB,jA,iA]= (aA*pA)*(aB*pB)
    2902029006                                    slicearea = slicearea + (aA*pA)*(aB*pB)
     29007                                if np.isnan(slicearea):
     29008                                    print errormsg
     29009                                    print '  ' + fname + ': Nan slice area for slice:',          \
     29010                                      jC, iC, jB, iB, jA, iA, 'N grids:', Nin,' !!'
     29011                                    print '     #grid AB #grid grid_area ' +         \
     29012                                      'grid_percen C # grid grid_area grid_percen____'
     29013                                    for iv in range(Nin):
     29014                                        print iv, inpointsAB[iv,jC,iC,jB,iB,jA,iA],  \
     29015                                          aA, pA, inpointsC[iv,jC,iC,jB,iB,jA,iA],   \
     29016                                          aB, pB
     29017                                    quit(-1)
    2902129018                                aanewvar[jC,iC,jB,iB,jA,iA]= slicearea
    2902229019        onewnc.sync()
     
    2904629043    pnewvar.setncattr('coordinates',' '.join(Spgrid[::-1]))
    2904729044
    29048     (dyA, dxA, dyB, dxB) = sN.shape
    29049     for jA in range(dyA):
    29050         for iA in range(dxA):
    29051             for jB in range(dyB):
    29052                 for iB in range(dxB):
    29053                     Nin = sN[jA,iA,jB,iB]
    29054                     if Nin > 0 and aanewvar[jA,iA,jB,iB] != 0.:
    29055                         sgpa[0:Nin,jA,iA,jB,iB] = anewvar[0:Nin,jA,iA,jB,iB]/        \
    29056                           aanewvar[jA,iA,jB,iB]
    29057                         panewvar[0:Nin,jA,iA,jB,iB] = sgpa[0:Nin,jA,iA,jB,iB]
    29058                         # Let's check
    29059                         psum = np.sum(sgpa[0:Nin,jA,iA,jB,iB])
    29060                         if not np.isnan(psum):
    29061                             if not gen.almost_zero(psum, 1., 4):
    29062                                 print warnmsg
    29063                                 print '    ' + fname + 'at slide:', jA,iA,jB,iB,     \
    29064                                   'percentages do NOT add one down to 0.0001 !!'
    29065                                 print '    Ngrids:', Nin, 'slice area:',             \
    29066                                   aanewvar[jA,iA,jB,iB], 'total sum:', psum
    29067                         else:
    29068                             print errormsg
    29069                             print '  ' + fname + ': grid Nan slice area for final '+ \
    29070                               ' slice:', jA, iA, jB, iB, 'N grids:', Nin,' !!'
    29071                             print '     slice total area:', aanewvar[jA,iA,jB,iB]
    29072                             print '     #grid grid_area slice_area grid_percen ______'
    29073                             for iv in range(Nin):
    29074                                 print iv, anewvar[iv,jA,iA,jB,iB],                   \
    29075                                   aanewvar[jA,iA,jB,iB], sgpa[iv,jA,iA,jB,iB]
    29076                             quit(-1)
     29045    if len(sN.shape)/2 == 2:
     29046        (dyA, dxA, dyB, dxB) = sN.shape
     29047        for jA in range(dyA):
     29048            for iA in range(dxA):
     29049                for jB in range(dyB):
     29050                    for iB in range(dxB):
     29051                        Nin = sN[jA,iA,jB,iB]
     29052                        if Nin > 0 and aanewvar[jA,iA,jB,iB] != 0.:
     29053                            sgpa[0:Nin,jA,iA,jB,iB] = anewvar[0:Nin,jA,iA,jB,iB]/        \
     29054                              aanewvar[jA,iA,jB,iB]
     29055                            panewvar[0:Nin,jA,iA,jB,iB] = sgpa[0:Nin,jA,iA,jB,iB]
     29056                            # Let's check
     29057                            psum = np.sum(sgpa[0:Nin,jA,iA,jB,iB])
     29058                            if not np.isnan(psum):
     29059                                if not gen.almost_zero(psum, 1., 4):
     29060                                    print warnmsg
     29061                                    print '    ' + fname + 'at slide:', jA,iA,jB,iB,     \
     29062                                      'percentages do NOT add one down to 0.0001 !!'
     29063                                    print '    Ngrids:', Nin, 'slice area:',             \
     29064                                      aanewvar[jA,iA,jB,iB], 'total sum:', psum
     29065                            else:
     29066                                print errormsg
     29067                                print '  ' + fname + ': grid Nan slice area for final '+ \
     29068                                  ' slice:', jA, iA, jB, iB, 'N grids:', Nin,' !!'
     29069                                print '     slice total area:', aanewvar[jA,iA,jB,iB]
     29070                                print '     #grid grid_area slice_area grid_percen ______'
     29071                                for iv in range(Nin):
     29072                                    print iv, anewvar[iv,jA,iA,jB,iB],                   \
     29073                                      aanewvar[jA,iA,jB,iB], sgpa[iv,jA,iA,jB,iB]
     29074                                quit(-1)
     29075    elif len(sN.shape)/2 == 3:
     29076        (dyA, dxA, dyB, dxB, dyC, dxC) = sN.shape
     29077        for jA in range(dyA):
     29078            for iA in range(dxA):
     29079                for jB in range(dyB):
     29080                    for iB in range(dxB):
     29081                        for jC in range(dyC):
     29082                            for iC in range(dxC):
     29083                                Nin = sN[jA,iA,jB,iB,jC,iC]
     29084                                if Nin > 0 and aanewvar[jA,iA,jB,iB,jC,iC] != 0.:
     29085                                    sgpa[0:Nin,jA,iA,jB,iB,jC,iC] =                  \
     29086                                      anewvar[0:Nin,jA,iA,jB,iB,jC,iC]/              \
     29087                                      aanewvar[jA,iA,jB,iB,jC,iC]
     29088                                    panewvar[0:Nin,jA,iA,jB,iB,jC,iC] =              \
     29089                                      sgpa[0:Nin,jA,iA,jB,iB,jC,iC]
     29090                                    # Let's check
     29091                                    psum = np.sum(sgpa[0:Nin,jA,iA,jB,iB,jC,iC])
     29092                                    if not np.isnan(psum):
     29093                                        if not gen.almost_zero(psum, 1., 4):
     29094                                            print warnmsg
     29095                                            print '    ' + fname + 'at slide:',      \
     29096                                              jA,iA,jB,iB,jC,iC, 'percentages do ' + \
     29097                                              'NOT add one down to 0.0001 !!'
     29098                                            print '    Ngrids:', Nin, 'slice area:', \
     29099                                              aanewvar[jA,iA,jB,iB,jC,iC],           \
     29100                                              'total sum:', psum
     29101                                    else:
     29102                                        print errormsg
     29103                                        print '  ' + fname + ': grid Nan slice ' +   \
     29104                                          'area for final slice:', jA, iA, jB, iB,   \
     29105                                          jC, iC, 'N grids:', Nin,' !!'
     29106                                        print '     slice total area:',              \
     29107                                          aanewvar[jA,iA,jB,iB,jC,iC]
     29108                                        print '     #grid grid_area slice_area ' +   \
     29109                                          'grid_percen ______'
     29110                                        for iv in range(Nin):
     29111                                            print iv, anewvar[iv,jA,iA,jB,iB,jC,iC], \
     29112                                              aanewvar[jA,iA,jB,iB,jC,iC],           \
     29113                                              sgpa[iv,jA,iA,jB,iB,jC,iC]
     29114                                        quit(-1)
     29115    else:
     29116        print errormsg
     29117        print '  ' + fname + ": rank ", len(sN.shape)/2,' of final slice not ready !!'
     29118        quit(-1)
     29119
    2907729120    onewnc.sync()
    2907829121                     
     
    2910229145
    2910329146    print '  ' + infmsg
    29104     print '    final slice:', Ndims, 'sape:', sN.shape
     29147    print '    final slice:', Ndims, 'shape:', sN.shape
    2910529148
    2910629149    # Checking
    29107     i = 3
     29150    i = 2
    2910829151    j = 5
    2910929152    k = 8
     
    2915729200                    if not gen.searchInlist(onewnc.dimensions,dnn):
    2915829201                        add_dims(onc, onewnc, [dnn])
    29159                         vardims.append(dnn)
    29160                         varshape.append(len(onc.dimensions[dnn]))
    2916129202                    if not gen.searchInlist(onewnc.variables,vdimn): add_vars(onc,   \
    2916229203                      onewnc, [vdimn])
     
    2916629207        newvarshape = varshape + shapeslice
    2916729208
    29168 #        newvarslice = []
    29169 #        for dimn in
     29209        # Generic newvar slice
     29210        newvarslice = []
     29211        for idd in range(len(newvarshape)):
     29212            newvarslice.append(slice(0,newvarshape[idd]))
    2917029213
    2917129214        onewvars = {}
     
    2919329236        # Checking for size...
    2919429237        Nvdims = len(vshape)
     29238        newvarslc = {}
    2919529239        varslc = {}
    2919629240        if Nvdims == 3:
    29197             vSIZE = np.prod(varv.shape[:])*8.
     29241            vSIZE = np.prod(ovar.shape[:])*8.
    2919829242            if vSIZE > gen.oneGB*3.:
    2919929243                print '  ' + infmsg
    2920029244                print '    variable size: ', vSIZE / gen.oneGB,' larger than 3GB !!'
    2920129245                print '    splitting time evolution to compute'
    29202                 vHSIZE = np.prod(varv.shape[1:3])*8.
    29203                 print '    var. horizontal size:', vHSIZE, 'dimt:', varv.shape[0]
     29246                vHSIZE = np.prod(ovar.shape[1:3])*8.
     29247                print '    var. horizontal size:', vHSIZE, 'dimt:', ovar.shape[0]
    2920429248                tsteps = gen.oneGB*3. / vHSIZE
    29205                 tslices = range(0,varv.shape[2],tsteps)
    29206                 print '    time-slices:', tklices
     29249                tslices = range(0,ovar.shape[0],tsteps)
     29250                print '    time-slices:', tslices
    2920729251                for itt in tslcices[1,len(tslices)]:
    2920829252                    iit = tslices[itt-1]
     
    2921029254                    varslc[itt-1] = [slice(iit,eet), slice(0,vshape[1]),             \
    2921129255                      slice(0,vbshape[2])]
     29256                    newvarslc[itt-1] = [slice(iit,eet)] + newvarslice[1:3]
    2921229257            else:
    29213                 tslices = range(0,varv.shape[0])
     29258                tslices = range(0,ovar.shape[0])
    2921429259                varslc[0] = [slice(0,vshape[0]), slice(0,vshape[1]),                 \
    2921529260                  slice(0,vshape[2])]
     29261                newvarslc[0] =  newvarslice
     29262        else:
     29263            slicevv = []
     29264            for iid in range(Nvdims):
     29265                slicevv.append(slice(0,vshape[0]))
     29266            varslc[0] = slicevv
     29267            newvarslc[0] = newvarslice
     29268
     29269        if Nvdims == 3:
     29270            d0 = ovar.shape[0]
     29271            d1 = ovar.shape[1]
     29272            d2 = ovar.shape[2]
     29273        elif Nvdims == 2:
     29274            d0 = ovar.shape[0]
     29275            d1 = ovar.shape[1]
     29276        elif Nvdims == 1:
     29277            d0 = ovar.shape[0]
     29278            if slicespacedim.count(vdimns[0]) != 1:
     29279                print errormsg
     29280                print '  ' + fname + ": there is no way to be able to compute " +    \
     29281                  "sliced statistics for variable '" + varn + "' because it " +      \
     29282                  "does not have any horizontal spatial dimension:", slicespacedim,  \
     29283                  "!!"
     29284                quit(-1)
     29285            ind = slicespacedim.index(vdimns[0])
     29286        else:
     29287            print errormsg
     29288            print '  ' + fame + ": rank ", Nvdims, " of variable '" + varn +         \
     29289              "' not ready !!"
     29290            quit(-1)
     29291
     29292        print '    Lluis computing statistics ...'
    2921629293
    2921729294        for itt in varslc.keys():
     29295           nslcv = newvarslc[itt]
    2921829296           slcv = varslc[itt]
    2921929297           varv = ovar[tuple(slcv)]
    29220            d0 = varv.shape[0]
    29221            d1 = varv.shape[1]
    29222            d2 = varv.shape[2]
     29298
    2922329299           varvt = varv.transpose()
    2922429300           if Nvdims == 3 and len(sN.shape) == 4:
     
    2923229308                 di1=d2, di2=d1, di3=d0, ds1=ssh[2], ds2=ssh[1], ds3=ssh[0],         \
    2923329309                 maxngridsin=sin.shape[1])
     29310           elif Nvdims == 2 and len(sN.shape) == 3:
     29311               voutt=fsci.module_scientific.multi_spaceweightstats_in2drkno_slc3v3(  \
     29312                 varin=varvt, ngridsin=sNt, gridsin=sint, percentages=spt,           \
     29313                 di1=d1, di2=d0, ds1=ssh[2], ds2=ssh[1], ds3=ssh[0],                 \
     29314                 maxngridsin=sin.shape[1])
     29315           elif Nvdims == 1 and len(sN.shape) == 3:
     29316               voutt=fsci.module_scientific.multi_spaceweightstats_in1drkno_slc3v3(  \
     29317                 varin=varvt, idv=ind, ngridsin=sNt, gridsin=sint, percentages=spt,  \
     29318                 di1=d0, ds1=ssh[2], ds2=ssh[1], ds3=ssh[0], maxngridsin=sin.shape[1])
    2923429319           else:
    2923529320               print errormsg
     
    2923729322                 ' slice rank:', len(sN.shape), 'not ready!!'
    2923829323               print '    available ones _______'
     29324               print ' var_rank: 3   slice_rank: 4'
    2923929325               print ' var_rank: 3   slice_rank: 3'
    29240                print ' var_rank: 3   slice_rank: 4'
     29326               print ' var_rank: 2   slice_rank: 3'
     29327               print ' var_rank: 1   slice_rank: 3'
    2924129328               quit(-1)
    2924229329
    2924329330           vout = voutt.transpose()
    2924429331           ist = 0
     29332           print '    Lluis filling file with statistics ...'
    2924529333           for statn in statns:
    2924629334               newvar = onewvars[statn]
    2924729335               rightvals = np.where(vout[6] == 0, gen.fillValueF, vout[ist])
    29248                newvar[tuple(slcv)] = rightvals
     29336               newvar[tuple(nslcv)] = rightvals
    2924929337               onewnc.sync()
    2925029338               ist = ist + 1
Note: See TracChangeset for help on using the changeset viewer.