public void Translate_ITimeSeriesInput()
{
if (ITSI != null)
{
UseConstant = false;
MultLdg = 1;
NoUserLoad = false;
Hourly = true; // don't assume truncated to day -- interpolate between date stamps
if (ITSI.InputTimeSeries == null)
{
throw new ArgumentException("An ITimeSeries as an AQUATOX Loading must have an associated InputTimeSeries");
}
ITimeSeriesOutput TSO = ITSI.InputTimeSeries.FirstOrDefault().Value;
list.Clear();
list.Capacity = TSO.Data.Count;
foreach (KeyValuePair <string, List <string> > entry in TSO.Data)
{
if (!(DateTime.TryParse(entry.Key, out DateTime date)))
{
throw new ArgumentException("Cannot convert '" + entry.Key + "' to TDateTime");
}
if (!(Double.TryParse(entry.Value[0], out double val)))
{
throw new ArgumentException("Cannot convert '" + entry.Value + "' to Double");
}
list.Add(date, val);
}
}
ITSI_Translated = true;
}
/// <summary>
/// Checks for temporal resolution and runs appropriate aggregation function.
/// </summary>
/// <param name="errorMsg"></param>
/// <param name="output"></param>
/// <param name="input"></param>
/// <returns></returns>
private ITimeSeriesOutput TemporalAggregation(out string errorMsg, ITimeSeriesOutput output, ITimeSeriesInput input)
{
errorMsg = "";
output.Metadata.Add("gldas_temporalresolution", input.TemporalResolution);
output.Metadata.Add("column_1", "Date");
output.Data = ConvertToHourly(out errorMsg, output, input);
if (input.Units.Contains("imperial"))
{
output.Metadata["gldas_unit"] = "in";
}
// NLDAS static methods used for aggregation as GLDAS is identical in function. Modifier refers to the 3hr different to nldas's hourly resolution.
switch (input.TemporalResolution)
{
case "daily":
output.Data = NLDAS.DailyAggregatedSum(out errorMsg, 7, 3.0, output, input);
output.Metadata.Add("column_2", "Daily Total");
return(output);
case "weekly":
output.Data = NLDAS.WeeklyAggregatedSum(out errorMsg, 3.0, output, input);
output.Metadata.Add("column_2", "Weekly Total");
return(output);
case "monthly":
output.Data = NLDAS.MonthlyAggregatedSum(out errorMsg, 3.0, output, input);
output.Metadata.Add("column_2", "Monthly Total");
return(output);
default:
output.Data = (input.Units.Contains("imperial")) ? NLDAS.UnitConversion(out errorMsg, 3.0, output, input) : output.Data;
output.Metadata.Add("column_2", "Hourly Average");
return(output);
}
}
/// <summary>
/// Makes the GetData call to the base PRISM class.
/// </summary>
/// <param name="errorMsg"></param>
/// <param name="output"></param>
/// <param name="input"></param>
/// <returns></returns>
public ITimeSeriesOutput GetData(out string errorMsg, ITimeSeriesOutput output, ITimeSeriesInput input)
{
errorMsg = "";
Data.Source.PRISM prism = new Data.Source.PRISM();
string data = prism.GetData(out errorMsg, "'tmax', 'tmin'", input);
if (errorMsg.Contains("ERROR"))
{
return(null);
}
ITimeSeriesOutput prismOutput = output;
prismOutput = prism.SetDataToOutput(out errorMsg, "Temperature", data, output, input);
if (errorMsg.Contains("ERROR"))
{
return(null);
}
prismOutput = TemporalAggregation(out errorMsg, output, input);
if (errorMsg.Contains("ERROR"))
{
return(null);
}
return(prismOutput);
}
public ITimeSeriesOutput GetData(out string errorMsg, ITimeSeriesOutput output, ITimeSeriesInput input)
{
errorMsg = "";
Data.Source.PRISM prism = new Data.Source.PRISM();
string data = prism.GetData(out errorMsg, "ppt", input);
ITimeSeriesOutput prismOutput = output;
if (errorMsg.Contains("ERROR"))
{
Utilities.ErrorOutput err = new Utilities.ErrorOutput();
output = err.ReturnError("Precipitation", "PRISM", errorMsg);
errorMsg = "";
return(output);
}
else
{
prismOutput = prism.SetDataToOutput(out errorMsg, "Precipitation", data, output, input);
}
prismOutput = TemporalAggregation(out errorMsg, output, input);
if (errorMsg.Contains("ERROR"))
{
return(null);
}
return(prismOutput);
}
/// <summary>
/// Makes the GetData call to the base GLDAS class.
/// </summary>
/// <param name="errorMsg"></param>
/// <param name="output"></param>
/// <param name="input"></param>
/// <returns></returns>S
public ITimeSeriesOutput GetData(out string errorMsg, ITimeSeriesOutput output, ITimeSeriesInput input)
{
errorMsg = "";
Data.Source.GLDAS gldas = new Data.Source.GLDAS();
string data = gldas.GetData(out errorMsg, "Baseflow", input);
if (errorMsg.Contains("ERROR"))
{
return(null);
}
ITimeSeriesOutput gldasOutput = output;
gldasOutput = gldas.SetDataToOutput(out errorMsg, "Baseflow", data, output, input);
if (errorMsg.Contains("ERROR"))
{
return(null);
}
gldasOutput = TemporalAggregation(out errorMsg, output, input);
if (errorMsg.Contains("ERROR"))
{
return(null);
}
return(gldasOutput);
}
/// <summary>
/// Makes the GetData call to the base Daymet class.
/// </summary>
/// <param name="errorMsg"></param>
/// <param name="input"></param>
/// <param name="output"></param>
/// <returns></returns>
public ITimeSeriesOutput GetData(out string errorMsg, ITimeSeriesOutput output, ITimeSeriesInput input)
{
errorMsg = "";
Data.Source.Daymet daymet = new Data.Source.Daymet();
string data = daymet.GetData(out errorMsg, "Precip", input);
if (errorMsg.Contains("ERROR"))
{
return(null);
}
ITimeSeriesOutput daymetOutput = output;
daymetOutput = SetDataToOutput(out errorMsg, "Precipitation", data, output, input);
daymetOutput.Metadata["daymet_unit"] = (input.Units.Contains("imperial")) ? "in" : "mm";
daymetOutput.Dataset = "Precipitation";
daymetOutput.DataSource = "daymet";
// Temporal aggregation
daymetOutput = TemporalAggregation(out errorMsg, output, input);
if (errorMsg.Contains("ERROR"))
{
return(null);
}
return(daymetOutput);
}
/// <summary>
/// Makes the GetData call to the base Daymet class.
/// </summary>
/// <param name="errorMsg"></param>
/// <param name="input"></param>
/// <param name="output"></param>
/// <returns></returns>
public ITimeSeriesOutput GetData(out string errorMsg, ITimeSeriesOutput output, ITimeSeriesInput input)
{
errorMsg = "";
Data.Source.Daymet daymet = new Data.Source.Daymet();
string data = daymet.GetData(out errorMsg, "Temp", input);
if (errorMsg.Contains("ERROR"))
{
return(null);
}
ITimeSeriesOutput daymetOutput = output;
daymetOutput = SetDataToOutput(out errorMsg, "Temperature", data, output, input);
// Temporal aggregation
daymetOutput = TemporalAggregation(out errorMsg, output, input);
if (errorMsg.Contains("ERROR"))
{
return(null);
}
return(daymetOutput);
}
/// <summary>
/// Checks temporal resolution and runs appropriate aggregation function.
/// </summary>
/// <param name="errorMsg"></param>
/// <param name="output"></param>
/// <param name="input"></param>
/// <returns></returns>
private ITimeSeriesOutput TemporalAggregation(out string errorMsg, ITimeSeriesOutput output, ITimeSeriesInput input)
{
errorMsg = "";
output.Metadata.Add("daymet_temporalresolution", input.TemporalResolution);
output.Metadata["daymet_unit"] = (input.Units.Contains("imperial")) ? "F" : "K";
output.Data = (input.Units.Contains("imperial")) ? UnitConversion(out errorMsg, false, output, input) : UnitConversion(out errorMsg, true, output, input);
output.Metadata.Add("column_1", "date");
output.Metadata.Add("column_2", "Max Temp");
output.Metadata.Add("column_3", "Min Temp");
switch (input.TemporalResolution)
{
case "weekly":
output.Data = WeeklyAverage(out errorMsg, output, input);
return(output);
case "monthly":
output.Data = MonthlyAverage(out errorMsg, output, input);
return(output);
case "daily":
default:
return(output);
}
}
/// <summary>
/// Checks temporal resolution and runs appropriate aggregation function.
/// </summary>
/// <param name="errorMsg"></param>
/// <param name="output"></param>
/// <param name="input"></param>
/// <returns></returns>
private ITimeSeriesOutput TemporalAggregation(out string errorMsg, ITimeSeriesOutput output, ITimeSeriesInput input)
{
errorMsg = "";
output.Metadata.Add("nldas_temporalresolution", input.TemporalResolution);
output.Metadata.Add("column_1", "Date");
if (input.Units.Contains("imperial"))
{
output.Metadata["nldas_unit"] = "in";
}
switch (input.TemporalResolution)
{
case "daily":
output.Data = DailyAggregatedSum(out errorMsg, 23, 1.0, output, input);
output.Metadata.Add("column_2", "Daily Total");
return(output);
case "weekly":
output.Data = WeeklyAggregatedSum(out errorMsg, 1.0, output, input);
output.Metadata.Add("column_2", "Weekly Total");
return(output);
case "monthly":
output.Data = MonthlyAggregatedSum(out errorMsg, 1.0, output, input);
output.Metadata.Add("column_2", "Monthly Total");
return(output);
default:
output.Data = (input.Units.Contains("imperial")) ? UnitConversion(out errorMsg, 1.0, output, input) : output.Data;
output.Metadata.Add("column_2", "Hourly Total");
return(output);
}
}
public async Task <IActionResult> POST([FromBody] TotalFlowInput tfInput)
{
WSTotalFlow tFlow = new WSTotalFlow();
ITimeSeriesOutput results = await tFlow.GetTotalFlowData(tfInput);
return(new ObjectResult(results));
}
/// <summary>
/// Gets the statistic details for the given data parameter.
/// </summary>
/// <param name="errorMsg"></param>
/// <param name="data"></param>
/// <param name="compareIndex">Index of the source to be compared against.</param>
/// <returns></returns>
public static ITimeSeriesOutput GetStatistics(out string errorMsg, ITimeSeriesOutput data)
{
errorMsg = "";
// Array of sources in the order they were added to the Data object.
string[] sources = data.DataSource.Split(new string[] { "," }, StringSplitOptions.RemoveEmptyEntries);
double[] sums = CalculateSums(data.Data);
double[] dailyAverage = CalculateDailyAverage(sums, data.Data);
double[] stdDeviation = CalculateStandardDeviation(dailyAverage, data.Data);
double[] gore = CalculateGORE(dailyAverage, data.Data);
//double[] goreAvg = CalculateAverageGORE(dailyAverage, data.Data);
double[] rSquared = CalculateDetermination(data.Data);
// calculated GORE value
for (int i = 0; i < dailyAverage.Length; i++)
{
//data.Metadata.Add(sources[i].Trim() + "_gore", goreAvg[i].ToString());
data.Metadata.Add(sources[i].Trim() + "_average", dailyAverage[i].ToString());
data.Metadata.Add(sources[i].Trim() + "_sum", sums[i].ToString());
data.Metadata.Add(sources[i].Trim() + "_standard_deviation", stdDeviation[i].ToString());
if (i != 0)
{
data.Metadata.Add(sources[i].Trim() + "_" + sources[0].Trim() + "_gore", gore[i].ToString());
data.Metadata.Add(sources[i].Trim() + "_" + sources[0].Trim() + "_R-Squared", rSquared[i].ToString());
}
}
return(data);
}
/// <summary>
/// Get simulated curve number data.
/// </summary>
/// <param name="errorMsg"></param>
/// <param name="input"></param>
/// <param name="output"></param>
/// <returns></returns>
public ITimeSeriesOutput Simulate(out string errorMsg, ITimeSeriesInput input, ITimeSeriesOutput precipData)
{
errorMsg = "";
ITimeSeriesOutputFactory oFactory = new TimeSeriesOutputFactory();
ITimeSeriesOutput output = oFactory.Initialize();
output.Dataset = "Surface Runoff";
output.DataSource = "curve number";
//output.Metadata = precipData.Metadata;
double cn = CalculateCN(out errorMsg, input);
// Curve number algorithm
// Runoff calculation: https://en.wikipedia.org/wiki/Runoff_curve_number
// Calculate soil moisture retention (S): S = 1000/CN - 10
// Calculate initial abstraction (Ia): Ia = 0.2S (old initial abstraction was Ia = 0.05S)
// Iterate over precipitation data (P) by date
// If precipitation <= Ia: Runoff (Q) = 0
// Else precipitation > Ia: Runoff (Q) = (P - Ia)^2/(P- Ia + S)
double s = 1000.0 / cn - 10.0;
double ia = 0.2 * s;
foreach (KeyValuePair <string, List <string> > dateValue in precipData.Data)
{
string date = dateValue.Key;
double p = double.Parse(dateValue.Value[0]);
double q = (p <= ia) ? 0 : ((p - ia) * (p - ia)) / (p - ia + s);
//Debug.WriteLine(date + ": " + q.ToString("E3"));
List <string> d = new List <string>();
d.Add(q.ToString(input.DataValueFormat));
output.Data.Add(date, d);
}
return(output);
}
/// <summary>
/// Makes the GetData call to the base NLDAS class.
/// </summary>
/// <param name="errorMsg"></param>
/// <param name="output"></param>
/// <param name="input"></param>
/// <returns></returns>
public ITimeSeriesOutput GetData(out string errorMsg, ITimeSeriesOutput output, ITimeSeriesInput input)
{
errorMsg = "";
Data.Source.NLDAS nldas = new Data.Source.NLDAS();
string data = nldas.GetData(out errorMsg, "Temp", input);
if (errorMsg.Contains("ERROR"))
{
return(null);
}
ITimeSeriesOutput nldasOutput = output;
nldasOutput = nldas.SetDataToOutput(out errorMsg, "Temperature", data, output, input);
if (errorMsg.Contains("ERROR"))
{
return(null);
}
nldasOutput = TemporalAggregation(out errorMsg, output, input);
if (errorMsg.Contains("ERROR"))
{
return(null);
}
return(nldasOutput);
}
/// <summary>
/// Makes the GetData call to the base NLDAS class.
/// </summary>
/// <param name="errorMsg"></param>
/// <param name="output"></param>
/// <param name="input"></param>
/// <returns></returns>
public ITimeSeriesOutput GetData(out string errorMsg, ITimeSeriesOutput output, ITimeSeriesInput input)
{
errorMsg = "";
Data.Source.NLDAS nldas = new Data.Source.NLDAS();
string data = nldas.GetData(out errorMsg, "PRECIP", input);
//if (errorMsg.Contains("ERROR")) { return null; }
//if (data.Contains("ERROR"))
//{
// string[] lines = data.Split(new string[] { "\n" }, StringSplitOptions.RemoveEmptyEntries);
// errorMsg = lines[0] + " Dataset: precipitation, Source: " + input.Source;
// return null;
//}
ITimeSeriesOutput nldasOutput = output;
if (errorMsg.Contains("ERROR"))
{
Utilities.ErrorOutput err = new Utilities.ErrorOutput();
output = err.ReturnError("Precipitation", "nldas", errorMsg);
errorMsg = "";
return(output);
}
else
{
nldasOutput = nldas.SetDataToOutput(out errorMsg, "Precipitation", data, output, input);
}
nldasOutput = TemporalAggregation(out errorMsg, output, input);
if (errorMsg.Contains("ERROR"))
{
return(null);
}
return(nldasOutput);
}
/// <summary>
/// Gets evapotranspiration data using the given TimeSeriesInput parameters.
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
public async Task <ITimeSeriesOutput> GetEvapotranspiration(EvapotranspirationInput input)
{
string errorMsg = "";
// Constructs default error output object containing error message.
Utilities.ErrorOutput err = new Utilities.ErrorOutput();
// Validate evapotranspiration sources.
errorMsg = (!Enum.TryParse(input.Source, true, out EvapoSources pSource)) ? "ERROR: 'Source' was not found or is invalid." : "";
if (errorMsg.Contains("ERROR"))
{
return(err.ReturnError(errorMsg));
}
// Evapotranspiration object
Evapotranspiration.Evapotranspiration evapo = new Evapotranspiration.Evapotranspiration()
{
Algorithm = input.Algorithm,
Albedo = input.Albedo,
CentralLongitude = input.CentralLongitude,
SunAngle = input.SunAngle,
Emissivity = input.Emissivity,
Model = input.Model,
Zenith = input.Zenith,
LakeSurfaceArea = input.LakeSurfaceArea,
LakeDepth = input.LakeDepth,
SubsurfaceResistance = input.SubsurfaceResistance,
StomatalResistance = input.StomatalResistance,
LeafWidth = input.LeafWidth,
RoughnessLength = input.RoughnessLength,
VegetationHeight = input.VegetationHeight,
LeafAreaIndices = input.LeafAreaIndices,
AirTemperature = input.AirTemperature,
UserData = input.UserData
};
// ITimeSeriesInputFactory object used to validate and initialize all variables of the input object.
ITimeSeriesInputFactory iFactory = new TimeSeriesInputFactory();
evapo.Input = iFactory.SetTimeSeriesInput(input, new List <string>()
{
"evapotranspiration"
}, out errorMsg);
// If error occurs in input validation and setup, errorMsg is added to metadata of an empty object.
if (errorMsg.Contains("ERROR"))
{
return(err.ReturnError(errorMsg));
}
// Gets the Evapotranspiration data.
ITimeSeriesOutput result = evapo.GetData(out errorMsg);
if (errorMsg.Contains("ERROR"))
{
return(err.ReturnError(errorMsg));
}
return(result);
}
/// <summary>
/// Checks temporal resolution and runs appropriate aggregation function.
/// </summary>
/// <param name="errorMsg"></param>
/// <param name="output"></param>
/// <param name="input"></param>
/// <returns></returns>
private ITimeSeriesOutput TemporalAggregation(out string errorMsg, ITimeSeriesOutput output, ITimeSeriesInput input)
{
errorMsg = "";
output.Metadata.Add("gldas_temporalresolution", input.TemporalResolution);
if (input.Units.Contains("imperial"))
{
output.Metadata["gldas_unit"] = "in";
}
output.Data = (input.Units.Contains("imperial")) ? NLDAS.UnitConversion(out errorMsg, output, input) : output.Data;
output.Metadata.Add("column_1", "Date");
switch (input.TemporalResolution)
{
case "daily":
output.Data = NLDAS.DailyValues(out errorMsg, output, input);
output.Metadata.Add("column_2", "Daily Average");
return(output);
case "weekly":
output.Data = NLDAS.WeeklyValues(out errorMsg, output, input);
output.Metadata.Add("column_2", "Weekly Average");
return(output);
case "monthly":
output.Data = NLDAS.MonthlyValues(out errorMsg, output, input);
output.Metadata.Add("column_2", "Monthly Average");
return(output);
default:
return(output);
}
}
public async Task <IActionResult> POST([FromBody] SoilMoistureInput evapoInput)
{
WSSoilMoisture evapo = new WSSoilMoisture();
ITimeSeriesOutput results = await evapo.GetSoilMoisture(evapoInput);
results.Metadata = Utilities.Metadata.AddToMetadata("request_url", this.Request.Path, results.Metadata);
return(new ObjectResult(results));
}
public ITimeSeriesOutput POST([FromBody] SoilMoistureInput evapoInput)
{
WSSoilMoisture evapo = new WSSoilMoisture();
ITimeSeriesOutput results = evapo.GetSoilMoisture(evapoInput);
results.Metadata = Utilities.Metadata.AddToMetadata("request_url", this.Request.Path, results.Metadata);
return(results);
}
public async Task <IActionResult> POST([FromBody] TemperatureInput tempInput)
{
WSTemperature temp = new WSTemperature();
ITimeSeriesOutput results = await temp.GetTemperature(tempInput);
results.Metadata = Utilities.Metadata.AddToMetadata("request_url", this.Request.Path, results.Metadata);
return(new ObjectResult(results));
}
public ITimeSeriesOutput POST([FromBody] TemperatureInput tempInput)
{
WSTemperature temp = new WSTemperature();
ITimeSeriesOutput results = temp.GetTemperature(tempInput);
results.Metadata = Utilities.Metadata.AddToMetadata("request_url", this.Request.Path, results.Metadata);
return(results);
}
public ITimeSeriesOutput POST([FromBody] PrecipitationInput precipInput)
{
WSPrecipitation precip = new WSPrecipitation();
ITimeSeriesOutput results = precip.GetPrecipitation(precipInput);
results.Metadata = Utilities.Metadata.AddToMetadata("request_url", this.Request.Path, results.Metadata);
return(results);
}
public async Task <IActionResult> POST([FromBody] SubSurfaceFlowInput ssFlowInput)
{
WSSubSurfaceFlow ssFlow = new WSSubSurfaceFlow();
ITimeSeriesOutput results = await ssFlow.GetSubSurfaceFlow(ssFlowInput);
results.Metadata = Utilities.Metadata.AddToMetadata("request_url", this.Request.Path, results.Metadata);
return(new ObjectResult(results));
}
public async Task <IActionResult> POST([FromBody] SurfaceRunoffInput runoffInput)
{
WSSurfaceRunoff runoff = new WSSurfaceRunoff();
ITimeSeriesOutput results = await runoff.GetSurfaceRunoff(runoffInput);
results.Metadata = Utilities.Metadata.AddToMetadata("request_url", this.Request.Path, results.Metadata);
return(new ObjectResult(results));
}
public ITimeSeriesOutput POST([FromBody] EvapotranspirationInput evapoInput)
{
WSEvapotranspiration evapo = new WSEvapotranspiration();
ITimeSeriesOutput results = evapo.GetEvapotranspiration(evapoInput);
results.Metadata = Utilities.Metadata.AddToMetadata("request_url", this.Request.Path, results.Metadata);
return(results);
}
public ITimeSeriesOutput POST([FromBody] SubSurfaceFlowInput ssFlowInput)
{
WSSubSurfaceFlow ssFlow = new WSSubSurfaceFlow();
ITimeSeriesOutput results = ssFlow.GetSubSurfaceFlow(ssFlowInput);
results.Metadata = Utilities.Metadata.AddToMetadata("request_url", this.Request.Path, results.Metadata);
return(results);
}
public ITimeSeriesOutput POST([FromBody] SurfaceRunoffInput runoffInput)
{
WSSurfaceRunoff runoff = new WSSurfaceRunoff();
ITimeSeriesOutput results = runoff.GetSurfaceRunoff(runoffInput);
results.Metadata = Utilities.Metadata.AddToMetadata("request_url", this.Request.Path, results.Metadata);
return(results);
}
public ITimeSeriesOutput POST([FromBody] WorkFlowCompareInput workflowInput)
{
WSWorkFlow workFlow = new WSWorkFlow();
ITimeSeriesOutput results = workFlow.GetWorkFlowData(workflowInput);
results.Metadata = Utilities.Metadata.AddToMetadata("request_url", this.Request.Path, results.Metadata);
return(results);
}
public async Task <IActionResult> POST([FromBody] PrecipitationInput precipInput)
{
WSPrecipitation precip = new WSPrecipitation();
ITimeSeriesOutput results = await precip.GetPrecipitation(precipInput);
results.Metadata = Utilities.Metadata.AddToMetadata("request_url", this.Request.Path, results.Metadata);
return(new ObjectResult(results));
}
public async Task <IActionResult> POST([FromBody] WorkFlowCompareInput workflowInput)
{
WSWorkFlow workFlow = new WSWorkFlow();
var stpWatch = System.Diagnostics.Stopwatch.StartNew();
ITimeSeriesOutput results = await workFlow.GetWorkFlowData(workflowInput);
stpWatch.Stop();
results.Metadata = Utilities.Metadata.AddToMetadata("retrievalTime", stpWatch.ElapsedMilliseconds.ToString(), results.Metadata);
results.Metadata = Utilities.Metadata.AddToMetadata("request_url", this.Request.Path, results.Metadata);
return(new ObjectResult(results));
}
public async Task <IActionResult> POST([FromBody] EvapotranspirationInput evapoInput)
{
var watch = System.Diagnostics.Stopwatch.StartNew(); //For Debugging
WSEvapotranspiration evapo = new WSEvapotranspiration();
ITimeSeriesOutput results = await evapo.GetEvapotranspiration(evapoInput);
results.Metadata = Utilities.Metadata.AddToMetadata("request_url", this.Request.Path, results.Metadata);
watch.Stop();
string elapsed = TimeSpan.FromMilliseconds(watch.ElapsedMilliseconds).TotalMinutes.ToString();
results.Metadata.Add("Time Elapsed", elapsed);
return(new ObjectResult(results));
}