/// <summary>
/// Constructs the request
/// </summary>
/// <param name="environmentVariableName">The name of the variable used in the particular FetchClimate service deployment</param>
/// <param name="domain">The domain for which the mean value must be fetched</param>
/// <param name="reproducibilityTimestamp">Timestamp (UTC) at which the configuration must be taken</param>
/// <param name="specificDataSources">the array of specific data sources identifiers to supply the mean value with. null value symbolizes automatic choice among all available data sources</param>
public FetchRequest(string environmentVariableName, IFetchDomain domain, DateTime reproducibilityTimestamp, string[] specificDataSources = null)
{
this.environmentVariableName = environmentVariableName;
this.domain = domain;
this.useParticularDataSources = specificDataSources;
this.reproducibilityTimeStampUTC = reproducibilityTimestamp;
}
public async Task ReanalysisGrowingUncertainty()
{
var storage = TestDataStorageFactory.GetStorageContext(TestConstants.UriReanalysisRegular);
NCEPReanalysisRegularGridDataHandler regularHandler = await NCEPReanalysisRegularGridDataHandler.CreateAsync(storage);
ITimeRegion tr = new TimeRegion(firstYear: 1961, lastYear: 1961, firstDay: 1, lastDay: 1, startHour: 0, stopHour: 0);
IFetchDomain dataDenseDomain = FetchDomain.CreatePoints(
new double[] { 76.25 },
new double[] { 31.25 }, tr);//more dense nodes
IFetchDomain dataSparseDomain = FetchDomain.CreatePoints(
new double[] { 1.25 },
new double[] { 31.25 }, tr);//more rare nodes
FetchRequest dataDenseRequest = new FetchRequest("air", dataDenseDomain);
FetchRequest dataSparseRequest = new FetchRequest("air", dataSparseDomain);
var handlerPrivate = new PrivateObject(regularHandler, new PrivateType(typeof(DataHandlerFacade)));
var evaluatorPrivate = new PrivateObject(handlerPrivate, "uncertaintyEvaluator");
Array dataDenseUncertainty = await(Task <Array>)(evaluatorPrivate.Invoke("EvaluateAsync", RequestContextStub.GetStub(storage, dataDenseRequest)));
Array dataSparseUncertainty = await(Task <Array>)(evaluatorPrivate.Invoke("EvaluateAsync", RequestContextStub.GetStub(storage, dataSparseRequest)));
Assert.IsFalse(double.IsNaN((double)dataDenseUncertainty.GetValue(0)));
Assert.IsFalse(double.IsNaN((double)dataSparseUncertainty.GetValue(0)));
Assert.IsTrue(((double)dataDenseUncertainty.GetValue(0)) < double.MaxValue);
Assert.IsTrue(((double)dataSparseUncertainty.GetValue(0)) < double.MaxValue);
Assert.IsTrue(((double)dataDenseUncertainty.GetValue(0)) >= 0.0);
Assert.IsTrue(((double)dataSparseUncertainty.GetValue(0)) >= 0.0);
//Assert.IsTrue(((double)dataDenseUncertainty.GetValue(0))<((double)dataSparseUncertainty.GetValue(0)));
}
public async Task ReanslysisNewYearCrossingSubDayTest()
{
var regularStorage = TestDataStorageFactory.GetStorageContext(TestConstants.UriReanalysisRegular);
NCEPReanalysisRegularGridDataHandler regularHandler = await NCEPReanalysisRegularGridDataHandler.CreateAsync(regularStorage);
ITimeRegion crossingTr = new TimeRegion(firstYear: 1950, lastYear: 1951, firstDay: 336, lastDay: 30, startHour: 0, stopHour: 12);
IFetchDomain crossingDomain = FetchDomain.CreatePoints(
new double[] { -37.5 }, // data index 51
new double[] { 137.5 }, //data index 55
crossingTr);
ITimeRegion firstTr = new TimeRegion(firstYear: 1950, lastYear: 1950, firstDay: 336, lastDay: 365, startHour: 0, stopHour: 12);
IFetchDomain firstDomain = FetchDomain.CreatePoints(
new double[] { -37.5 }, // data index 51
new double[] { 137.5 }, //data index 55
firstTr);
ITimeRegion secondTr = new TimeRegion(firstYear: 1951, lastYear: 1951, firstDay: 1, lastDay: 30, startHour: 0, stopHour: 12);
IFetchDomain secondDomain = FetchDomain.CreatePoints(
new double[] { -37.5 }, // data index 51
new double[] { 137.5 }, //data index 55
secondTr);
var handlerPrivate = new PrivateObject(regularHandler, new PrivateType(typeof(DataHandlerFacade)));
var aggregatorPrivate = new PrivateObject(handlerPrivate, "valuesAggregator");
double crossing = (double)(await(Task <Array>)(aggregatorPrivate.Invoke("AggregateAsync", RequestContextStub.GetStub(regularStorage, new FetchRequest("air", crossingDomain)), null))).GetValue(0);
double first = (double)(await(Task <Array>)(aggregatorPrivate.Invoke("AggregateAsync", RequestContextStub.GetStub(regularStorage, new FetchRequest("air", firstDomain)), null))).GetValue(0);
double second = (double)(await(Task <Array>)(aggregatorPrivate.Invoke("AggregateAsync", RequestContextStub.GetStub(regularStorage, new FetchRequest("air", secondDomain)), null))).GetValue(0);
Assert.AreEqual(crossing, (first + second) / 2.0, 1e-6);
}
public async Task ReanslysisUncertatintyTest()
{
var storage = TestDataStorageFactory.GetStorageContext(TestConstants.UriReanalysisRegular);
NCEPReanalysisRegularGridDataHandler regularHandler = await NCEPReanalysisRegularGridDataHandler.CreateAsync(storage);
ITimeRegion tr = new TimeRegion(firstYear: 1961, lastYear: 1990);
IFetchDomain dataDomain1 = FetchDomain.CreatePoints(
new double[] { 37.5 },
new double[] { 30.0 }, tr);
IFetchDomain dataDomain2 = FetchDomain.CreatePoints(
new double[] { 37.5 },
new double[] { -30.0 }, tr);
FetchRequest dataRequest1 = new FetchRequest("air", dataDomain1);
FetchRequest dataRequest2 = new FetchRequest("air", dataDomain2);
var handlerPrivate = new PrivateObject(regularHandler, new PrivateType(typeof(DataHandlerFacade)));
var evaluatorPrivate = new PrivateObject(handlerPrivate, "uncertaintyEvaluator");
Array dataUncertainty1 = await(Task <Array>)(evaluatorPrivate.Invoke("EvaluateAsync", RequestContextStub.GetStub(storage, dataRequest1)));
Array dataUncertainty2 = await(Task <Array>)(evaluatorPrivate.Invoke("EvaluateAsync", RequestContextStub.GetStub(storage, dataRequest2)));
Assert.IsFalse(double.IsNaN((double)dataUncertainty1.GetValue(0)));
Assert.IsFalse(double.IsNaN((double)dataUncertainty2.GetValue(0)));
Assert.IsTrue(((double)dataUncertainty1.GetValue(0)) < double.MaxValue);
Assert.IsTrue(((double)dataUncertainty2.GetValue(0)) < double.MaxValue);
Assert.IsTrue(((double)dataUncertainty1.GetValue(0)) >= 0.0);
Assert.IsTrue(((double)dataUncertainty2.GetValue(0)) >= 0.0);
}
public async Task MonthlyMeansMissingValueOnWaterTest()
{
var storage = TestDataStorageFactory.GetStorageContext(TestConstants.UriCru);
CruCl20DataHandler cru = await CruCl20DataHandler.CreateAsync(storage);
ITimeRegion tr = new TimeRegion();
IFetchDomain domain = FetchDomain.CreatePoints(
new double[] { 0.5 },
new double[] { 0.5 },
tr);
FetchRequest request = new FetchRequest("tmp", domain);
var handlerPrivate = new PrivateObject(cru, new PrivateType(typeof(DataHandlerFacade)));
var aggregatorPrivate = new PrivateObject(handlerPrivate, "valuesAggregator");
for (int i = 0; i < 2; i++)
{
Array mask = i == 0 ? null : new bool[, ] {
{ true }
};
var res = await(Task <Array>)(aggregatorPrivate.Invoke("AggregateAsync", RequestContextStub.GetStub(storage, request), null));
//lon,lat,t
double[] temps = (double[])res;
Assert.AreEqual(1, temps.Length);
Assert.IsTrue(double.IsNaN(temps[0]));
}
}
public async Task CruAllVaraiblesValuesTest()
{
var storage = TestDataStorageFactory.GetStorageContext(TestConstants.UriCru);
CruCl20DataHandler cru = await CruCl20DataHandler.CreateAsync(storage);
ITimeRegion tr = new TimeRegion().GetMonthlyTimeseries(firstMonth: 1, lastMonth: 1);
IFetchDomain domain = FetchDomain.CreatePoints(
new double[] { 48.25 }, // data index 679
new double[] { -100.25 }, //data index 478
tr);
var handlerPrivate = new PrivateObject(cru, new PrivateType(typeof(DataHandlerFacade)));
var aggregatorPrivate = new PrivateObject(handlerPrivate, "valuesAggregator");
FetchRequest tmpRequest = new FetchRequest("tmp", domain);
FetchRequest preRequest = new FetchRequest("pre", domain);
FetchRequest wndRequest = new FetchRequest("wnd", domain);
FetchRequest sunpRequest = new FetchRequest("sunp", domain);
FetchRequest rehRequest = new FetchRequest("reh", domain);
FetchRequest rd0Request = new FetchRequest("rd0", domain);
FetchRequest frsRequest = new FetchRequest("frs", domain);
FetchRequest dtrRequest = new FetchRequest("dtr", domain);
Assert.AreEqual(4.9, (double)(await(Task <Array>)(aggregatorPrivate.Invoke("AggregateAsync", RequestContextStub.GetStub(storage, wndRequest), null))).GetValue(0), TestConstants.FloatPrecision); //manual data comparision
Assert.AreEqual(-15.4, (double)(await(Task <Array>)(aggregatorPrivate.Invoke("AggregateAsync", RequestContextStub.GetStub(storage, tmpRequest), null))).GetValue(0), TestConstants.FloatPrecision);
Assert.AreEqual(48.1, (double)(await(Task <Array>)(aggregatorPrivate.Invoke("AggregateAsync", RequestContextStub.GetStub(storage, sunpRequest), null))).GetValue(0), TestConstants.FloatPrecision);
Assert.AreEqual(74.5, (double)(await(Task <Array>)(aggregatorPrivate.Invoke("AggregateAsync", RequestContextStub.GetStub(storage, rehRequest), null))).GetValue(0), TestConstants.FloatPrecision);
Assert.AreEqual(7.6, (double)(await(Task <Array>)(aggregatorPrivate.Invoke("AggregateAsync", RequestContextStub.GetStub(storage, rd0Request), null))).GetValue(0), TestConstants.FloatPrecision);
Assert.AreEqual(14.0, (double)(await(Task <Array>)(aggregatorPrivate.Invoke("AggregateAsync", RequestContextStub.GetStub(storage, preRequest), null))).GetValue(0), TestConstants.FloatPrecision);
Assert.AreEqual(30.7, (double)(await(Task <Array>)(aggregatorPrivate.Invoke("AggregateAsync", RequestContextStub.GetStub(storage, frsRequest), null))).GetValue(0), TestConstants.FloatPrecision);
Assert.AreEqual(11.8, (double)(await(Task <Array>)(aggregatorPrivate.Invoke("AggregateAsync", RequestContextStub.GetStub(storage, dtrRequest), null))).GetValue(0), TestConstants.FloatPrecision);
}
public async Task ReanalysisOutOfDataTest()
{
var storage = TestDataStorageFactory.GetStorageContext(TestConstants.UriReanalysisRegular);
NCEPReanalysisRegularGridDataHandler regularHandler = await NCEPReanalysisRegularGridDataHandler.CreateAsync(storage);
ITimeRegion firstDataYear = new TimeRegion(firstYear: 1245, lastYear: 1245);
IFetchDomain dataDomain = FetchDomain.CreatePoints(
new double[] { -37.5 }, // data index 51
new double[] { 137.5 }, //data index 55
firstDataYear);
FetchRequest dataRequest = new FetchRequest("air", dataDomain);
var handlerPrivate = new PrivateObject(regularHandler, new PrivateType(typeof(DataHandlerFacade)));
var evaluatorPrivate = new PrivateObject(handlerPrivate, "uncertaintyEvaluator");
var aggregatorPrivate = new PrivateObject(handlerPrivate, "valuesAggregator");
Array dataArray = await(Task <Array>)(aggregatorPrivate.Invoke("AggregateAsync", RequestContextStub.GetStub(storage, dataRequest), null));;
Array dataUncertainty = await(Task <Array>)(evaluatorPrivate.Invoke("EvaluateAsync", RequestContextStub.GetStub(storage, dataRequest)));
Assert.AreEqual(1, dataArray.Length);
Assert.AreEqual(1, dataUncertainty.Length);
Assert.IsTrue(double.IsNaN((double)dataArray.GetValue(0)));
Assert.IsTrue(double.IsNaN((double)dataUncertainty.GetValue(0)));
}
public async Task MonthlyMeansLandOnlyVariablesTest()
{
var storage = TestDataStorageFactory.GetStorageContext(TestConstants.UriCru);
CruCl20DataHandler cru = await CruCl20DataHandler.CreateAsync(storage);
ITimeRegion tr = new TimeRegion().GetMonthlyTimeseries(firstMonth: 1, lastMonth: 1);
IFetchDomain oceanDomain = FetchDomain.CreateCells(
new double[] { 22.0 },
new double[] { -25.0 },
new double[] { 23.0 },
new double[] { -24.0 },
tr);
IFetchDomain landDomain = FetchDomain.CreateCells(
new double[] { 24.0 },
new double[] { -10.0 },
new double[] { 25.0 },
new double[] { -9.0 },
tr);
IFetchDomain landOceanMixDomain = FetchDomain.CreateCells(
new double[] { 24.0 },
new double[] { -16.0 },
new double[] { 25.0 },
new double[] { -14.0 },
tr);
FetchRequest oceanPrecRequest = new FetchRequest("pre", oceanDomain);
FetchRequest landPrecRequest = new FetchRequest("pre", landDomain);
FetchRequest mixPrecRequest = new FetchRequest("pre", landOceanMixDomain);
var handlerPrivate = new PrivateObject(cru, new PrivateType(typeof(DataHandlerFacade)));
var evaluatorPrivate = new PrivateObject(handlerPrivate, "uncertaintyEvaluator");
var aggregatorPrivate = new PrivateObject(handlerPrivate, "valuesAggregator");
double oceanUnc = (double)(await(Task <Array>)(evaluatorPrivate.Invoke("EvaluateAsync", RequestContextStub.GetStub(storage, oceanPrecRequest)))).GetValue(0);
double landUnc = (double)(await(Task <Array>)(evaluatorPrivate.Invoke("EvaluateAsync", RequestContextStub.GetStub(storage, landPrecRequest)))).GetValue(0);
double mixUnc = (double)(await(Task <Array>)(evaluatorPrivate.Invoke("EvaluateAsync", RequestContextStub.GetStub(storage, mixPrecRequest)))).GetValue(0);
Assert.IsTrue(double.IsNaN(oceanUnc));
Assert.AreEqual(double.MaxValue, mixUnc);
Assert.IsTrue(!double.IsNaN(landUnc));
Assert.IsTrue(landUnc < double.MaxValue); //check variogram presence if this fails
double oceanVal = (double)(await(Task <Array>)(aggregatorPrivate.Invoke("AggregateAsync", RequestContextStub.GetStub(storage, oceanPrecRequest), null))).GetValue(0);
double landVal = (double)(await(Task <Array>)(aggregatorPrivate.Invoke("AggregateAsync", RequestContextStub.GetStub(storage, landPrecRequest), null))).GetValue(0);
double mixVal = (double)(await(Task <Array>)(aggregatorPrivate.Invoke("AggregateAsync", RequestContextStub.GetStub(storage, mixPrecRequest), null))).GetValue(0);
Assert.IsTrue(double.IsNaN(oceanVal));
Assert.IsTrue(!double.IsNaN(landVal));
Assert.IsTrue(!double.IsNaN(mixVal));
}
public async Task GHCNOutOfDataTests()
{
IStorageContext storage = new GhcnStorageContextStub();
DataSourceHandler handler = await GHCNv2DataSource.DataHandler.CreateAsync(storage);
IFetchDomain fd = FetchDomain.CreatePoints(new double[] { Math.Asin(1.0 / Math.Sqrt(3.0)) * 180.0 / Math.PI }, new double[] { 45.0 }, new TimeRegion(firstYear: 1970, lastYear: 1970, firstDay: 160, lastDay: 190)); //mar
FetchRequest fr = new FetchRequest("temp", fd);
IRequestContext requestContext = RequestContextStub.GetStub(storage, fr);
var result = await handler.ProcessRequestAsync(requestContext);
Assert.IsTrue(double.IsNaN((double)result.GetValue(0)));
}
public async Task CellSetDataTest()
{
var storage = TestDataStorageFactory.GetStorageContext(TestConstants.UriReanalysisRegular);
NCEPReanalysisRegularGridDataHandler reanalysis = await NCEPReanalysisRegularGridDataHandler.CreateAsync(storage);
ITimeRegion tr = new TimeRegion(firstYear: 1980, lastYear: 1980, firstDay: 2, lastDay: 3, startHour: 0, stopHour: 0).
GetSeasonlyTimeseries(firstDay: 2, lastDay: 3, isIntervalTimeseries: false);//indeces 46756,46760; hours sice 1-1-1 00:00:00 = 17347560 , 17347524
IFetchDomain domain = FetchDomain.CreateCells(
//ocean region
new double[] { 67.5, 7.5, 75.0, 0.0 }, //indeces 9,33,6,36
new double[] { 75.0, 7.5, 107.5, 52.5 }, //indeces 30,3,43,21
new double[] { 67.5, 7.5, 75.0, 0.0 }, //indeces 9,33,6,36
new double[] { 75.0, 7.5, 107.5, 52.5 }, //indeces 30,3,43,21
tr);
FetchRequest request = new FetchRequest("air", domain);
bool[, ] mask = new bool[4, 2];
bool[] smask = System.Linq.Enumerable.Repeat(true, 8).ToArray();
Buffer.BlockCopy(smask, 0, mask, 0, 8 * sizeof(bool));
var handlerPrivate = new PrivateObject(reanalysis, new PrivateType(typeof(DataHandlerFacade)));
var aggregatorPrivate = new PrivateObject(handlerPrivate, "valuesAggregator");
for (int i = 0; i < 2; i++)
{
bool[, ] effectiveMask = i == 0 ? null : mask;
var result = await(Task <Array>)(aggregatorPrivate.Invoke("AggregateAsync", RequestContextStub.GetStub(storage, request), effectiveMask));
//i,t
double[, ] temps = (double[, ])result;
Assert.AreEqual(8, temps.Length);
Assert.AreEqual(4, temps.GetLength(0));
Assert.AreEqual(2, temps.GetLength(1));
Assert.AreEqual(-18.05, temps[0, 0], TestConstants.FloatPrecision); //reference data value (unscaled) is -25771
Assert.AreEqual(26.95, temps[1, 0], TestConstants.FloatPrecision); //reference data value (unscaled) is -21271
Assert.AreEqual(-25.05, temps[2, 0], TestConstants.FloatPrecision); //reference data value (unscaled) is -26471
Assert.AreEqual(26.15, temps[3, 0], TestConstants.FloatPrecision); //reference data value (unscaled) is -21351
Assert.AreEqual(-19.25, temps[0, 1], TestConstants.FloatPrecision); //reference data value (unscaled) is -25891
Assert.AreEqual(25.05, temps[1, 1], TestConstants.FloatPrecision); //reference data value (unscaled) is -21461
Assert.AreEqual(-28.55, temps[2, 1], TestConstants.FloatPrecision); //reference data value (unscaled) is -26821
Assert.AreEqual(25.65, temps[3, 1], TestConstants.FloatPrecision); //reference data value (unscaled) is -21401
}
}
public async Task CruUncertaintyLandAndWaterTest()
{
var storage = TestDataStorageFactory.GetStorageContext(TestConstants.UriCru);
CruCl20DataHandler cru = await CruCl20DataHandler.CreateAsync(storage);
ITimeRegion tr = new TimeRegion(firstYear: 1950, lastYear: 2010);
IFetchDomain domain = FetchDomain.CreateCells(
//ocean region
new double[] { 0.0 },
new double[] { 0.0 },
new double[] { 1.0 },
new double[] { 1.0 },
tr);
FetchRequest request = new FetchRequest("pre", domain);
var handlerPrivate = new PrivateObject(cru, new PrivateType(typeof(DataHandlerFacade)));
var evaluatorPrivate = new PrivateObject(handlerPrivate, "uncertaintyEvaluator");
var res = await(Task <Array>)(evaluatorPrivate.Invoke("EvaluateAsync", RequestContextStub.GetStub(storage, request)));
//i,t
double[] prec = (double[])res;
Assert.AreEqual(1, prec.Length);
Assert.IsTrue(double.IsNaN(prec[0]));
domain = FetchDomain.CreateCells(
//land region
new double[] { 10.0 },
new double[] { 10.0 },
new double[] { 11.0 },
new double[] { 11.0 },
tr);
request = new FetchRequest("pre", domain);
res = await(Task <Array>)(evaluatorPrivate.Invoke("EvaluateAsync", RequestContextStub.GetStub(storage, request)));
//i,t
prec = (double[])res;
Assert.AreEqual(1, prec.Length);
Assert.IsTrue(!double.IsNaN(prec[0]));
}
public async Task PointCubeDataTest()
{
var storage = TestDataStorageFactory.GetStorageContext(TestConstants.UriCru);
CruCl20DataHandler cru = await CruCl20DataHandler.CreateAsync(storage);
ITimeRegion tr = new TimeRegion().GetMonthlyTimeseries(firstMonth: 2, lastMonth: 3);
IFetchDomain domain = FetchDomain.CreatePointGrid(
GenerateAxis(67.25, 67.75, 0.25),
GenerateAxis(179.25, 180.75, 0.25),
tr);
FetchRequest request = new FetchRequest("tmp", domain);
bool[, ,,,] mask = new bool[7, 3, 1, 2, 1];
bool[] maskStreched = Enumerable.Repeat(true, 2 * 7 * 3).ToArray();
Buffer.BlockCopy(maskStreched, 0, mask, 0, maskStreched.Length * sizeof(bool));
var handlerPrivate = new PrivateObject(cru, new PrivateType(typeof(DataHandlerFacade)));
var aggregatorPrivate = new PrivateObject(handlerPrivate, "valuesAggregator");
for (int i = 0; i < 2; i++)
{
Array effectiveMask = i == 0 ? null : mask;
var res = await(Task <Array>)(aggregatorPrivate.Invoke("AggregateAsync", RequestContextStub.GetStub(storage, request), null));
//lon,lat,t
double[,,] temps = (double[, , ])res;
double precision = TestConstants.FloatPrecision; //float precision
//manual data comparasion
//lon,lat,t //lat,lon,t
Assert.AreEqual(-29.3, temps[0, 0, 0], precision); //corresponding varaible index [793,2155,1]
Assert.AreEqual(-30.0, temps[0, 2, 0], precision); //corresponding varaible index [796,2155,1]
Assert.AreEqual(-26.6, temps[4, 0, 0], precision); //corresponding varaible index [793,1,1]
Assert.AreEqual(-26.8, temps[4, 2, 0], precision); //corresponding varaible index [796,1,1]
Assert.AreEqual(-27.4, temps[0, 0, 1], precision); //corresponding varaible index [793,2155,2]
Assert.AreEqual(-28.2, temps[0, 2, 1], precision); //corresponding varaible index [796,2155,2]
Assert.AreEqual(-25.1, temps[4, 0, 1], precision); //corresponding varaible index [793,1,2]
Assert.AreEqual(-25.2, temps[4, 2, 1], precision); //corresponding varaible index [796,1,2]
}
}
public async Task CpcValuesTest()
{
var storage = TestDataStorageFactory.GetStorageContext(TestConstants.UriCpc);
CPCDataSource.CpcDataHandler handler = await CPCDataSource.CpcDataHandler.CreateAsync(storage);
ITimeRegion tr = new TimeRegion(firstYear: 1949, lastYear: 1949).GetMonthlyTimeseries(firstMonth: 4, lastMonth: 4); //data index 15
IFetchDomain domain = FetchDomain.CreatePoints(
new double[] { 31.75 }, //data index 116
new double[] { 84.75 }, //data index 171
tr);
FetchRequest soilRequest = new FetchRequest("soilw", domain);
var handlerPrivate = new PrivateObject(handler, new PrivateType(typeof(DataHandlerFacade)));
var aggregatorPrivate = new PrivateObject(handlerPrivate, "valuesAggregator");
Assert.AreEqual(101.925401325, (double)(await(Task <Array>)(aggregatorPrivate.Invoke("AggregateAsync", RequestContextStub.GetStub(storage, soilRequest), null))).GetValue(0), TestConstants.DoublePrecision); //manual data comparision. data -22079
}
public async Task CpcMvTest()
{
var storage = TestDataStorageFactory.GetStorageContext(TestConstants.UriCpc);
CPCDataSource.CpcDataHandler handler = await CPCDataSource.CpcDataHandler.CreateAsync(storage);
ITimeRegion tr = new TimeRegion(firstYear: 1949, lastYear: 1949).GetMonthlyTimeseries(firstMonth: 4, lastMonth: 4);//data index 15
IFetchDomain domain = FetchDomain.CreatePoints(
new double[] { 10.7 },
new double[] { -148.4 },
tr);
FetchRequest soilRequest = new FetchRequest("soilw", domain);
var handlerPrivate = new PrivateObject(handler, new PrivateType(typeof(DataHandlerFacade)));
var aggregatorPrivate = new PrivateObject(handlerPrivate, "valuesAggregator");
Assert.IsTrue(double.IsNaN((double)(await(Task <Array>)(aggregatorPrivate.Invoke("AggregateAsync", RequestContextStub.GetStub(storage, soilRequest), null))).GetValue(0)));
}
public async Task GtopoValuesTest()
{
var storage = TestDataStorageFactory.GetStorageContext(TestConstants.UriGtopo);
GTOPO30DataSource.GTOPO30DataHandler gtopo = await GTOPO30DataSource.GTOPO30DataHandler.CreateAsync(storage);
ITimeRegion tr = new TimeRegion().GetMonthlyTimeseries(firstMonth: 1, lastMonth: 1);
IFetchDomain domain = FetchDomain.CreatePoints(
new double[] { 55.7125 }, // data index 17485
new double[] { 37.5125 }, //data index 26101
tr);
FetchRequest elevRequest = new FetchRequest("elevation", domain);
var handlerPrivate = new PrivateObject(gtopo, new PrivateType(typeof(DataHandlerFacade)));
var aggregatorPrivate = new PrivateObject(handlerPrivate, "valuesAggregator");
Assert.AreEqual(188.0, (double)(await(Task <Array>)(aggregatorPrivate.Invoke("AggregateAsync", RequestContextStub.GetStub(storage, elevRequest), null))).GetValue(0)); //manual data comparision
}
public async Task GhcnPartialFutureOutOfDataFinishesTest()
{
System.Diagnostics.Trace.WriteLine(TestConstants.UriGHCN);
var storage = TestDataStorageFactory.GetStorageContext(TestConstants.UriGHCN);
DataSourceHandler handler = await GHCNv2DataSource.DataHandler.CreateAsync(storage);
ITimeRegion tr = new TimeRegion(firstYear: 1990, lastYear: 2101).GetMonthlyTimeseries(firstMonth: 12, lastMonth: 12); //data index 2567
IFetchDomain domain = FetchDomain.CreatePoints(
new double[] { -25.18 }, //exact station. data index 18398
new double[] { 151.65 },
tr);
FetchRequest prateRequest = new FetchRequest("prate", domain);
var reqContext = RequestContextStub.GetStub(storage, prateRequest);
var result = await handler.ProcessRequestAsync(reqContext);
}
public async Task WorldClimAllVaraiblesValuesTest()
{
var storage = TestDataStorageFactory.GetStorageContext(TestConstants.UriWorldClim);
WorldClim14DataSource wc = await WorldClim14DataSource.CreateAsync(storage);
ITimeRegion tr = new TimeRegion().GetMonthlyTimeseries(firstMonth: 1, lastMonth: 1);
IFetchDomain domain = FetchDomain.CreatePoints(
new double[] { 48.25 }, // data index 12990
new double[] { -100.25 }, //data index 9570
tr);
FetchRequest tmpRequest = new FetchRequest("tmean", domain);
FetchRequest preRequest = new FetchRequest("prec", domain);
var handlerPrivate = new PrivateObject(wc, new PrivateType(typeof(DataHandlerFacade)));
var aggregatorPrivate = new PrivateObject(handlerPrivate, "valuesAggregator");
Assert.AreEqual(-14.9, (double)(await(Task <Array>)(aggregatorPrivate.Invoke("AggregateAsync", RequestContextStub.GetStub(storage, tmpRequest), null))).GetValue(0), 1e-2); //manual data comparision
Assert.AreEqual(13, (double)(await(Task <Array>)(aggregatorPrivate.Invoke("AggregateAsync", RequestContextStub.GetStub(storage, preRequest), null))).GetValue(0), 1e-1);
}
public async Task TestUnknownUncertatintyMaxValue()
{
var storage = TestDataStorageFactory.GetStorageContext(TestConstants.UriHADCM3_sra_tas);
HADCM3DataHandler regularHandler = await HADCM3DataHandler.CreateAsync(storage);
TimeRegion tr = new TimeRegion(firstYear: 2010, lastYear: 2015, firstDay: 91, lastDay: 120, startHour: 0, stopHour: 24); //index 15 ; april 2001
IFetchDomain tmpDomain = FetchDomain.CreatePoints(
new double[] { -75.0 }, // data index 6,7
new double[] { 90.0 },
tr);
FetchRequest tmpRequest = new FetchRequest("tas", tmpDomain);
var handlerPrivate = new PrivateObject(regularHandler, new PrivateType(typeof(DataHandlerFacade)));
var evaluatorPrivate = new PrivateObject(handlerPrivate, "uncertaintyEvaluator");
var res = await(Task <Array>)(evaluatorPrivate.Invoke("EvaluateAsync", RequestContextStub.GetStub(storage, tmpRequest)));
Assert.AreEqual(double.MaxValue, ((double)res.GetValue(0)));
}
public async Task MonthlyMeansUnknownVarEvaluationRejectingTest()
{
var storage = TestDataStorageFactory.GetStorageContext(TestConstants.UriCru);
CruCl20DataHandler cru = await CruCl20DataHandler.CreateAsync(storage);
ITimeRegion tr = new TimeRegion().GetMonthlyTimeseries(firstMonth: 1, lastMonth: 1);
IFetchDomain d = FetchDomain.CreateCells( //below the data
new double[] { -10.0 },
new double[] { -15.0 },
new double[] { -8.0 },
new double[] { -14.0 },
tr);
FetchRequest r = new FetchRequest("fasdf342f34", d);
var handlerPrivate = new PrivateObject(cru, new PrivateType(typeof(DataHandlerFacade)));
var evaluatorPrivate = new PrivateObject(handlerPrivate, "uncertaintyEvaluator");
var et = await(Task <Array>)(evaluatorPrivate.Invoke("EvaluateAsync", RequestContextStub.GetStub(storage, r)));
}
public async Task CruUncertaintyTest()
{
var storage = TestDataStorageFactory.GetStorageContext(TestConstants.UriCru);
CruCl20DataHandler cru = await CruCl20DataHandler.CreateAsync(storage);
ITimeRegion tr = new TimeRegion().GetMonthlyTimeseries(firstMonth: 1, lastMonth: 1);
IFetchDomain domain = FetchDomain.CreatePoints(
new double[] { 48.25 }, // data index 679
new double[] { -100.25 }, //data index 478
tr); //20.0, -180.0, 85.0, -20.0 north america region. reh rtgcv for the january is 4.8
FetchRequest rehRequest = new FetchRequest("reh", domain);
var handlerPrivate = new PrivateObject(cru, new PrivateType(typeof(DataHandlerFacade)));
var evaluatorPrivate = new PrivateObject(handlerPrivate, "uncertaintyEvaluator");
double unc = (double)(await(Task <Array>)(evaluatorPrivate.Invoke("EvaluateAsync", RequestContextStub.GetStub(storage, rehRequest)))).GetValue(0);
Assert.AreEqual(4.8, unc, 1e-8);
}
public async Task EtopoValuesTest()
{
var storage = TestDataStorageFactory.GetStorageContext(TestConstants.UriEtopo);
ETOPO1DataSource.ETOPO1DataHandler gtopo = await ETOPO1DataSource.ETOPO1DataHandler.CreateAsync(storage);
ITimeRegion tr = new TimeRegion().GetMonthlyTimeseries(firstMonth: 1, lastMonth: 1);
IFetchDomain domain = FetchDomain.CreatePoints(
new double[] { 61.55, 61.55 }, // data index 9093
new double[] { 328.45, -31.55 }, //data index 8907 (the same point, different lon notations)
tr);
FetchRequest elevRequest = new FetchRequest("Elevation", domain);
var handlerPrivate = new PrivateObject(gtopo, new PrivateType(typeof(DataHandlerFacade)));
var aggregatorPrivate = new PrivateObject(handlerPrivate, "valuesAggregator");
Assert.AreEqual(-2441.0, (double)(await(Task <Array>)(aggregatorPrivate.Invoke("AggregateAsync", RequestContextStub.GetStub(storage, elevRequest), null))).GetValue(0), 1e-9); //manual data comparision
Assert.AreEqual(-2441.0, (double)(await(Task <Array>)(aggregatorPrivate.Invoke("AggregateAsync", RequestContextStub.GetStub(storage, elevRequest), null))).GetValue(1), 1e-9); //manual data comparision
}
public async Task GhcnPrateValuesTest()
{
System.Diagnostics.Trace.WriteLine(TestConstants.UriGHCN);
var storage = TestDataStorageFactory.GetStorageContext(TestConstants.UriGHCN);
DataSourceHandler handler = await GHCNv2DataSource.DataHandler.CreateAsync(storage);
ITimeRegion tr = new TimeRegion(firstYear: 1914, lastYear: 1914).GetMonthlyTimeseries(firstMonth: 12, lastMonth: 12); //data index 2567
IFetchDomain domain = FetchDomain.CreatePoints(
new double[] { -25.18 }, //exact station. data index 18398
new double[] { 151.65 },
tr);
FetchRequest prateRequest = new FetchRequest("prate", domain);
var reqContext = RequestContextStub.GetStub(storage, prateRequest);
var result = await handler.ProcessRequestAsync(reqContext);
Assert.AreEqual(85.1, (double)result.GetValue(0), 1e-3); //manual data comparison.
}
public async Task TestTemperatureValue()
{
var storage = TestDataStorageFactory.GetStorageContext(TestConstants.UriHADCM3_sra_tas);
HADCM3DataHandler regularHandler = await HADCM3DataHandler.CreateAsync(storage);
TimeRegion tr = new TimeRegion(firstYear: 2001, lastYear: 2001, firstDay: 91, lastDay: 120, startHour: 0, stopHour: 24); //index 15 ; april 2001
IFetchDomain tmpDomain = FetchDomain.CreatePoints(
new double[] { -75.0, -72.5 }, // data index 6,7
new double[] { 90.0, 105.0 }, //data index 24,28
tr);
FetchRequest tmpRequest = new FetchRequest("tas", tmpDomain);
var handlerPrivate = new PrivateObject(regularHandler, new PrivateType(typeof(DataHandlerFacade)));
var aggregatorPrivate = new PrivateObject(handlerPrivate, "valuesAggregator");
var res = await(Task <Array>)(aggregatorPrivate.Invoke("AggregateAsync", RequestContextStub.GetStub(storage, tmpRequest), null));
Assert.AreEqual(-64.256323, (double)res.GetValue(0), TestConstants.FloatPrecision); //manual data comparision
Assert.AreEqual(-58.911108, (double)res.GetValue(1), TestConstants.FloatPrecision); //manual data comparision
}
public async Task ReanalysisAllVaraiblesValuesTest()
{
var regularStorage = TestDataStorageFactory.GetStorageContext(TestConstants.UriReanalysisRegular);
NCEPReanalysisRegularGridDataHandler regularHandler = await NCEPReanalysisRegularGridDataHandler.CreateAsync(regularStorage);
ITimeRegion tr = new TimeRegion(firstYear: 1980, lastYear: 1980, firstDay: 1, lastDay: 1, startHour: 0, stopHour: 0); //index 46752 ; hours sice 1-1-1 00:00:00 = 17347536
IFetchDomain tmpDomain = FetchDomain.CreatePoints(
new double[] { -37.5 }, // data index 51
new double[] { 137.5 }, //data index 55
tr);
FetchRequest tmpRequest = new FetchRequest("air", tmpDomain);
var handlerPrivate1 = new PrivateObject(regularHandler, new PrivateType(typeof(DataHandlerFacade)));
var aggregatorPrivate1 = new PrivateObject(handlerPrivate1, "valuesAggregator");
Assert.AreEqual(11.45, (double)(await(Task <Array>)(aggregatorPrivate1.Invoke("AggregateAsync", RequestContextStub.GetStub(regularStorage, tmpRequest), null))).GetValue(0), TestConstants.FloatPrecision); //manual data comparision
var gaussStorage = TestDataStorageFactory.GetStorageContext(TestConstants.UriReanalysisGauss);
NCEPReanalysisGaussT62GridDataHandler gaussHandler = await NCEPReanalysisGaussT62GridDataHandler.CreateAsync(gaussStorage);
ITimeRegion tr2 = new TimeRegion(firstYear: 1980, lastYear: 1980, firstDay: 1, lastDay: 1, startHour: 0, stopHour: 6); //index 46752 ; hours sice 1-1-1 00:00:00 = 17347536
IFetchDomain preDomain = FetchDomain.CreatePoints(
new double[] { 2.8571 }, // data index 45
new double[] { 178.125 }, //data index 95
tr2);
FetchRequest preRequest = new FetchRequest("prate", preDomain);
var handlerPrivate2 = new PrivateObject(gaussHandler, new PrivateType(typeof(DataHandlerFacade)));
var aggregatorPrivate2 = new PrivateObject(handlerPrivate2, "valuesAggregator");
//raw data value at [45,95,46752] is -32355
//scale_factor = 1E-07
//add_offset = 0.0032765
//aditional_scaling = 2592000
Assert.AreEqual(106.272, (double)(await(Task <Array>)(aggregatorPrivate2.Invoke("AggregateAsync", RequestContextStub.GetStub(gaussStorage, preRequest), null))).GetValue(0), 1e-3); //manual data comparision. 1e-3 precision as Data and scale_factor/add_offset are single
}
public static int[] GetDataArrayShape(this IFetchDomain domain)
{
List <int> timeDimsLengths = new List <int>(3);
if (domain.TimeRegion.YearsAxisLength > 1)
{
timeDimsLengths.Add(domain.TimeRegion.YearsAxisLength);
}
if (domain.TimeRegion.DaysAxisLength > 1)
{
timeDimsLengths.Add(domain.TimeRegion.DaysAxisLength);
}
if (domain.TimeRegion.HoursAxisLength > 1)
{
timeDimsLengths.Add(domain.TimeRegion.HoursAxisLength);
}
switch (domain.SpatialRegionType)
{
case SpatialRegionSpecification.Points:
case SpatialRegionSpecification.Cells:
return(new int[1] {
domain.Lats.Length
}.Concat(timeDimsLengths).ToArray());
case SpatialRegionSpecification.CellGrid:
return(new int[2] {
domain.Lons.Length - 1, domain.Lats.Length - 1
}.Concat(timeDimsLengths).ToArray());
case SpatialRegionSpecification.PointGrid:
return(new int[2] {
domain.Lons.Length, domain.Lats.Length
}.Concat(timeDimsLengths).ToArray());
default:
throw new Exception("Unknown spatial region type");
}
}
public async Task TestOutOfDataNan()
{
var storage = TestDataStorageFactory.GetStorageContext(TestConstants.UriHADCM3_sra_tas);
HADCM3DataHandler regularHandler = await HADCM3DataHandler.CreateAsync(storage);
TimeRegion tr = new TimeRegion(firstYear: 2301, lastYear: 2301, firstDay: 91, lastDay: 120, startHour: 0, stopHour: 24); //index 15 ; april out of data
IFetchDomain tmpDomain = FetchDomain.CreatePoints(
new double[] { -75.0 }, // data index 6,7
new double[] { 90.0 },
tr);
FetchRequest tmpRequest = new FetchRequest("tas", tmpDomain);
var handlerPrivate = new PrivateObject(regularHandler, new PrivateType(typeof(DataHandlerFacade)));
var evaluatorPrivate = new PrivateObject(handlerPrivate, "uncertaintyEvaluator");
var aggregatorPrivate = new PrivateObject(handlerPrivate, "valuesAggregator");
var res = await(Task <Array>)(evaluatorPrivate.Invoke("EvaluateAsync", RequestContextStub.GetStub(storage, tmpRequest)));
Assert.IsTrue(double.IsNaN((double)res.GetValue(0))); //uncertatinty is nan
res = await(Task <Array>)(aggregatorPrivate.Invoke("AggregateAsync", RequestContextStub.GetStub(storage, tmpRequest), null));
Assert.IsTrue(double.IsNaN((double)res.GetValue(0))); // and the value is nan
}
public async Task GhcnTempValuesTest()
{
System.Diagnostics.Trace.WriteLine(TestConstants.UriGHCN);
string etopoLocalUri = TestConstants.UriEtopo;
var ghcnStorage = TestDataStorageFactory.GetStorageContext(TestConstants.UriGHCN);
DataSourceHandler handler = await GHCNv2DataSource.DataHandler.CreateAsync(ghcnStorage);
ITimeRegion tr = new TimeRegion(firstYear: 1921, lastYear: 1921).GetMonthlyTimeseries(firstMonth: 3, lastMonth: 3); //data index 2642
IFetchDomain domain = FetchDomain.CreatePoints(
new double[] { 36.27 }, //exact station. data index 3776
new double[] { -90.97 },
tr);
FetchRequest tempRequest = new FetchRequest("temp", domain);
var reqContext = RequestContextStub.GetStub(ghcnStorage, tempRequest);
var result = await handler.ProcessRequestAsync(reqContext);
Assert.AreEqual(15.6, (double)result.GetValue(0), 1e-5); //manual data comparison.
}
public async Task ClusterizationTest()
{
var storage = TestDataStorageFactory.GetStorageContext(TestConstants.UriWorldClim);
WorldClim14DataSource worldClim = await WorldClim14DataSource.CreateAsync(storage);
ITimeRegion tr = new TimeRegion(firstYear: 1950, lastYear: 2010, firstDay: 1, lastDay: 31);
IFetchDomain domain = FetchDomain.CreatePoints(
//ocean region
new double[] { 53.1, 53.3, -22.8, 53.2 }, //data indeces 13572,13596,13584
new double[] { -116.0, -115.975, 124.8, -115.9 }, //data indeces 7680,7683,36576,7692
tr
);
FetchRequest request = new FetchRequest("tmean", domain);
var handlerPrivate = new PrivateObject(worldClim, new PrivateType(typeof(DataHandlerFacade)));
var aggregatorPrivate = new PrivateObject(handlerPrivate, "valuesAggregator");
var res = await(Task <Array>)(aggregatorPrivate.Invoke("AggregateAsync", RequestContextStub.GetStub(storage, request), null));
Assert.AreEqual(-13.3, (double)res.GetValue(0), 1e-2);
Assert.AreEqual(-13.3, (double)res.GetValue(1), 1e-2);
Assert.AreEqual(32.6, (double)res.GetValue(2), 1e-2);
Assert.AreEqual(-13.3, (double)res.GetValue(3), 1e-2);
}
public async Task CellGridDataLinearInterpolationTest()
{
var storage = TestDataStorageFactory.GetStorageContext(TestConstants.UriReanalysisRegular);
NCEPReanalysisRegularGridDataHandler reanalysis = await NCEPReanalysisRegularGridDataHandler.CreateAsync(storage);
ITimeRegion tr = new TimeRegion(firstYear: 1980, lastYear: 1980, firstDay: 2, lastDay: 3, startHour: 0, stopHour: 0).
GetSeasonlyTimeseries(firstDay: 2, lastDay: 3, isIntervalTimeseries: false);//indeces 46756,46760; hours sice 1-1-1 00:00:00 = 17347560 , 17347524
IFetchDomain domain = FetchDomain.CreateCellGrid(
//ocean region
new double[] { 5.0, 7.5, 10.0 }, //indeces 34,33,32
new double[] { 40.0, 42.5, 45, 47.5 }, //indeces 16,17,18,19
tr);
FetchRequest request = new FetchRequest("air", domain);
bool[,, ] mask = new bool[3, 2, 2];
bool[] smask = System.Linq.Enumerable.Repeat(true, 12).ToArray();
Buffer.BlockCopy(smask, 0, mask, 0, 12 * sizeof(bool));
var handlerPrivate = new PrivateObject(reanalysis, new PrivateType(typeof(DataHandlerFacade)));
var aggregatorPrivate = new PrivateObject(handlerPrivate, "valuesAggregator");
for (int i = 0; i < 2; i++)
{
bool[, ,] effectiveMask = i == 0 ? null : mask;
var result = await(Task <Array>)(aggregatorPrivate.Invoke("AggregateAsync", RequestContextStub.GetStub(storage, request), effectiveMask));
//lon,lat,t
double[, , ] t = (double[, , ])result;
Assert.AreEqual(12, t.Length);
Assert.AreEqual(3, t.GetLength(0));
Assert.AreEqual(2, t.GetLength(1));
//first time layer manual calculation
//SDS fetched data
//C:\Users\Dmitry>sds data "msds:az?name=ReanalysisRegular&DefaultEndpointsProl=http&AccountName=fetch&AccountKey=1Y0EOrnCX6ULY8c3iMHg9rrul2BWbPHKsHUceZ7ShM/q9K0ml49gQm+PE7G7i7zCvrpuT/vT1aHzEArutw==" air[32:34,16:19,46756]
//[32,16,46756] -22521
//[32,17,46756] -22091
//[32,18,46756] -22221
//[32,19,46756] -22291
//[33,16,46756] -22391
//[33,17,46756] -21861
//[33,18,46756] -21921
//[33,19,46756] -22021
//[34,16,46756] -21811
//[34,17,46756] -21421
//[34,18,46756] -21461
//[34,19,46756] -21541
//excel calculated values x*0.01+239.66 mean
//-22521 -22091 -22221 -22291 14.45 18.75 17.45 16.75 17.5 19.425 18.525
//-22391 -21861 -21921 -22021 15.75 21.05 20.45 19.45 20.95 23 22.3
//-21811 -21421 -21461 -21541 21.55 25.45 25.05 24.25
//checking first time layer
//ATTENTION: notice the lat indexing. it is flaped!
//lon,lat,t
A(17.5, t[0, 1, 0]); A(19.425, t[1, 1, 0]); A(18.525, t[2, 1, 0]);
A(20.95, t[0, 0, 0]); A(23, t[1, 0, 0]); A(22.3, t[2, 0, 0]);
//second time layer asserting
//SDS data fetching
//lon,lat,t
//C:\Users\Dmitry>sds data "msds:az?name=ReanalysisRegular&DefaultEndpointsProl=http&AccountName=fetch&AccountKey=1Y0EOrnCX6ULY8c3iMHg9rrul2BWbPHKsHUceZ7ShM/q9K0ml49gQm+PE7G7i7zCvrpuT/vT1aHzEArutw==" air[32:34,16:19,46760]
//[32,16,46760] -22761
//[32,17,46760] -22071
//[32,18,46760] -22201
//[32,19,46760] -22391
//[33,16,46760] -22571
//[33,17,46760] -21911
//[33,18,46760] -21961
//[33,19,46760] -22111
//[34,16,46760] -21891
//[34,17,46760] -21601
//[34,18,46760] -21611
//[34,19,46760] -21631
//excel calculated values x*0.01+239.66 mean
//-22761 -22071 -22201 -22391 12.05 18.95 17.65 15.75 16.375 19.3 18
//-22571 -21911 -21961 -22111 13.95 20.55 20.05 18.55 19.725 21.95 21.375
//-21891 -21601 -21611 -21631 20.75 23.65 23.55 23.35
//checking second time layer
//ATTENTION: notice the lat indexing. it is flaped!
//lon,lat,t
A(16.375, t[0, 1, 1]); A(19.3, t[1, 1, 1]); A(18, t[2, 1, 1]);
A(19.725, t[0, 0, 1]); A(21.95, t[1, 0, 1]); A(21.375, t[2, 0, 1]);
}
}
/// <summary>
/// Check for validness of request content. e.g coordinate ranges, ascending of time axes
/// </summary>
/// <returns></returns>
public static bool IsContentValid(this IFetchDomain domain, out string errorMessage)
{
StringBuilder sb = new StringBuilder();
bool valid = true;
if (domain.Lats == null)
{
sb.AppendLine("Latitude bounds are not specified");
valid = false;
}
if (domain.Lons == null)
{
sb.AppendLine("Longitude bounds are not specified");
valid = false;
}
for (int i = 0; i < domain.Lats.Length; i++)
{
if (domain.Lats[i] > 90.0 || domain.Lats[i] < -90.0)
{
sb.AppendLine("One of the latitudes are out of bounds -90 .. 90");
valid = false;
break;
}
}
for (int i = 0; i < domain.Lons.Length; i++)
{
if (domain.Lons[i] > 360.0 || domain.Lons[i] < -180.0)
{
sb.AppendLine("One of the longitudes are out of bounds -180 .. 360");
valid = false;
break;
}
}
if (domain.SpatialRegionType == SpatialRegionSpecification.PointGrid || domain.SpatialRegionType == SpatialRegionSpecification.CellGrid)
{
for (int i = 0; i < domain.Lats.Length - 1; i++)
{
if (domain.Lats[i] > domain.Lats[i + 1])
{
sb.AppendLine("Latitude axis doesn't ascend");
valid = false;
break;
}
}
for (int i = 0; i < domain.Lons.Length - 1; i++)
{
if (domain.Lons[i] > domain.Lons[i + 1])
{
sb.AppendLine("Longitude axis doesn't ascend");
valid = false;
break;
}
}
}
if (domain.SpatialRegionType == SpatialRegionSpecification.Cells)
{
//checking cells grid
if (domain.Lats2 != null)
{
for (int i = 0; i < domain.Lats2.Length; i++)
{
if (domain.Lats2[i] < domain.Lats[i])
{
sb.AppendLine("Cells upper latitude bounds are lower that lower bounds");
valid = false;
break;
}
}
}
if (domain.Lons2 != null)
{
for (int i = 0; i < domain.Lons2.Length; i++)
{
if (domain.Lons2[i] < domain.Lons[i])
{
sb.AppendLine("Cells upper longitude bounds are lower that lower bounds");
valid = false;
break;
}
}
}
}
if (domain.TimeRegion.Days == null)
{
sb.AppendLine("Days bounds are not specified");
valid = false;
}
else
{
for (int i = 0; i < domain.TimeRegion.Days.Length - 1; i++)
{
if (domain.TimeRegion.Days[i] >= domain.TimeRegion.Days[i + 1])
{
sb.AppendLine("Days axis doesn't not ascend");
valid = false;
break;
}
}
int maxDayAllowed = domain.TimeRegion.IsIntervalsGridDays ? 367 : 366;
for (int i = 0; i < domain.TimeRegion.Days.Length; i++)
{
if (domain.TimeRegion.Days[i] < 1 || domain.TimeRegion.Days[i] > maxDayAllowed)
{
sb.AppendLine("One of the days specified is outside 1 .. 366 interval");
valid = false;
break;
}
}
}
if (domain.TimeRegion.Hours == null)
{
sb.AppendLine("Hours bounds are not specified");
valid = false;
}
else
{
for (int i = 0; i < domain.TimeRegion.Hours.Length - 1; i++)
{
if (domain.TimeRegion.Hours[i] >= domain.TimeRegion.Hours[i + 1])
{
sb.AppendLine("Hours axis doesn't not ascend");
valid = false;
break;
}
}
for (int i = 0; i < domain.TimeRegion.Hours.Length; i++)
{
if (domain.TimeRegion.Hours[i] < 0 || domain.TimeRegion.Hours[i] > 24)
{
sb.AppendLine("One of the hours specified is outside 0 .. 24 interval");
valid = false;
break;
}
}
}
if (domain.TimeRegion.Years == null)
{
sb.AppendLine("Years bounds are not specified");
valid = false;
}
else
{
for (int i = 0; i < domain.TimeRegion.Years.Length - 1; i++)
{
if (domain.TimeRegion.Years[i] >= domain.TimeRegion.Years[i + 1])
{
sb.AppendLine("Years axis doesn't not ascend");
valid = false;
break;
}
}
}
errorMessage = sb.ToString();
return(valid);
}
