def calc(self, computeOptions, **args):
source = computeOptions.get_argument("source", None)
startTime = computeOptions.get_argument("s", None)
endTime = computeOptions.get_argument("e", None)
bbox = computeOptions.get_argument("b", None)
timeTolerance = computeOptions.get_float_arg("tt")
depthTolerance = computeOptions.get_float_arg("dt")
radiusTolerance = computeOptions.get_float_arg("rt")
platforms = computeOptions.get_argument("platforms", "")
source1 = self.getDataSourceByName(source)
if source1 is None:
raise Exception("Source '%s' not found"%source)
values, bounds = datafetch.getValues(source1, startTime, endTime, bbox, depthTolerance, platforms, placeholders=True)
count = len(values)
args = {
"source": source,
"startTime": startTime,
"endTime": endTime,
"bbox": bbox,
"timeTolerance": timeTolerance,
"depthTolerance": depthTolerance,
"radiusTolerance": radiusTolerance,
"platforms": platforms
}
return BaseDomsHandler.DomsQueryResults(results=values, args=args, bounds=bounds, details={}, count=count, computeOptions=None)
def calc(self, computeOptions, **args):
satellitesList = self._tile_service.get_dataseries_list(simple=True)
insituList = []
for satellite in satellitesList:
satellite["metadata"] = self.getMetadataForSource(
satellite["shortName"])
for insitu in config.ENDPOINTS:
depths, facets = self.getFacetsForInsituSource(insitu)
insituList.append({
"name":
insitu["name"],
"endpoint":
insitu["url"],
"metadata":
self.getMetadataForSource(insitu["name"]),
"depths":
depths,
"facets":
facets
})
values = {"satellite": satellitesList, "insitu": insituList}
return BaseDomsHandler.DomsQueryResults(results=values)
def calc(self, computeOptions, **args):
dataset = computeOptions.get_argument("dataset", None)
if dataset is None or len(dataset) == 0:
raise Exception("'dataset' parameter not specified")
metadataUrl = self.__getUrlForDataset(dataset)
try:
r = requests.get(metadataUrl)
results = json.loads(r.text)
return BaseDomsHandler.DomsQueryResults(results=results)
except:
raise DatasetNotFoundException("Dataset '%s' not found")
def calc(self, computeOptions, **args):
id = computeOptions.get_argument("id", None)
retrieval = ResultsStorage.ResultsRetrieval()
params, stats, data = retrieval.retrieveResults(id)
return BaseDomsHandler.DomsQueryResults(results=data,
args=params,
details=stats,
bounds=None,
count=None,
computeOptions=None,
executionId=id)
def calc(self, computeOptions, **args):
execution_id = computeOptions.get_argument("id", None)
try:
execution_id = uuid.UUID(execution_id)
except:
raise NexusProcessingException(reason="'id' argument must be a valid uuid", code=400)
simple_results = computeOptions.get_boolean_arg("simpleResults", default=False)
with ResultsStorage.ResultsRetrieval() as storage:
params, stats, data = storage.retrieveResults(execution_id, trim_data=simple_results)
return BaseDomsHandler.DomsQueryResults(results=data, args=params, details=stats, bounds=None, count=None,
computeOptions=None, executionId=execution_id)
def calc(self, computeOptions, **args):
source = computeOptions.get_argument("source", None)
startTime = computeOptions.get_argument("s", None)
endTime = computeOptions.get_argument("e", None)
bbox = computeOptions.get_argument("b", None)
timeTolerance = computeOptions.get_float_arg("tt")
depth_min = computeOptions.get_float_arg("depthMin", default=None)
depth_max = computeOptions.get_float_arg("depthMax", default=None)
radiusTolerance = computeOptions.get_float_arg("rt")
platforms = computeOptions.get_argument("platforms", None)
source1 = self.getDataSourceByName(source)
if source1 is None:
raise Exception("Source '%s' not found" % source)
count, bounds = datafetch.getCount(source1, startTime, endTime, bbox,
depth_min, depth_max, platforms)
args = {
"source": source,
"startTime": startTime,
"endTime": endTime,
"bbox": bbox,
"timeTolerance": timeTolerance,
"depthMin": depth_min,
"depthMax": depth_max,
"radiusTolerance": radiusTolerance,
"platforms": platforms
}
return BaseDomsHandler.DomsQueryResults(results={},
args=args,
details={},
bounds=bounds,
count=count,
computeOptions=None)
def calc(self, computeOptions, **args):
primary = computeOptions.get_argument("primary", None)
matchup = computeOptions.get_argument("matchup", None)
startTime = computeOptions.get_argument("s", None)
endTime = computeOptions.get_argument("e", None)
bbox = computeOptions.get_argument("b", None)
timeTolerance = computeOptions.get_float_arg("tt")
depth_min = computeOptions.get_float_arg("depthMin", default=None)
depth_max = computeOptions.get_float_arg("depthMax", default=None)
radiusTolerance = computeOptions.get_float_arg("rt")
platforms = computeOptions.get_argument("platforms", None)
if primary is None or len(primary) == 0:
raise Exception("No primary dataset specified")
if matchup is None or len(matchup) == 0:
raise Exception("No matchup datasets specified")
start = self._now()
primarySpec = self.getDataSourceByName(primary)
if primarySpec is None:
raise Exception("Specified primary dataset not found using identifier '%s'" % primary)
primaryData, bounds = self.fetchData([primarySpec], startTime, endTime, bbox, depth_min, depth_max, platforms)
primaryContext = MatchupContext(primaryData)
matchupIds = matchup.split(",")
for matchupId in matchupIds:
matchupSpec = self.getDataSourceByName(matchupId)
if matchupSpec is not None: # Then it's in the in-situ configuration
proc = InsituDatasetProcessor(primaryContext, matchupSpec, startTime, endTime, bbox, depth_min, depth_max,
platforms, timeTolerance, radiusTolerance)
proc.start()
else: # We assume it to be a Nexus tiled dataset
'''
Single Threaded at the moment...
'''
daysinrange = self._tile_service.find_days_in_range_asc(bounds.south, bounds.north, bounds.west,
bounds.east, matchupId,
self.__parseDatetime(startTime) / 1000,
self.__parseDatetime(endTime) / 1000)
tilesByDay = {}
for dayTimestamp in daysinrange:
ds1_nexus_tiles = self._tile_service.get_tiles_bounded_by_box_at_time(bounds.south, bounds.north,
bounds.west, bounds.east,
matchupId, dayTimestamp)
# print "***", type(ds1_nexus_tiles)
# print ds1_nexus_tiles[0].__dict__
tilesByDay[dayTimestamp] = ds1_nexus_tiles
primaryContext.processGridded(tilesByDay, matchupId, radiusTolerance, timeTolerance)
matches, numMatches = primaryContext.getFinal(len(matchupIds))
end = self._now()
args = {
"primary": primary,
"matchup": matchupIds,
"startTime": startTime,
"endTime": endTime,
"bbox": bbox,
"timeTolerance": timeTolerance,
"depthMin": depth_min,
"depthMax": depth_max,
"radiusTolerance": radiusTolerance,
"platforms": platforms
}
details = {
"timeToComplete": (end - start),
"numInSituRecords": primaryContext.insituCount,
"numInSituMatched": primaryContext.insituMatches,
"numGriddedChecked": primaryContext.griddedCount,
"numGriddedMatched": primaryContext.griddedMatched
}
with ResultsStorage.ResultsStorage() as resultsStorage:
execution_id = resultsStorage.insertResults(results=matches, params=args, stats=details, startTime=start,
completeTime=end, userEmail="")
return BaseDomsHandler.DomsQueryResults(results=matches, args=args, details=details, bounds=None, count=None,
computeOptions=None, executionId=execution_id)
