def test_time():
rqst = {"time": "NOW", "input": "NOW", "output": "GPS"}
d = sliderule.source("time", rqst)
now = d["time"] - (d["time"] % 1000
) # gmt is in resolution of seconds, not milliseconds
rqst["time"] = d["time"]
rqst["input"] = "GPS"
rqst["output"] = "GMT"
d = sliderule.source("time", rqst)
rqst["time"] = d["time"]
rqst["input"] = "GMT"
rqst["output"] = "GPS"
d = sliderule.source("time", rqst)
again = d["time"]
if now == again:
logging.info("Passed time test")
else:
logging.error("Failed time test")
def h5p(datasets, resource, asset="atlas-s3"):
# Baseline Request
rqst = {
"asset": asset,
"resource": resource,
"datasets": datasets,
}
# Read H5 File
try:
rsps = sliderule.source("h5p", rqst, stream=True)
except RuntimeError as e:
logger.critical(e)
rsps = []
# Build Record Data
results = {}
for result in rsps:
results[result["dataset"]] = __get_values(result["data"],
result["datatype"],
result["size"])
# Return Results
return results
def test_definition(self):
icesat2.init(SERVER)
rqst = {
"rectype": "atl06rec.elevation",
}
d = sliderule.source("definition", rqst)
assert d["delta_time"]["offset"] == 192
def test_version():
rsps = sliderule.source("version", {})
success = True
success = success and ('server' in rsps)
success = success and ('version' in rsps['server'])
success = success and ('commit' in rsps['server'])
success = success and ('launch' in rsps['server'])
success = success and ('duration' in rsps['server'])
success = success and ('packages' in rsps['server'])
success = success and ('.' in rsps['server']['version'])
success = success and ('-g' in rsps['server']['commit'])
success = success and (':' in rsps['server']['launch'])
success = success and (rsps['server']['duration'] > 0)
success = success and ('icesat2' in rsps['server']['packages'])
success = success and ('version' in rsps['icesat2'])
success = success and ('commit' in rsps['icesat2'])
success = success and ('.' in rsps['icesat2']['version'])
success = success and ('-g' in rsps['icesat2']['commit'])
if success:
logging.info("Passed version test")
else:
logging.error("Failed version test: {}".format(str(rsps)))
def test_time(self):
icesat2.init(SERVER)
rqst = {"time": "NOW", "input": "NOW", "output": "GPS"}
d = sliderule.source("time", rqst)
now = d["time"] - (
d["time"] % 1000
) # gmt is in resolution of seconds, not milliseconds
rqst["time"] = d["time"]
rqst["input"] = "GPS"
rqst["output"] = "GMT"
d = sliderule.source("time", rqst)
rqst["time"] = d["time"]
rqst["input"] = "GMT"
rqst["output"] = "GPS"
d = sliderule.source("time", rqst)
again = d["time"]
assert now == again
def test_geospatial4(self):
icesat2.init(SERVER)
test = {
"asset": ASSET,
"pole": "north",
"lat": 30.0,
"lon": 100.0,
"x": 0.20051164424058,
"y": -1.1371580426033,
}
d = sliderule.source("geo", test)
assert abs(d["lat"] - 30.0) < 0.0001 and d["lon"] == -80.0
def test_definition():
rqst = {
"rectype": "atl06rec.elevation",
}
d = sliderule.source("definition", rqst)
if (d["delta_time"]["offset"] == 128):
logging.info("Passed definition test")
else:
logging.error("Failed definition test: {}".format(
d["delta_time"]["offset"]))
def __atl06(parm, resource, asset, track):
# Build ATL06 Request
rqst = {
"atl03-asset": asset,
"resource": resource,
"track": track,
"parms": parm
}
# Execute ATL06 Algorithm
rsps = sliderule.source("atl06", rqst, stream=True)
# Flatten Responses
columns = {}
if len(rsps) <= 0:
logger.debug("no response returned for %s", resource)
elif (rsps[0]['__rectype'] != 'atl06rec'
and rsps[0]['__rectype'] != 'atl06rec-compact'):
logger.debug("invalid response returned for %s: %s", resource,
rsps[0]['__rectype'])
else:
# Determine Record Type
if rsps[0]['__rectype'] == 'atl06rec':
rectype = 'atl06rec.elevation'
else:
rectype = 'atl06rec-compact.elevation'
# Count Rows
num_rows = 0
for rsp in rsps:
num_rows += len(rsp["elevation"])
# Build Columns
for field in rsps[0]["elevation"][0].keys():
fielddef = sliderule.get_definition(rectype, field)
if len(fielddef) > 0:
columns[field] = numpy.empty(num_rows, fielddef["nptype"])
# Populate Columns
elev_cnt = 0
for rsp in rsps:
for elevation in rsp["elevation"]:
for field in elevation.keys():
if field in columns:
columns[field][elev_cnt] = elevation[field]
elev_cnt += 1
# Return Response
return __todataframe(columns, "delta_time", "lon", "lat"), resource
def test_version(self):
icesat2.init(SERVER)
rsps = sliderule.source("version", {})
assert 'server' in rsps
assert 'version' in rsps['server']
assert 'commit' in rsps['server']
assert 'launch' in rsps['server']
assert 'duration' in rsps['server']
assert 'packages' in rsps['server']
assert '.' in rsps['server']['version']
assert '-g' in rsps['server']['commit']
assert ':' in rsps['server']['launch']
assert rsps['server']['duration'] > 0
assert 'icesat2' in rsps['server']['packages']
assert 'version' in rsps['icesat2']
assert 'commit' in rsps['icesat2']
assert '.' in rsps['icesat2']['version']
assert '-g' in rsps['icesat2']['commit']
def h5(dataset,
resource,
asset="atlas-s3",
datatype=sliderule.datatypes["DYNAMIC"],
col=0,
startrow=0,
numrows=ALL_ROWS):
# Baseline Request
rqst = {
"asset": asset,
"resource": resource,
"dataset": dataset,
"datatype": datatype,
"col": col,
"startrow": startrow,
"numrows": numrows,
"id": 0
}
# Read H5 File
try:
rsps = sliderule.source("h5", rqst, stream=True)
except RuntimeError as e:
logger.critical(e)
return numpy.empty(0)
# Check if Data Returned
if len(rsps) <= 0:
return numpy.empty(0)
# Build Record Data
rsps_datatype = rsps[0]["datatype"]
rsps_data = bytearray()
rsps_size = 0
for d in rsps:
rsps_data += bytearray(d["data"])
rsps_size += d["size"]
# Get Values
values = __get_values(rsps_data, rsps_datatype, rsps_size)
# Return Response
return values
def test_geospatial1(self):
icesat2.init(SERVER)
test = {
"asset": ASSET,
"pole": "north",
"lat": 40.0,
"lon": 60.0,
"x": 0.466307658155,
"y": 0.80766855588292,
"span": {
"lat0": 20.0,
"lon0": 100.0,
"lat1": 15.0,
"lon1": 105.0
},
"span1": {
"lat0": 30.0,
"lon0": 100.0,
"lat1": 35.0,
"lon1": 105.0
},
"span2": {
"lat0": 32.0,
"lon0": 101.0,
"lat1": 45.0,
"lon1": 106.0
}
}
d = sliderule.source("geo", test)
assert d["intersect"] == True
assert abs(d["combine"]["lat0"] - 44.4015) < 0.001
assert abs(d["combine"]["lon0"] - 108.6949) < 0.001
assert d["combine"]["lat1"] == 30.0
assert d["combine"]["lon1"] == 100.0
assert abs(d["split"]["lspan"]["lat0"] - 18.6736) < 0.001
assert abs(d["split"]["lspan"]["lon0"] - 106.0666) < 0.001
assert abs(d["split"]["lspan"]["lat1"] - 15.6558) < 0.001
assert abs(d["split"]["lspan"]["lon1"] - 102.1886) < 0.001
assert abs(d["split"]["rspan"]["lat0"] - 19.4099) < 0.001
assert abs(d["split"]["rspan"]["lon0"] - 103.0705) < 0.001
assert abs(d["split"]["rspan"]["lat1"] - 16.1804) < 0.001
assert abs(d["split"]["rspan"]["lon1"] - 99.3163) < 0.001
assert d["lat"] == 40.0 and d["lon"] == 60.0
assert d["x"] == 0.466307658155 and d["y"] == 0.80766855588292
import json
import logging
import sliderule
from sliderule import icesat2
from sliderule import datatypes
###############################################################################
# MAIN
###############################################################################
if __name__ == '__main__':
url = ["127.0.0.1"]
# Override server URL from command line
if len(sys.argv) > 1:
url = sys.argv[1]
# Bypass service discovery
if len(sys.argv) > 2:
if sys.argv[2] == "bypass":
url = [url]
# Initialize ICESat2/SlideRule Package
icesat2.init(url, False)
# Query Version
rsps = sliderule.source("version", {})
# Display Version Information
print(json.dumps(rsps, indent=4))
def get_version():
rsps = sliderule.source("version", {})
rsps["client"] = {"version": version.full_version}
return rsps
def __atl03s(parm, resource, asset, track):
# Build ATL06 Request
rqst = {
"atl03-asset": asset,
"resource": resource,
"track": track,
"parms": parm
}
# Execute ATL06 Algorithm
rsps = sliderule.source("atl03s", rqst, stream=True)
# Flatten Responses
columns = {}
if len(rsps) <= 0:
logger.debug("no response returned for %s", resource)
elif rsps[0]['__rectype'] != 'atl03rec':
logger.debug("invalid response returned for %s: %s", resource,
rsps[0]['__rectype'])
else:
# Count Rows
num_rows = 0
for rsp in rsps:
num_rows += len(rsp["data"])
# Build Columns
for rsp in rsps:
if len(rsp["data"]) > 0:
# Allocate Columns
for field in rsp.keys():
fielddef = sliderule.get_definition("atl03rec", field)
if len(fielddef) > 0:
columns[field] = numpy.empty(num_rows,
fielddef["nptype"])
for field in rsp["data"][0].keys():
fielddef = sliderule.get_definition(
"atl03rec.photons", field)
if len(fielddef) > 0:
columns[field] = numpy.empty(num_rows,
fielddef["nptype"])
break
# Populate Columns
ph_cnt = 0
for rsp in rsps:
ph_index = 0
left_cnt = rsp["count"][0]
for photon in rsp["data"]:
for field in rsp.keys():
if field in columns:
if field == "count":
if ph_index < left_cnt:
columns[field][ph_cnt] = 0
else:
columns[field][ph_cnt] = 1
elif type(rsp[field]) is tuple:
columns[field][ph_cnt] = rsp[field][0]
else:
columns[field][ph_cnt] = rsp[field]
for field in photon.keys():
if field in columns:
columns[field][ph_cnt] = photon[field]
ph_cnt += 1
ph_index += 1
# Rename Count Column to Pair Column
columns["pair"] = columns.pop("count")
# Return Response
return __todataframe(columns, "delta_time", "longitude",
"latitude"), resource
# Default Parameters
parms = {"ipaddr": "127.0.0.1", "fmt": "console", "depth": 1, "ids": []}
# Override Parameters
parms = parse_command_line(sys.argv, parms)
# Default Request
rqst = {"type": LOG | TRACE, "level": "INFO", "duration": 30}
# Override Request
rqst = parse_command_line(sys.argv, rqst)
# Set URL (bypass service discovery)
sliderule.set_url([parms["ipaddr"]])
# Connect to SlideRule
rsps = sliderule.source("event",
rqst,
stream=True,
callbacks={'eventrec': process_event})
# Flatten names to get indexes
names = list(names)
# Run commanded operation
if parms["fmt"] == "console":
console_output(origins)
elif parms["fmt"] == "sta":
sta_output(parms["ids"], parms["depth"], names, traces)
def test_geospatial(asset):
# Test 1 #
test1 = {
"asset": asset,
"pole": "north",
"lat": 40.0,
"lon": 60.0,
"x": 0.466307658155,
"y": 0.80766855588292,
"span": {
"lat0": 20.0,
"lon0": 100.0,
"lat1": 15.0,
"lon1": 105.0
},
"span1": {
"lat0": 30.0,
"lon0": 100.0,
"lat1": 35.0,
"lon1": 105.0
},
"span2": {
"lat0": 32.0,
"lon0": 101.0,
"lat1": 45.0,
"lon1": 106.0
},
}
d = sliderule.source("geo", test1)
if (d["intersect"] == True):
logging.info("Passed intersection test")
else:
logging.error("Failed intersection test", d["intersect"])
if(abs(d["combine"]["lat0"] - 44.4015) < 0.001 and abs(d["combine"]["lon0"] - 108.6949) < 0.001 and\
d["combine"]["lat1"] == 30.0 and d["combine"]["lon1"] == 100.0):
logging.info("Passed combination test")
else:
logging.error("Failed combination test", d["combine"])
if(abs(d["split"]["lspan"]["lat0"] - 18.6736) < 0.001 and abs(d["split"]["lspan"]["lon0"] - 106.0666) < .001 and\
abs(d["split"]["lspan"]["lat1"] - 15.6558) < 0.001 and abs(d["split"]["lspan"]["lon1"] - 102.1886) < .001 and\
abs(d["split"]["rspan"]["lat0"] - 19.4099) < 0.001 and abs(d["split"]["rspan"]["lon0"] - 103.0705) < .001 and\
abs(d["split"]["rspan"]["lat1"] - 16.1804) < 0.001 and abs(d["split"]["rspan"]["lon1"] - 99.3163) < .001):
logging.info("Passed split test")
else:
logging.error("Failed split test", d["split"])
if (d["lat"] == 40.0 and d["lon"] == 60.0):
logging.info("Passed sphere test")
else:
logging.error("Failed sphere test", d["lat"], d["lon"])
if (d["x"] == 0.466307658155 and d["y"] == 0.80766855588292):
logging.info("Passed projection test")
else:
logging.error("Failed projection test", d["x"], d["y"])
# Test 2 #
test2 = {
"asset": atl03_asset,
"pole": "north",
"lat": 30.0,
"lon": 100.0,
"x": -0.20051164424058,
"y": 1.1371580426033,
}
d = sliderule.source("geo", test2)
if (abs(d["lat"] - 30.0) < 0.0001 and d["lon"] == 100.0):
logging.info("Passed sphere2 test")
else:
logging.error("Failed sphere2 test", d["lat"], d["lon"])
# Test 3 #
test3 = {
"asset": atl03_asset,
"pole": "north",
"lat": 30.0,
"lon": 100.0,
"x": -0.20051164424058,
"y": -1.1371580426033,
}
d = sliderule.source("geo", test3)
if (abs(d["lat"] - 30.0) < 0.0001 and d["lon"] == -100.0):
logging.info("Passed sphere3 test")
else:
logging.error("Failed sphere3 test", d["lat"], d["lon"])
# Test 4 #
test4 = {
"asset": atl03_asset,
"pole": "north",
"lat": 30.0,
"lon": 100.0,
"x": 0.20051164424058,
"y": -1.1371580426033,
}
d = sliderule.source("geo", test4)
if (abs(d["lat"] - 30.0) < 0.0001 and d["lon"] == -80.0):
logging.info("Passed sphere4 test")
else:
logging.error("Failed sphere4 test", d["lat"], d["lon"])