public AddAnalog(
RemoteName remoteName,
PointName pointName,
PointCoordinate pointCoordinate)
{
RemoteName = remoteName;
PointName = pointName;
PointCoordinate = pointCoordinate;
}
public UpdateAnalogCoordinate(
RemoteName remoteName,
PointName pointName,
PointCoordinate newPointCoordinate)
{
RemoteName = remoteName;
PointName = pointName;
NewPointCoordinate = newPointCoordinate;
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
try
{
JObject jsonObj = JObject.Load(reader);
ITypedCoordinateContainer typedCoorContainerResult = (ITypedCoordinateContainer)Activator.CreateInstance(objectType);
if (jsonObj.HasValues)
{
JProperty typeProp = jsonObj.Property("type");
JProperty coordinatesProp = jsonObj.Property("coordinates");
if (typeProp != null && coordinatesProp != null)
{
string type = typeProp.Value.ToString();
JArray coorArray = string.IsNullOrWhiteSpace(coordinatesProp.Value.ToString()) ? null : JArray.FromObject(coordinatesProp.Value);
if (coorArray != null)
{
ICoordinateCollection coorResult = null;
ITypedCoordinate typedCoorResult = null;
if (type == "Point")
{
//TJM: Assume simple array of coordinate pairs...
coorResult = GetPointFromJArray(coorArray, _isLegacyFormat);
//TJM: It's ok if the coorResult is null.
typedCoorResult = new PointCoordinate(coorResult);
}
else if (type == "LineString")
{
//TJM: Assume array of "Point".
coorResult = GetLineStringFromJArray(coorArray, _isLegacyFormat);
typedCoorResult = new LineStringCoordinate(coorResult);
}
else if (type == "Polygon")
{
//TJM: Assume array of "LineString".
coorResult = GetPolygonFromJArray(coorArray, _isLegacyFormat);
typedCoorResult = new PolygonCoordinate(coorResult);
}
typedCoorContainerResult.Coordinates = typedCoorResult;
return(typedCoorContainerResult);
}
}
}
}
catch (Exception ex)
{
//TJM: Should we do anything here??
}
return(null);
}
/// <summary>
/// Default function for retrieving Total Flow data
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
public async Task <ITimeSeriesOutput> GetTotalFlowData(TotalFlowInput input)
{
//TODO: Extract the geometry percentage from following code and place in Utility class, for possible use by all controllers.
// Steps:
// 1 - determine geometry
// type case ID: is equal to "huc", "commid", or "catchmentid"
// type case ID action: send request to HMS-GIS /rest/catchment?source=SOURCE%type=TYPE%id=ID for geometry
// type case geojson: is equal to "catchment", or "flowline"
// type case geojson action: send request to HMS-GIS /rest/catchment/geojson/ (geojson in body) OR
// : send request to HMS-GIS /rest/catchment/flowlines/ (flowline geojson in body)
// type case points: is equal to "points"
// type case points action: if request is one point - send request to EPA waters for watershed geometry, if request is two points
// 2 - retrieve catchments-points table
// 3 - collect all points catchment table (this resolves issue of possible duplicate calls on catchment edge)
// 4 - retrieve data for all points in catchment table [Parallel]
// 5 - iterate through catchments and assign data to appropriate catchment
// 6 - aggregate the data for each catchment based upon how much area that cell has in the catchment [Parallel]
// 7 - return aggregated data as a timeseries in the form of { datetime : [ catchment1, catchment2, catchment3, ... ]}
// 8 - set metadata (request inputs, catchment data, aggregation data, output structure)
// 9 - return output
string error = "";
Utilities.ErrorOutput err = new Utilities.ErrorOutput();
GeometryResponse geo = new GeometryResponse();
string requestUrl = this.baseUrl + "/hms/rest/api/v2/hms/gis/percentage/";
if (input.GeometryInputs != null)
{
if (input.GeometryInputs.ContainsKey("huc8") && input.GeometryInputs.ContainsKey("commid"))
{
Dictionary <string, string> taskID;
string queryUrl = requestUrl + "?huc_8_num=" + input.GeometryInputs["huc8"] + "&com_id_num=" + input.GeometryInputs["commid"];
using (var httpClientHandler = new HttpClientHandler())
{
httpClientHandler.ServerCertificateCustomValidationCallback = (message, cert, chain, errors) => { return(true); };
using (var client = new HttpClient(httpClientHandler))
{
taskID = JsonConvert.DeserializeObject <Dictionary <string, string> >(client.GetStringAsync(queryUrl).Result);
}
geo = this.RequestData(taskID["job_id"], out error);
}
}
else
{
return(err.ReturnError("Input error - GeometryInputs provided is invalid."));
}
}
else
{
switch (input.GeometryType.ToLower())
{
case "huc":
// use case 1
// use case 2
string hucID = input.GeometryInput;
using (var client = new HttpClient())
{
string queryUrl = baseUrl + "?huc_8_id=" + hucID;
client.Timeout = TimeSpan.FromMinutes(10);
geo = JsonConvert.DeserializeObject <GeometryResponse>(client.GetStringAsync(queryUrl).Result);
}
//goto default;
break;
case "commid":
// use case 3
//string commid = input.GeometryInput;
//using (var client = new HttpClient())
//{
// string queryUrl = baseUrl + "?com_id=" + commid;
// client.Timeout = TimeSpan.FromMinutes(10);
// geo = JsonConvert.DeserializeObject<GeometryResponse>(client.GetStringAsync(queryUrl).Result);
//}
goto default;
break;
case "catchmentid":
// use case 3
// string catchmentID = input.GeometryInput;
//using (var client = new HttpClient())
//{
// geo = JsonConvert.DeserializeObject<GeometryResponse>(client.GetStringAsync(baseUrl + "/api/GridCell/catchmentid/" + catchmentID).Result);
//}
goto default;
break;
case "catchment":
// use case 4
// Use POST call with geometry
goto default;
break;
case "flowline":
// use case 5
// Use POST call with geometry
goto default;
break;
case "points":
// use case 6
// use case 7
// GET call with points, hms-gis will get geometries
goto default;
break;
case "test":
string testGeometry = "{\"geometry\":{\"9311911\": { \"points\": [ { \"cellArea\": 0.015624999999992895, \"containedArea\": 4.178630503273804e-05, \"longitude\": -71.43749999999996, \"latitude\": 44.18749999999999, \"percentArea\": 0.26743235220964506 }, { \"cellArea\": 0.015624999999996447, \"containedArea\": 0.005083393397351494, \"longitude\": -71.31249999999997, \"latitude\": 44.18750000000001, \"percentArea\": 32.53371774305696 }, { \"cellArea\": 0.015624999999996447, \"containedArea\": 0.0002419268603100419, \"longitude\": -71.31249999999997, \"latitude\": 44.31249999999997, \"percentArea\": 1.5483319059846201 } ] } }, \"metadata\": { \"execution time\": 86.99717831611633, \"nldas source\": \"https://ldas.gsfc.nasa.gov/nldas/gis/NLDAS_Grid_Reference.zip\", \"number of points\": 3, \"request date\": \"Thu, 22 Mar 2018 11:46:44 GMT\", \"shapefile source\": \"ftp://newftp.epa.gov/exposure/BasinsData/NHDPlus21/NHDPlus01060002.zip\" } }";
//string testGeometry = "{\"Geometry\": {\"02080107\": [{\"Latitude\": 37.437499999999972,\"Longitude\": -76.687499999999972,\"CellArea\": 0.0156250000000036,\"ContainedArea\": 0.00559514073505796,\"PercentArea\": 35.8089007043628},{\"Latitude\": 37.437499999999972,\"Longitude\": -76.5625,\"CellArea\": 0.0156250000000053,\"ContainedArea\": 0.0100796700330301,\"PercentArea\": 64.5098882113707},{\"Latitude\": 37.437499999999972,\"Longitude\": -76.437499999999972,\"CellArea\": 0.0156250000000142,\"ContainedArea\": 0.00780989236262298,\"PercentArea\": 49.9833111207416},{\"Latitude\": 37.437499999999972,\"Longitude\": -76.312499999999957,\"CellArea\": 0.0156250000000036,\"ContainedArea\": 0.0012605882348706,\"PercentArea\": 8.06776470316997}]},\"Metadata\": {}}";
geo = JsonConvert.DeserializeObject <GeometryResponse>(testGeometry);
break;
default:
return(err.ReturnError("Input error - GeometryType provided is invalid. Provided value = " + input.GeometryType));
}
}
// Check for any errors
if (!String.IsNullOrWhiteSpace(error) || !geo.status.Equals("SUCCESS"))
{
return(err.ReturnError(error));
}
// Collect all unique points in Catchment
List <GeometryPoint> points = new List <GeometryPoint>();
List <string> pointsSTR = new List <string>();
foreach (KeyValuePair <string, Catchment> k in geo.data.geometry)
{
foreach (Point cp in k.Value.points)
{
GeometryPoint p = new GeometryPoint();
p.Latitude = cp.latitude;
p.Longitude = cp.longitude;
if (!points.Contains(p))
{
points.Add(p);
pointsSTR.Add("[" + p.Latitude.ToString() + ", " + p.Longitude.ToString() + "]");
}
}
}
ITimeSeriesInputFactory inputFactory = new TimeSeriesInputFactory();
List <string> errorMessages = new List <string>();
string errorMsg = "";
// Initialize all surface and subsurface points
Dictionary <string, SurfaceRunoff.SurfaceRunoff> surfaceFlow = new Dictionary <string, SurfaceRunoff.SurfaceRunoff>();
Dictionary <string, SubSurfaceFlow.SubSurfaceFlow> subsurfaceFlow = new Dictionary <string, SubSurfaceFlow.SubSurfaceFlow>();
foreach (GeometryPoint point in points)
{
string key = point.Latitude.ToString() + "," + point.Longitude.ToString();
TimeSeriesGeometry tsGeometry = new TimeSeriesGeometry();
tsGeometry.Point = new PointCoordinate()
{
Latitude = point.Latitude,
Longitude = point.Longitude
};
// Initialize surfaceFlow catchment point object
errorMsg = "";
TimeSeriesInput surfaceTempInput = new TimeSeriesInput();
surfaceTempInput = input;
surfaceTempInput.Geometry = tsGeometry;
SurfaceRunoff.SurfaceRunoff sFlow = new SurfaceRunoff.SurfaceRunoff();
sFlow.Input = inputFactory.SetTimeSeriesInput(surfaceTempInput, new List <string>()
{
"surfacerunoff"
}, out errorMsg);
surfaceFlow.Add(key, sFlow);
errorMessages.Add(errorMsg);
// Initialize subsurfaceFlow catchment point object
errorMsg = "";
TimeSeriesInput subSurfaceTempInput = new TimeSeriesInput();
subSurfaceTempInput = input;
subSurfaceTempInput.Geometry = tsGeometry;
SubSurfaceFlow.SubSurfaceFlow subFlow = new SubSurfaceFlow.SubSurfaceFlow();
subFlow.Input = inputFactory.SetTimeSeriesInput(subSurfaceTempInput, new List <string>()
{
"subsurfaceflow"
}, out errorMsg);
subsurfaceFlow.Add(key, subFlow);
errorMessages.Add(errorMsg);
}
// TODO: merge parallelized calls to surfaceRunoff and subsurfaceFlow
// Parallelized surfaceRunoff
object outputListLock = new object();
List <string> surfaceError = new List <string>();
var options = new ParallelOptions {
MaxDegreeOfParallelism = -1
};
Parallel.ForEach(surfaceFlow, options, (KeyValuePair <string, SurfaceRunoff.SurfaceRunoff> surF) =>
{
string errorM = "";
surF.Value.GetData(out errorM);
lock (outputListLock)
{
surfaceError.Add(errorM);
}
});
// Parallelized subsurfaceFlow
List <string> subsurfaceError = new List <string>();
Parallel.ForEach(subsurfaceFlow, options, (KeyValuePair <string, SubSurfaceFlow.SubSurfaceFlow> subF) =>
{
string errorM = "";
subF.Value.GetData(out errorM);
lock (outputListLock)
{
subsurfaceError.Add(errorM);
}
});
ITimeSeriesOutputFactory outputFactory = new TimeSeriesOutputFactory();
ITimeSeriesOutput output = outputFactory.Initialize();
// Aggregate catchments
List <ITimeSeriesOutput> catchmentFlow = new List <ITimeSeriesOutput>();
ITimeSeriesOutput iOutput = outputFactory.Initialize();
var options2 = new ParallelOptions {
MaxDegreeOfParallelism = 1
};
Dictionary <string, string> catchmentMeta = new Dictionary <string, string>();
Parallel.ForEach(geo.data.geometry, options2, (KeyValuePair <string, Catchment> catchments) => {
string catchmentID = catchments.Key;
List <ITimeSeriesOutput> catchmentPoints = new List <ITimeSeriesOutput>();
foreach (Point cp in catchments.Value.points)
{
IPointCoordinate point = new PointCoordinate()
{
Latitude = cp.latitude,
Longitude = cp.longitude
};
string key = point.Latitude.ToString() + "," + point.Longitude.ToString();
ITimeSeriesOutput output1 = Utilities.Merger.ModifyTimeSeries(surfaceFlow[key].Output, cp.percentArea / 100);
ITimeSeriesOutput output2 = Utilities.Merger.ModifyTimeSeries(subsurfaceFlow[key].Output, cp.percentArea / 100);
if (iOutput.Data.Count == 0)
{
iOutput = output1;
iOutput = Utilities.Merger.MergeTimeSeries(iOutput, output2);
}
else
{
iOutput = Utilities.Merger.MergeTimeSeries(iOutput, output1);
iOutput = Utilities.Merger.MergeTimeSeries(iOutput, output2);
}
catchmentPoints.Add(Utilities.Merger.AddTimeSeries(output1, output2, "TotalFlow"));
}
output.Data = (Utilities.Merger.MergeTimeSeries(catchmentPoints).Data);
int currentCatchment = catchmentMeta.Count + 1;
catchmentMeta.Add("catchment_column_" + currentCatchment.ToString() + "_ID", catchments.Key);
});
// Testing
// output.Data = iOutput.Data;
output.DataSource = input.Source;
output.Dataset = "Total Flow";
output.Metadata = surfaceFlow.First().Value.Output.Metadata;
output.Metadata.Remove(input.Source + "_lat");
output.Metadata.Remove(input.Source + "_lon");
output.Metadata.Remove(input.Source + "_prod_name");
output.Metadata.Remove(input.Source + "_param_short_name");
output.Metadata.Remove(input.Source + "_param_name");
output.Metadata[input.Source + "_points"] = string.Join(", ", pointsSTR);
// Adding geometry metadata to output metadata
foreach (KeyValuePair <string, string> kv in geo.data.metadata)
{
if (!output.Metadata.ContainsKey(kv.Key))
{
output.Metadata.Add(kv.Key, kv.Value);
}
}
// Cleaning up output metadata
Dictionary <string, string> cleanedMetaData = new Dictionary <string, string>();
foreach (KeyValuePair <string, string> kv in output.Metadata)
{
if (!kv.Key.Contains("column"))
{
cleanedMetaData.Add(kv.Key, kv.Value);
}
}
output.Metadata = cleanedMetaData;
// Add catchments metadata to output metadata
foreach (KeyValuePair <string, string> kv in catchmentMeta)
{
output.Metadata.Add(kv.Key, kv.Value);
}
return(output);
}
/// <summary>
/// Gets workflow data.
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
public async Task <ITimeSeriesOutput> GetWorkFlowData(WorkFlowCompareInput input)
{
string errorMsg = "";
// Constructs default error output object containing error message.
Utilities.ErrorOutput err = new Utilities.ErrorOutput();
input.SourceList = new List <string>()
{
{ "ncdc" },
{ "nldas" },
{ "gldas" },
{ "daymet" }
};
ITimeSeriesOutputFactory oFactory = new TimeSeriesOutputFactory();
ITimeSeriesOutput output = oFactory.Initialize();
output.DataSource = string.Join(" - ", input.SourceList.ToArray());
if (input.Dataset.Contains("precipitation"))
{
input.SourceList = new List <string>()
{
{ "nldas" },
{ "gldas" },
{ "daymet" }
};
input.Source = "ncdc";
// Validate precipitation sources.
errorMsg = (!Enum.TryParse(input.Source, true, out PrecipSources pSource)) ? "ERROR: 'Source' was not found or is invalid." : "";
if (errorMsg.Contains("ERROR"))
{
return(err.ReturnError(errorMsg));
}
List <Precipitation.Precipitation> precipList = new List <Precipitation.Precipitation>();
List <ITimeSeriesOutput> outputList = new List <ITimeSeriesOutput>();
// NCDC Call
Precipitation.Precipitation ncdc = new Precipitation.Precipitation();
// ITimeSeriesInputFactory object used to validate and initialize all variables of the input object.
ITimeSeriesInputFactory nFactory = new TimeSeriesInputFactory();
ITimeSeriesInput nInput = nFactory.SetTimeSeriesInput(input, new List <string>()
{
"precipitation"
}, out errorMsg);
if (errorMsg.Contains("ERROR"))
{
return(err.ReturnError(errorMsg));
}
// Set input to precip object.
ncdc.Input = nInput;
ncdc.Input.TemporalResolution = "daily";
ncdc.Input.Geometry.GeometryMetadata["token"] = (ncdc.Input.Geometry.GeometryMetadata.ContainsKey("token")) ? ncdc.Input.Geometry.GeometryMetadata["token"] : "RUYNSTvfSvtosAoakBSpgxcHASBxazzP";
ITimeSeriesOutput nResult = ncdc.GetData(out errorMsg);
if (errorMsg.Contains("ERROR"))
{
return(err.ReturnError(errorMsg));
}
output = nResult;
// Construct Precipitation objects for Parallel execution in the preceeding Parallel.ForEach statement.
foreach (string source in input.SourceList)
{
// Precipitation object
Precipitation.Precipitation precip = new Precipitation.Precipitation();
PointCoordinate point = new PointCoordinate();
if (output.Metadata.ContainsKey("ncdc_latitude") && output.Metadata.ContainsKey("ncdc_longitude"))
{
point.Latitude = Convert.ToDouble(output.Metadata["ncdc_latitude"]);
point.Longitude = Convert.ToDouble(output.Metadata["ncdc_longitude"]);
input.Geometry.Point = point;
}
else
{
errorMsg = "ERROR: Coordinate information was not found or is invalid for the specified NCDC station.";
}
// ITimeSeriesInputFactory object used to validate and initialize all variables of the input object.
ITimeSeriesInputFactory iFactory = new TimeSeriesInputFactory();
input.Source = source;
ITimeSeriesInput sInput = iFactory.SetTimeSeriesInput(input, new List <string>()
{
"PRECIP"
}, out errorMsg);
if (errorMsg.Contains("ERROR"))
{
return(err.ReturnError(errorMsg));
}
// Set input to precip object.
precip.Input = sInput;
precip.Input.TemporalResolution = "daily";
precip.Input.DateTimeSpan.EndDate = precip.Input.DateTimeSpan.EndDate.AddDays(1);
if (!precip.Input.Geometry.GeometryMetadata.ContainsKey("leapYear"))
{
precip.Input.Geometry.GeometryMetadata.Add("leapYear", "correction");
}
precipList.Add(precip);
}
List <string> errorList = new List <string>();
object outputListLock = new object();
var options = new ParallelOptions {
MaxDegreeOfParallelism = -1
};
Parallel.ForEach(precipList, options, (Precipitation.Precipitation precip) =>
{
// Gets the Precipitation data.
string errorM = "";
ITimeSeriesOutput result = precip.GetData(out errorM);
lock (outputListLock)
{
errorList.Add(errorM);
outputList.Add(result);
}
});
if (errorList.FindIndex(errorStr => errorStr.Contains("ERROR")) != -1)
{
return(err.ReturnError(string.Join(",", errorList.ToArray())));
}
foreach (ITimeSeriesOutput result in outputList)
{
output = Utilities.Merger.MergeTimeSeries(output, result);
}
output.Metadata.Add("column_1", "date");
output.Metadata.Add("column_2", "ncdc");
output = Utilities.Statistics.GetStatistics(out errorMsg, output);
return(output);
}
else if (input.Dataset.Contains("SurfaceRunoff"))
{
//TODO: Do runoff source iteration.
return(err.ReturnError("ERROR. Workflow has not yet been implemented."));
}
else
{
return(err.ReturnError("ERROR: WorkFlow source not found or is invalid."));
}
}
static extern IntPtr MonitorFromPoint(PointCoordinate pt, MonitorOptions dwFlags);
static extern bool GetCursorPos(out PointCoordinate lpPoint);
