def verticalIntegral(grid):
""" Computes a vertical coordinate integral of a 3D grid.
"""
from visad import Real
levels = getLevels(grid)
dlevels = getAbsCDiff(levels)
vavg = GridUtil.make2DGridFromSlice(
GridUtil.sliceAtLevel(grid,
levels[len(levels) - 1])).multiply(Real(0.0))
for level, dlevel in zip(levels, dlevels):
vavg = vavg + GridUtil.make2DGridFromSlice(
GridUtil.sliceAtLevel(grid, float(level)), 0).multiply(
Real(dlevel))
return vavg
def areaWeights(grid):
""" Computes area weights of a grid and returns the grid with
weights at each grid.
"""
from visad import Real
areaW = createAreaField(grid)
areaSum = sum(areaW.getValues()[0])
return areaW.divide(Real(areaSum))
def computeGridAreaAverage(variable):
from ucar.unidata.util.Misc import getAverage
from visad import Real
#print GridUtil.isTimeSequence(variable)
areaW = createAreaField(variable)
sumareaW = sum(areaW.getValues()[0])
areaW = areaW.divide(Real(sumareaW))
test = variable.getSample(0).multiply(areaW)
aavg = sum(test.getValues()[0]) / len(test.getValues()[0])
return aavg
def getSliceAtAltitude(fieldimpl, alt, unit="m"):
""" Extract a 2D horizontal slice from a 3D grid at the given altitude;
level is a real number; if unit is supplied, it must
be compatible with meters (ft, fathoms, etc)
param fieldimpl is a grid which may have
one or more time steps. """
#import methods from
from visad import RealType
from visad import Real
alt = float(alt)
unit = Util.parseUnit(unit)
altitude = Real(RealType.Altitude, alt, unit)
ff = GridUtil.sliceAtLevel(fieldimpl, altitude)
return ff
def ddt(grid, timegradunit):
""" compute tendency (time derivative) using forward difference,
units of returned grid are units of grid per timegradient unit
timegradient unit can be month, day, hour, minute, seconds
"""
from visad import Real
from visad import FunctionType
from visad import FieldImpl
from visad import RealType
from visad import Gridded1DDoubleSet
from ucar.visad.data import CalendarDateTime
from visad import CommonUnit
from visad import VisADException
if (GridUtil.isTimeSequence(grid) == 1):
newTimeValues = []
timediffs = []
ts = GridUtil.getTimeSet(grid)
if (str(timegradunit).lower() in ("mon", "month", "months")):
timefactor = 86400.0 * 30
timegradunit = "month"
elif (str(timegradunit).lower() in ("day", "d", "days")):
timefactor = 86400.0
timegradunit = "day"
elif (str(timegradunit).lower() in ("hr", "hour", "hours")):
timefactor = 3600.0
timegradunit = "hr"
elif (str(timegradunit).lower() in ("m", "min", "minute", "minutes")):
timefactor = 60.0
timegradunit = "min"
elif (str(timegradunit).lower() in ("s", "sec", "second", "seconds")):
timefactor = 1.0
timegradunit = "s"
else:
raise VisADException(
"Requested time gradient unit is ambigious,use month,day,hour etc"
)
for i in range(grid.getDomainSet().getLength() - 1):
newTimeValues.append((ts[i].getValue() + ts[i + 1].getValue()) / 2)
prevtime = float(ts[i].getValue(CommonUnit.secondsSinceTheEpoch))
nexttime = float(ts[i + 1].getValue(
CommonUnit.secondsSinceTheEpoch))
timediffs.append((nexttime - prevtime) / timefactor)
newTimes = Gridded1DDoubleSet(RealType.Time, [newTimeValues],
len(newTimeValues), None,
ts.getSetUnits(), None)
ddtgrid = FieldImpl(
FunctionType(RealType.Time,
grid.getSample(0).getType()), newTimes)
for i in range(grid.getDomainSet().getLength() - 1):
diff = (grid.getSample(i + 1) - grid.getSample(i)).divide(
Real(timediffs[i]))
ddtgrid.setSample(i, diff)
unitname = str(
GridUtil.getParamType(grid).getComponent(0).getDefaultUnit())
print("[" + unitname + "]/" + str(timegradunit))
newunit = Util.parseUnit("(" + unitname + ")/" + str(timegradunit))
newType = Util.makeRealType("ddt of " + getVarName(grid), newunit)
else:
raise VisADException(
"Well, this data is not a time series, hard to do a time derivative!"
)
return GridUtil.setParamType(ddtgrid, newType, 0)
def createTimeMeans(grid, meanType="None"):
""" Create time mean of a grid at periods specified by type.
meanType can be yearly, monthly, daily, hourly, minutes, seconds
"""
from visad import Real
from visad import Gridded1DDoubleSet
from visad import FieldImpl
from visad import FunctionType
from visad import RealType
from visad import VisADException
if (str(meanType).lower() in ("year", "yr", "years", "yearly")):
searchFormat = "yyyy"
elif (str(meanType).lower() in ("mon", "month", "months", "monthly")):
searchFormat = "MM"
elif (str(meanType).lower() in ("day", "d", "days", "daily")):
searchFormat = "dd"
elif (str(meanType).lower() in ("hr", "hour", "hours", "hourly")):
searchFormat = "hh"
elif (str(meanType).lower()
in ("m", "min", "minute", "minutes", "minutely")):
searchFormat = "mm"
elif (str(meanType).lower() in ("s", "sec", "second", "seconds")):
searchFormat = "ss"
else:
raise VisADException(
"Unrecognized time mean type, use yearly or monthly etc")
alltimes = getSampleTimesInFormat(grid, searchFormat)
timeSet = GridUtil.getTimeSet(grid)
timeset = GridUtil.getTimeSet(grid).getSamples()[0]
timevalues = [i for i in timeset]
oldtime = alltimes[0]
temptime = 0
count = 0
newtimelist = []
for currt, tv, i in zip(alltimes, timevalues, range(len(alltimes))):
#values are always accumulated next time
if currt == oldtime:
#takes care of multiple times,first time,last time
temptime = temptime + tv
count = count + 1
if (i == (len(alltimes) - 1)):
newtimeval = temptime / count
newtimelist.append(newtimeval)
else:
#prev values are accumulated join to list
newtimeval = temptime / count
newtimelist.append(newtimeval)
count = 1
temptime = tv
oldtime = currt
if (i == (len(alltimes) - 1)):
newtimelist.append(temptime)
#create new time set
newTimes = Gridded1DDoubleSet(RealType.Time,
[newtimelist], len(newtimelist), None,
timeSet.getSetUnits(), None)
newdatalist = FieldImpl(
FunctionType(RealType.Time,
grid.getSample(0).getType()), newTimes)
timindices = range(len(newtimelist))
oldtime = alltimes[0]
tempdata = grid.getSample(0).multiply(Real(0.0))
count = 0
newind = 0
for currt, i in zip(alltimes, range(len(alltimes))):
#values are always accumulated next time
if currt == oldtime:
#takes care of multiple times,first time,last time
tempdata = tempdata.add(grid.getSample(i))
count = count + 1
if (i == (len(alltimes) - 1)):
newdatalist.setSample(newind, tempdata.divide(Real(count)))
newind = newind + 1
else:
#prev values are accumulated join to list
newdatalist.setSample(newind, tempdata.divide(Real(count)))
newind = newind + 1
count = 1
tempdata = grid.getSample(i)
oldtime = currt
if (i == (len(alltimes) - 1)):
newdatalist.setSample(newind, tempdata.divide(Real(count)))
newParamName = "Time Mean " + str(
Util.cleanTypeName(GridUtil.getParamType(grid)))
return newName(newdatalist, newParamName)
rangetype = a.getType().getRange()
maps = subs.makeMaps(RealType.Latitude, "y", RealType.Longitude, "x",
rangetype[0], "text")
disp = subs.makeDisplay3D(maps)
pcontrol = disp.getProjectionControl()
dzoom = DiscoverableZoom()
pcontrol.addControlListener(dzoom)
tcontrol = maps[2].getControl()
tcontrol.setAutoSize(1)
rends = []
for i in range(ydim / 2, ydim / 2 + 20):
for j in range(xdim / 2, xdim / 2 + 20):
ref = DataReferenceImpl("data")
latlon = cs.toReference(((j, ), (i, )))
tuple = RealTuple(
(a[i * xdim + j][0], Real(RealType.Latitude, latlon[0][0]),
Real(RealType.Longitude, latlon[1][0])))
ref.setData(tuple)
rend = DefaultRendererJ3D()
rends.append(rend)
disp.addReferences(rend, ref, None)
dzoom.setRenderers(rends, .1)
subs.showDisplay(disp)
