public async Task LinearWeightsContextFactoryFacadeTest()
{
var lwcff = new LinearWeightsContextFactoryFacade <RealValueNodesStub>(new Stub4(), new Stub3());
var cells = new GeoCellTuple[] { new GeoCellTuple()
{
LatMax = 11.0, LonMin = 13.0, LatMin = 17.0, LonMax = 19.0
} };
var request = new FetchRequest("dummy", FetchDomain.CreateCells(new double[] { 17.0 }, new double[] { 13.0 }, new double[] { 11.0 }, new double[] { 19.0 }, new TimeRegion()));
var storage = TestDataStorageFactory.GetStorage("msds:memory");
var requestContext = RequestContextStub.GetStub(storage, request);
var lwc = await lwcff.CreateAsync(requestContext, cells);
var combs = lwc.Combinations.ToArray();
Assert.AreEqual(1, combs.Length);
Assert.AreEqual(cells[0], combs[0].Item1);
RealValueNodes nodes = combs[0].Item2;
IEnumerable <LinearWeight> weights = combs[0].Item3;
var result = weights.Sum(w => w.Weight * nodes.Values[w.DataIndex]);
Assert.AreEqual(847.0, result);
}
public void PartsCountingInSingleDimensionalRequestTest()
{
var tr = new TimeRegion(firstYear: 1990, lastYear: 2001);
var request = new FetchRequest(
"pet",
FetchDomain.CreatePoints(
Enumerable.Range(0, 1500).Select(i => 5.0 + i * 0.1).ToArray(), // 5.0 .. 20.0
Enumerable.Range(0, 1500).Select(i => 70.0 + i * 0.1).ToArray(),
tr));
// 1500 pts in this request
Assert.AreEqual(3, JobManager.GetPartitionsCount(request, 0, 10000, 20));
Assert.AreEqual(1, JobManager.GetPartitionsCount(request, 1000, 10000, 310));
var request2 = new FetchRequest(
"pet",
FetchDomain.CreateCells(
Enumerable.Range(0, 15000).Select(i => 5.0 + i * 0.1).ToArray(),
Enumerable.Range(0, 15000).Select(i => 70.0 + i * 0.1).ToArray(),
Enumerable.Range(0, 15000).Select(i => 6.0 + i * 0.1).ToArray(),
Enumerable.Range(0, 15000).Select(i => 71.0 + i * 0.1).ToArray(),
tr));
//15000 cells
Assert.AreEqual(30, JobManager.GetPartitionsCount(request2, 0, 10000, 102));
Assert.AreEqual(15, JobManager.GetPartitionsCount(request2, 0, 10000, 20));
Assert.AreEqual(15, JobManager.GetPartitionsCount(request2, 1000, 10000, 102));
}
public void GHCNplaneInterpolationCellTest()
{
//with lapse rate correction
FetchDomain fd = FetchDomain.CreateCells(new double[] { 1.5 }, new double[] { 1.0 }, new double[] { 1.6 }, new double[] { 1.1 }, new TimeRegion(firstYear: 1970, lastYear: 1970, firstDay: 91, lastDay: 120)); //april
FetchRequest fr = new FetchRequest("temp", fd);
GhcnPlaneStorageContext storage = new GhcnPlaneStorageContext(fr);
GHCNDataHandler sotdh = new GHCNDataHandler(storage);
var compCont = new ComputationalContext();
var evRes = sotdh.EvaluateAsync(storage, compCont).Result;
var result = (double[])sotdh.AggregateAsync(storage, compCont).Result;
Assert.AreEqual(-7.0, result[0], TestConstants.DoublePrecision);
//without lapse rate correction
fd = FetchDomain.CreateCells(new double[] { -2.5 }, new double[] { 1.0 }, new double[] { -2.4 }, new double[] { 1.1 }, new TimeRegion(firstYear: 1970, lastYear: 1970, firstDay: 91, lastDay: 120)); //april
fr = new FetchRequest("temp", fd);
storage = new GhcnPlaneStorageContext(fr);
sotdh = new GHCNDataHandler(storage);
compCont = new ComputationalContext();
evRes = sotdh.EvaluateAsync(storage, compCont).Result;
result = (double[])sotdh.AggregateAsync(storage, compCont).Result;
Assert.AreEqual(-6.0, result[0], TestConstants.DoublePrecision);
}
private FetchDomain CreateCellsDomain(TimeRegion tr)
{
var eps = r.NextDouble() / 10.0;
Trace.WriteLine(String.Format("Using eps={0}", eps));
return(FetchDomain.CreateCells(
new double[] { BayOfBiscaySELat + eps, InFranceLat + eps },
new double[] { BayOfBiscaySELon + eps, InFranceLon + eps },
new double[] { BayOfBiscaySELat + 1.0 + eps, InFranceLat + 1.0 + eps },
new double[] { BayOfBiscaySELon + 1.0 + eps, InFranceLon + 1.0 + eps },
tr));
}
public async Task MonthlyMeansLandOnlyVariablesTest()
{
var storage = TestDataStorageFactory.GetStorage(TestConstants.UriCru);
CruCl20DataHandler cru = await CruCl20DataHandler.CreateAsync(storage);
TimeRegion tr = new TimeRegion().GetMonthlyTimeseries(firstMonth: 1, lastMonth: 1);
FetchDomain oceanDomain = FetchDomain.CreateCells(
new double[] { 22.0 },
new double[] { -25.0 },
new double[] { 23.0 },
new double[] { -24.0 },
tr);
FetchDomain landDomain = FetchDomain.CreateCells(
new double[] { 24.0 },
new double[] { -10.0 },
new double[] { 25.0 },
new double[] { -9.0 },
tr);
FetchDomain 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));
Assert.AreEqual(mixVal, landVal, TestConstants.DoublePrecision);
}
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 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 MonthlyMeansOutOfDataTest()
{
var storage = TestDataStorageFactory.GetStorageContext(TestConstants.UriCru);
CruCl20DataHandler cru = await CruCl20DataHandler.CreateAsync(storage);
ITimeRegion tr = new TimeRegion().GetMonthlyTimeseries(firstMonth: 1, lastMonth: 1);
IFetchDomain[] outOfDataDomain = new FetchDomain[2];
outOfDataDomain[0] = FetchDomain.CreateCells( //below the data
new double[] { -70.0 },
new double[] { -25.0 },
new double[] { -68.0 },
new double[] { -24.0 },
tr);
outOfDataDomain[1] = FetchDomain.CreateCells( //above the data
new double[] { 85.0 },
new double[] { -25.0 },
new double[] { 87.0 },
new double[] { -24.0 },
tr);
var handlerPrivate = new PrivateObject(cru, new PrivateType(typeof(DataHandlerFacade)));
var evaluatorPrivate = new PrivateObject(handlerPrivate, "uncertaintyEvaluator");
var aggregatorPrivate = new PrivateObject(handlerPrivate, "valuesAggregator");
for (int i = 0; i < 2; i++)
{
FetchRequest outOfDataRequest = new FetchRequest("pre", outOfDataDomain[i]);
double unc = (double)(await(Task <Array>)(evaluatorPrivate.Invoke("EvaluateAsync", RequestContextStub.GetStub(storage, outOfDataRequest)))).GetValue(0);
double val = (double)(await(Task <Array>)(aggregatorPrivate.Invoke("AggregateAsync", RequestContextStub.GetStub(storage, outOfDataRequest), null))).GetValue(0);
Assert.IsTrue(double.IsNaN(val));
Assert.IsTrue(double.IsNaN(unc));
}
}
public void SingleDimensionalRequestPartitioningTest()
{
var tr = new TimeRegion(firstYear: 1990, lastYear: 2001);
var request = new FetchRequest(
"pet",
FetchDomain.CreatePoints(
Enumerable.Range(0, 1500).Select(i => 5.0 + i * 0.1).ToArray(), // 5.0 .. 20.0
Enumerable.Range(0, 1500).Select(i => 70.0 + i * 0.1).ToArray(),
tr));
var guess0 = JobManager.EvaluateSubrequestData(request, 3, 0);
var guess1 = JobManager.EvaluateSubrequestData(request, 3, 1);
var guess2 = JobManager.EvaluateSubrequestData(request, 3, 2);
Assert.AreEqual(512, guess0.Item1.Domain.Lats.Length);
Assert.AreEqual(512, guess1.Item1.Domain.Lats.Length);
Assert.AreEqual(476, guess2.Item1.Domain.Lats.Length);
Assert.AreEqual(512, guess0.Item1.Domain.Lons.Length);
Assert.AreEqual(512, guess1.Item1.Domain.Lons.Length);
Assert.AreEqual(476, guess2.Item1.Domain.Lons.Length);
for (int i = 0; i < 512; ++i)
{
Assert.AreEqual(request.Domain.Lats[i], guess0.Item1.Domain.Lats[i], TestConstants.DoublePrecision);
}
for (int i = 0; i < 512; ++i)
{
Assert.AreEqual(request.Domain.Lats[i + 512], guess1.Item1.Domain.Lats[i], TestConstants.DoublePrecision);
}
for (int i = 0; i < 476; ++i)
{
Assert.AreEqual(request.Domain.Lats[i + 1024], guess2.Item1.Domain.Lats[i], TestConstants.DoublePrecision);
}
for (int i = 0; i < 512; ++i)
{
Assert.AreEqual(request.Domain.Lons[i], guess0.Item1.Domain.Lons[i], TestConstants.DoublePrecision);
}
for (int i = 0; i < 512; ++i)
{
Assert.AreEqual(request.Domain.Lons[i + 512], guess1.Item1.Domain.Lons[i], TestConstants.DoublePrecision);
}
for (int i = 0; i < 476; ++i)
{
Assert.AreEqual(request.Domain.Lons[i + 1024], guess2.Item1.Domain.Lons[i], TestConstants.DoublePrecision);
}
var request2 = new FetchRequest(
"pet",
FetchDomain.CreateCells(
Enumerable.Range(0, 1500).Select(i => 5.0 + i * 0.1).ToArray(),
Enumerable.Range(0, 1500).Select(i => 70.0 + i * 0.1).ToArray(),
Enumerable.Range(0, 1500).Select(i => 6.0 + i * 0.1).ToArray(),
Enumerable.Range(0, 1500).Select(i => 71.0 + i * 0.1).ToArray(),
tr));
var guess10 = JobManager.EvaluateSubrequestData(request, 3, 0);
var guess11 = JobManager.EvaluateSubrequestData(request, 3, 1);
var guess12 = JobManager.EvaluateSubrequestData(request, 3, 2);
Assert.AreEqual(512, guess10.Item1.Domain.Lats.Length);
Assert.AreEqual(512, guess11.Item1.Domain.Lats.Length);
Assert.AreEqual(476, guess12.Item1.Domain.Lats.Length);
Assert.AreEqual(512, guess10.Item1.Domain.Lons.Length);
Assert.AreEqual(512, guess11.Item1.Domain.Lons.Length);
Assert.AreEqual(476, guess12.Item1.Domain.Lons.Length);
for (int i = 0; i < 512; ++i)
{
Assert.AreEqual(request2.Domain.Lats[i], guess10.Item1.Domain.Lats[i], TestConstants.DoublePrecision);
}
for (int i = 0; i < 512; ++i)
{
Assert.AreEqual(request2.Domain.Lats[i + 512], guess11.Item1.Domain.Lats[i], TestConstants.DoublePrecision);
}
for (int i = 0; i < 476; ++i)
{
Assert.AreEqual(request2.Domain.Lats[i + 1024], guess12.Item1.Domain.Lats[i], TestConstants.DoublePrecision);
}
for (int i = 0; i < 512; ++i)
{
Assert.AreEqual(request2.Domain.Lons[i], guess10.Item1.Domain.Lons[i], TestConstants.DoublePrecision);
}
for (int i = 0; i < 512; ++i)
{
Assert.AreEqual(request2.Domain.Lons[i + 512], guess11.Item1.Domain.Lons[i], TestConstants.DoublePrecision);
}
for (int i = 0; i < 476; ++i)
{
Assert.AreEqual(request2.Domain.Lons[i + 1024], guess12.Item1.Domain.Lons[i], TestConstants.DoublePrecision);
}
}
public void SubrequestExtractionTest()
{
var tr = new TimeRegion(firstYear: 2000, lastYear: 2001).GetMonthlyTimeseries();
var request = new FetchRequest(
"pet",
FetchDomain.CreatePointGrid(
Enumerable.Range(0, 150).Select(i => 5.0 + i * 0.1).ToArray(), // 5.0 .. 20.0
Enumerable.Range(0, 170).Select(i => 70.0 + i * 0.1).ToArray(),
tr),
new DateTime(2013, 11, 17));
//let's divide it into 31 part
// 170 / 31 = 5
// 170 % 31 = 15
//so we gotta get 15 parts 6 points wide and 16 parts 5 points wide
var answer1 = new FetchRequest(
"pet",
FetchDomain.CreatePointGrid(
Enumerable.Range(0, 150).Select(i => 5.0 + i * 0.1).ToArray(), // 5.0 .. 20.0
Enumerable.Range(0, 6).Select(i => 70.0 + i * 0.1).ToArray(),
tr),
new DateTime(2013, 11, 17));
var answer15 = new FetchRequest(
"pet",
FetchDomain.CreatePointGrid(
Enumerable.Range(0, 150).Select(i => 5.0 + i * 0.1).ToArray(), // 5.0 .. 20.0
Enumerable.Range(0, 6).Select(i => 78.4 + i * 0.1).ToArray(),
tr),
new DateTime(2013, 11, 17));
var answer16 = new FetchRequest(
"pet",
FetchDomain.CreatePointGrid(
Enumerable.Range(0, 150).Select(i => 5.0 + i * 0.1).ToArray(), // 5.0 .. 20.0
Enumerable.Range(0, 5).Select(i => 79.0 + i * 0.1).ToArray(),
tr),
new DateTime(2013, 11, 17));
var answer31 = new FetchRequest(
"pet",
FetchDomain.CreatePointGrid(
Enumerable.Range(0, 150).Select(i => 5.0 + i * 0.1).ToArray(), // 5.0 .. 20.0
Enumerable.Range(0, 5).Select(i => 86.5 + i * 0.1).ToArray(),
tr),
new DateTime(2013, 11, 17));
var guess1 = JobManager.EvaluateSubrequestData(request, 31, 0);
var guess15 = JobManager.EvaluateSubrequestData(request, 31, 14);
var guess16 = JobManager.EvaluateSubrequestData(request, 31, 15);
var guess31 = JobManager.EvaluateSubrequestData(request, 31, 30);
Assert.AreEqual(answer1.EnvironmentVariableName, guess1.Item1.EnvironmentVariableName);
Assert.AreEqual(answer1.ParticularDataSource, guess1.Item1.ParticularDataSource);
Assert.AreEqual(answer1.ReproducibilityTimestamp, guess1.Item1.ReproducibilityTimestamp);
Assert.AreEqual(answer1.Domain.SpatialRegionType, guess1.Item1.Domain.SpatialRegionType);
Assert.AreEqual(answer15.EnvironmentVariableName, guess15.Item1.EnvironmentVariableName);
Assert.AreEqual(answer15.ParticularDataSource, guess15.Item1.ParticularDataSource);
Assert.AreEqual(answer15.ReproducibilityTimestamp, guess15.Item1.ReproducibilityTimestamp);
Assert.AreEqual(answer15.Domain.SpatialRegionType, guess15.Item1.Domain.SpatialRegionType);
Assert.AreEqual(answer16.EnvironmentVariableName, guess16.Item1.EnvironmentVariableName);
Assert.AreEqual(answer16.ParticularDataSource, guess16.Item1.ParticularDataSource);
Assert.AreEqual(answer16.ReproducibilityTimestamp, guess16.Item1.ReproducibilityTimestamp);
Assert.AreEqual(answer16.Domain.SpatialRegionType, guess16.Item1.Domain.SpatialRegionType);
Assert.AreEqual(answer31.EnvironmentVariableName, guess31.Item1.EnvironmentVariableName);
Assert.AreEqual(answer31.ParticularDataSource, guess31.Item1.ParticularDataSource);
Assert.AreEqual(answer31.ReproducibilityTimestamp, guess31.Item1.ReproducibilityTimestamp);
Assert.AreEqual(answer31.Domain.SpatialRegionType, guess31.Item1.Domain.SpatialRegionType);
for (int i = 0; i < answer1.Domain.Lats.Length; ++i)
{
Assert.AreEqual(answer1.Domain.Lats[i], guess1.Item1.Domain.Lats[i], TestConstants.DoublePrecision);
}
for (int i = 0; i < answer1.Domain.Lons.Length; ++i)
{
Assert.AreEqual(answer1.Domain.Lons[i], guess1.Item1.Domain.Lons[i], TestConstants.DoublePrecision);
}
for (int i = 0; i < answer15.Domain.Lats.Length; ++i)
{
Assert.AreEqual(answer15.Domain.Lats[i], guess15.Item1.Domain.Lats[i], TestConstants.DoublePrecision);
}
for (int i = 0; i < answer15.Domain.Lons.Length; ++i)
{
Assert.AreEqual(answer15.Domain.Lons[i], guess15.Item1.Domain.Lons[i], TestConstants.DoublePrecision);
}
for (int i = 0; i < answer16.Domain.Lats.Length; ++i)
{
Assert.AreEqual(answer16.Domain.Lats[i], guess16.Item1.Domain.Lats[i], TestConstants.DoublePrecision);
}
for (int i = 0; i < answer16.Domain.Lons.Length; ++i)
{
Assert.AreEqual(answer16.Domain.Lons[i], guess16.Item1.Domain.Lons[i], TestConstants.DoublePrecision);
}
for (int i = 0; i < answer31.Domain.Lats.Length; ++i)
{
Assert.AreEqual(answer31.Domain.Lats[i], guess31.Item1.Domain.Lats[i], TestConstants.DoublePrecision);
}
for (int i = 0; i < answer31.Domain.Lons.Length; ++i)
{
Assert.AreEqual(answer31.Domain.Lons[i], guess31.Item1.Domain.Lons[i], TestConstants.DoublePrecision);
}
Assert.AreEqual(0, guess1.Item2[0]);
Assert.AreEqual(84, guess15.Item2[0]);
Assert.AreEqual(90, guess16.Item2[0]);
Assert.AreEqual(165, guess31.Item2[0]);
var request2 = new FetchRequest(
"pet",
FetchDomain.CreateCellGrid(
Enumerable.Range(0, 150).Select(i => 5.0 + i * 0.1).ToArray(), // 5.0 .. 20.0
Enumerable.Range(0, 171).Select(i => 70.0 + i * 0.1).ToArray(),
tr),
new DateTime(2013, 11, 17));
var answer115 = new FetchRequest(
"pet",
FetchDomain.CreatePointGrid(
Enumerable.Range(0, 150).Select(i => 5.0 + i * 0.1).ToArray(), // 5.0 .. 20.0
Enumerable.Range(0, 7).Select(i => 78.4 + i * 0.1).ToArray(),
tr),
new DateTime(2013, 11, 17));
var answer116 = new FetchRequest(
"pet",
FetchDomain.CreatePointGrid(
Enumerable.Range(0, 150).Select(i => 5.0 + i * 0.1).ToArray(), // 5.0 .. 20.0
Enumerable.Range(0, 6).Select(i => 79.0 + i * 0.1).ToArray(),
tr),
new DateTime(2013, 11, 17));
var guess115 = JobManager.EvaluateSubrequestData(request2, 31, 14);
var guess116 = JobManager.EvaluateSubrequestData(request2, 31, 15);
for (int i = 0; i < answer115.Domain.Lats.Length; ++i)
{
Assert.AreEqual(answer115.Domain.Lats[i], guess115.Item1.Domain.Lats[i], TestConstants.DoublePrecision);
}
for (int i = 0; i < answer115.Domain.Lons.Length; ++i)
{
Assert.AreEqual(answer115.Domain.Lons[i], guess115.Item1.Domain.Lons[i], TestConstants.DoublePrecision);
}
for (int i = 0; i < answer116.Domain.Lats.Length; ++i)
{
Assert.AreEqual(answer116.Domain.Lats[i], guess116.Item1.Domain.Lats[i], TestConstants.DoublePrecision);
}
for (int i = 0; i < answer116.Domain.Lons.Length; ++i)
{
Assert.AreEqual(answer116.Domain.Lons[i], guess116.Item1.Domain.Lons[i], TestConstants.DoublePrecision);
}
var tr2 = new TimeRegion(1990, 2000, 1, -1, 0, 24).GetYearlyTimeseries(1990, 2000);
var request3 = new FetchRequest(
"airt",
FetchDomain.CreateCells(
new double[] { 3.0 },
new double[] { 78.0 },
new double[] { 23.0 },
new double[] { 99.0 },
tr2));
var guess117 = JobManager.EvaluateSubrequestData(request3, 1, 0);
for (int i = 0; i < request3.Domain.Lats.Length; ++i)
{
Assert.AreEqual(request3.Domain.Lats[i], guess117.Item1.Domain.Lats[i], TestConstants.DoublePrecision);
}
for (int i = 0; i < request3.Domain.Lons.Length; ++i)
{
Assert.AreEqual(request3.Domain.Lons[i], guess117.Item1.Domain.Lons[i], TestConstants.DoublePrecision);
}
for (int i = 0; i < request3.Domain.Lats2.Length; ++i)
{
Assert.AreEqual(request3.Domain.Lats2[i], guess117.Item1.Domain.Lats2[i], TestConstants.DoublePrecision);
}
for (int i = 0; i < request3.Domain.Lons2.Length; ++i)
{
Assert.AreEqual(request3.Domain.Lons2[i], guess117.Item1.Domain.Lons2[i], TestConstants.DoublePrecision);
}
}
public void TestParameterIgnoringProvenance(ClimateParameter p, EnvironmentalDataSource ds)
{
ClimateService.ServiceUrl = "http://fetchclimate2.cloudapp.net/";
const double MoscowLat = 55.7;
const double MoscowLon = 37.5;
const double PacificLat = -20;
const double PacificLon = 170;
const double PacificLatA = -15;
const double PacificLonA = 175;
const double KrasnoyarskLat = 56.017;
const double KrasnoyarskLon = 92.867;
const double AroundKrasnoyarskLatMin = 55;
const double AroundKrasnoyarskLonMin = 91;
const double AroundKrasnoyarskLatMax = 60;
const double AroundKrasnoyarskLonMax = 95;
const double SriLankaLatMin = 5;
const double SriLankaLonMin = 70;
const double SriLankaLatMax = 20;
const double SriLankaLonMax = 87;
string varName = ClimateService.ClimateParameterToFC2VariableName(p);
Assert.AreNotEqual("", varName, string.Format("Mapping for {0} does not exist.", p.ToString()));
string[] sources = ClimateService.EnvironmentalDataSourceToArrayOfFC2DataSources(ds);
//Single point fetch
var tr1 = new TimeRegion(1961, 1990);
var tr2 = new TimeRegion(1990, 2000);
//Moscow
var request1 = new FetchRequest(
varName,
FetchDomain.CreatePoints(
new double[] { MoscowLat },
new double[] { MoscowLon },
tr1),
sources);
var result1 = ClimateService.FetchAsync(request1).Result;
double sd1 = ((double[])result1["sd"].GetData())[0];
double value1 = ((double[])result1["values"].GetData())[0];
Assert.AreEqual(sd1, ClimateService.FetchClimateUncertainty(p, MoscowLat, MoscowLat, MoscowLon, MoscowLon, dataSource: ds));
Assert.AreEqual(value1, ClimateService.FetchClimate(p, MoscowLat, MoscowLat, MoscowLon, MoscowLon, dataSource: ds));
//somewhere in Pacific Ocean
var request2 = new FetchRequest(
varName,
FetchDomain.CreatePoints(
new double[] { PacificLat },
new double[] { PacificLon },
tr1),
sources);
var result2 = ClimateService.FetchAsync(request2).Result;
double sd2 = ((double[])result2["sd"].GetData())[0];
double value2 = ((double[])result2["values"].GetData())[0];
Assert.AreEqual(sd2, ClimateService.FetchClimateUncertainty(p, PacificLat, PacificLat, PacificLon, PacificLon, dataSource: ds));
Assert.AreEqual(value2, ClimateService.FetchClimate(p, PacificLat, PacificLat, PacificLon, PacificLon, dataSource: ds));
//Cell around Krasnoyarsk
var request3 = new FetchRequest(
varName,
FetchDomain.CreateCells(
new double[] { AroundKrasnoyarskLatMin },
new double[] { AroundKrasnoyarskLonMin },
new double[] { AroundKrasnoyarskLatMax },
new double[] { AroundKrasnoyarskLonMax },
tr2),
sources);
var result3 = ClimateService.FetchAsync(request3).Result;
double sd3 = ((double[])result3["sd"].GetData())[0];
double value3 = ((double[])result3["values"].GetData())[0];
Assert.AreEqual(sd3, ClimateService.FetchClimateUncertainty(p, AroundKrasnoyarskLatMin, AroundKrasnoyarskLatMax, AroundKrasnoyarskLonMin, AroundKrasnoyarskLonMax, startyear: 1990, stopyear: 2000, dataSource: ds));
Assert.AreEqual(value3, ClimateService.FetchClimate(p, AroundKrasnoyarskLatMin, AroundKrasnoyarskLatMax, AroundKrasnoyarskLonMin, AroundKrasnoyarskLonMax, startyear: 1990, stopyear: 2000, dataSource: ds));
//Cell somewhere in Pacific Ocean
var request4 = new FetchRequest(
varName,
FetchDomain.CreateCells(
new double[] { PacificLat },
new double[] { PacificLon },
new double[] { PacificLatA },
new double[] { PacificLonA },
tr2),
sources);
var result4 = ClimateService.FetchAsync(request4).Result;
double sd4 = ((double[])result4["sd"].GetData())[0];
double value4 = ((double[])result4["values"].GetData())[0];
Assert.AreEqual(sd4, ClimateService.FetchClimateUncertainty(p, PacificLat, PacificLatA, PacificLon, PacificLonA, startyear: 1990, stopyear: 2000, dataSource: ds));
Assert.AreEqual(value4, ClimateService.FetchClimate(p, PacificLat, PacificLatA, PacificLon, PacificLonA, startyear: 1990, stopyear: 2000, dataSource: ds));
//batch request
double[] batchLonMin = new double[] { PacificLon, AroundKrasnoyarskLonMin };
double[] batchLonMax = new double[] { PacificLon, AroundKrasnoyarskLonMax };
double[] batchLatMin = new double[] { PacificLat, AroundKrasnoyarskLatMin };
double[] batchLatMax = new double[] { PacificLat, AroundKrasnoyarskLatMax };
int[] batchStartYear = new int[] { 1961, 1990 };
int[] batchStopYear = new int[] { 1990, 2000 };
double[] sdGuess1 = ClimateService.FetchClimateUncertainty(p, batchLatMin, batchLatMax, batchLonMin, batchLonMax, null, null, null, null, batchStartYear, batchStopYear, ds);
double[] valueGuess1 = ClimateService.FetchClimate(p, batchLatMin, batchLatMax, batchLonMin, batchLonMax, null, null, null, null, batchStartYear, batchStopYear, ds);
Assert.AreEqual(sd2, sdGuess1[0]);
Assert.AreEqual(sd3, sdGuess1[1]);
Assert.AreEqual(value2, valueGuess1[0]);
Assert.AreEqual(value3, valueGuess1[1]);
//grid request
var request5 = new FetchRequest(
varName,
FetchDomain.CreateCellGrid(
Enumerable.Range(0, (int)Math.Round((SriLankaLatMax - SriLankaLatMin) / 1) + 1).Select(i => SriLankaLatMin + i).ToArray(),
Enumerable.Range(0, (int)Math.Round((SriLankaLonMax - SriLankaLonMin) / 1) + 1).Select(i => SriLankaLonMin + i).ToArray(),
tr2),
sources);
var result5 = ClimateService.FetchAsync(request5).Result;
double[,] gridSds = (double[, ])result5["sd"].GetData();
double[,] gridValues = (double[, ])result5["values"].GetData();
int len0 = gridSds.GetLength(0), len1 = gridSds.GetLength(1);
double[,] sdGuess2 = ClimateService.FetchUncertaintyGrid(p, SriLankaLatMin, SriLankaLatMax, SriLankaLonMin, SriLankaLonMax, 1, 1, yearmin: 1990, yearmax: 2000, dataSource: ds);
double[,] valueGuess2 = ClimateService.FetchClimateGrid(p, SriLankaLatMin, SriLankaLatMax, SriLankaLonMin, SriLankaLonMax, 1, 1, yearmin: 1990, yearmax: 2000, dataSource: ds);
//in FC2 grid is lon x lat while in FC1 it was lat x lon
Assert.AreEqual(len0, sdGuess2.GetLength(1));
Assert.AreEqual(len1, sdGuess2.GetLength(0));
Assert.AreEqual(len0, valueGuess2.GetLength(1));
Assert.AreEqual(len1, valueGuess2.GetLength(0));
for (int i = 0; i < len0; ++i)
{
for (int j = 0; j < len1; ++j)
{
Assert.AreEqual(gridSds[i, j], sdGuess2[j, i]);
Assert.AreEqual(gridValues[i, j], valueGuess2[j, i]);
}
}
//Yearly TimeSeries for Krasnoyarsk
var tr3 = new TimeRegion().GetYearlyTimeseries(1990, 2000);
var request6 = new FetchRequest(
varName,
FetchDomain.CreatePoints(
new double[] { KrasnoyarskLat },
new double[] { KrasnoyarskLon },
tr3),
sources);
var result6 = ClimateService.FetchAsync(request6).Result;
double[,] seriesSds1 = (double[, ])result6["sd"].GetData();
double[,] seriesValues1 = (double[, ])result6["values"].GetData();
double[] seriesSdsGuess1 = ClimateService.FetchClimateYearlyUncertainty(p, KrasnoyarskLat, KrasnoyarskLat, KrasnoyarskLon, KrasnoyarskLon, yearmin: 1990, yearmax: 2000, dataSource: ds);
double[] seriesValuesGuess1 = ClimateService.FetchClimateYearly(p, KrasnoyarskLat, KrasnoyarskLat, KrasnoyarskLon, KrasnoyarskLon, yearmin: 1990, yearmax: 2000, dataSource: ds);
Assert.AreEqual(seriesSds1.Length, seriesSdsGuess1.Length);
Assert.AreEqual(seriesValues1.Length, seriesValuesGuess1.Length);
for (int i = 0; i < seriesValues1.Length; ++i)
{
Assert.AreEqual(seriesSds1[0, i], seriesSdsGuess1[i]);
Assert.AreEqual(seriesValues1[0, i], seriesValuesGuess1[i]);
}
//Monthly TimeSeries for Krasnoyarsk
var tr4 = new TimeRegion(1990, 1991).GetSeasonlyTimeseries(30, 40);
var request7 = new FetchRequest(
varName,
FetchDomain.CreatePoints(
new double[] { KrasnoyarskLat },
new double[] { KrasnoyarskLon },
tr4),
sources);
var result7 = ClimateService.FetchAsync(request7).Result;
double[,] seriesSds2 = (double[, ])result7["sd"].GetData();
double[,] seriesValues2 = (double[, ])result7["values"].GetData();
double[] seriesSdsGuess2 = ClimateService.FetchClimateSeasonlyUncertainty(p, KrasnoyarskLat, KrasnoyarskLat, KrasnoyarskLon, KrasnoyarskLon, daymin: 30, daymax: 40, yearmin: 1990, yearmax: 1991, dataSource: ds);
double[] seriesValuesGuess2 = ClimateService.FetchClimateSeasonly(p, KrasnoyarskLat, KrasnoyarskLat, KrasnoyarskLon, KrasnoyarskLon, daymin: 30, daymax: 40, yearmin: 1990, yearmax: 1991, dataSource: ds);
Assert.AreEqual(seriesSds2.Length, seriesSdsGuess2.Length);
Assert.AreEqual(seriesValues2.Length, seriesValuesGuess2.Length);
for (int i = 0; i < seriesValues2.Length; ++i)
{
Assert.AreEqual(seriesSds2[0, i], seriesSdsGuess2[i]);
Assert.AreEqual(seriesValues2[0, i], seriesValuesGuess2[i]);
}
//Hourly TimeSeries for Krasnoyarsk
var tr5 = new TimeRegion(1990, 1991, 30, 31).GetHourlyTimeseries(isIntervalTimeseries: true);
var request8 = new FetchRequest(
varName,
FetchDomain.CreatePoints(
new double[] { KrasnoyarskLat },
new double[] { KrasnoyarskLon },
tr5),
sources);
var result8 = ClimateService.FetchAsync(request8).Result;
double[,] seriesSds3 = (double[, ])result8["sd"].GetData();
double[,] seriesValues3 = (double[, ])result8["values"].GetData();
double[] seriesSdsGuess3 = ClimateService.FetchClimateHourlyUncertainty(p, KrasnoyarskLat, KrasnoyarskLat, KrasnoyarskLon, KrasnoyarskLon, daymin: 30, daymax: 31, yearmin: 1990, yearmax: 1991, dataSource: ds);
double[] seriesValuesGuess3 = ClimateService.FetchClimateHourly(p, KrasnoyarskLat, KrasnoyarskLat, KrasnoyarskLon, KrasnoyarskLon, daymin: 30, daymax: 31, yearmin: 1990, yearmax: 1991, dataSource: ds);
Assert.AreEqual(seriesSds3.Length, seriesSdsGuess3.Length);
Assert.AreEqual(seriesValues3.Length, seriesValuesGuess3.Length);
for (int i = 0; i < seriesValues3.Length; ++i)
{
Assert.AreEqual(seriesSds3[0, i], seriesSdsGuess3[i]);
Assert.AreEqual(seriesValues3[0, i], seriesValuesGuess3[i]);
}
}
public void WebService_UseSampleFetchRequest_CanProperlySerializeAndDeSerializeFetchRequest()
{
// Arrange
var request1 = new Microsoft.Research.Science.FetchClimate2.Serializable.FetchRequest(new FetchRequest(
"evn_var_name",
FetchDomain.CreateCells(
new double[] { 1.0, 3.4 },
new double[] { 2.0, 4.5 },
new double[] { 1.0, 3.4 },
new double[] { 2.0, 4.5 },
new TimeRegion()
)
, new DateTime(2012, 11, 15, 0, 0, 0, DateTimeKind.Utc))
);
// Act
var json = JsonConvert.SerializeObject(request1);
var request2 = JsonConvert.DeserializeObject <Microsoft.Research.Science.FetchClimate2.Serializable.FetchRequest>(json).ConvertFromSerializable();
// Assert
Assert.IsNotNull(request2, "Error: Deserilized object is null");
Assert.AreEqual <string>(request1.EnvironmentVariableName, request2.EnvironmentVariableName);
Assert.IsNotNull(request2.Domain);
Assert.IsNotNull(request2.Domain.Lats);
Assert.AreEqual <int>(request1.Domain.Lats.Length, request2.Domain.Lats.Length);
Assert.IsNotNull(request2.Domain.Lats[0]);
Assert.AreEqual <double>(request1.Domain.Lats[0], request2.Domain.Lats[0]);
Assert.IsNotNull(request2.Domain.Lons);
Assert.AreEqual <int>(request1.Domain.Lons.Length, request2.Domain.Lons.Length);
Assert.IsNotNull(request2.Domain.Lons[0]);
Assert.AreEqual <double>(request1.Domain.Lons[0], request2.Domain.Lons[0]);
Assert.IsNotNull(request2.Domain.Lats2);
Assert.AreEqual <int>(request1.Domain.Lats2.Length, request2.Domain.Lats2.Length);
Assert.IsNotNull(request2.Domain.Lats2[0]);
Assert.AreEqual <double>(request1.Domain.Lats2[0], request2.Domain.Lats2[0]);
Assert.IsNotNull(request2.Domain.Lons2);
Assert.AreEqual <int>(request1.Domain.Lons2.Length, request2.Domain.Lons2.Length);
Assert.IsNotNull(request2.Domain.Lons2[0]);
Assert.AreEqual <double>(request1.Domain.Lons2[0], request2.Domain.Lons2[0]);
Assert.IsNotNull(request2.Domain.TimeRegion);
Assert.AreEqual <int>(request1.Domain.TimeRegion.Years[0], request2.Domain.TimeRegion.Years[0]);
Assert.AreEqual <int>(request1.Domain.TimeRegion.Years[1], request2.Domain.TimeRegion.Years[1]);
Assert.AreEqual <int>(request1.Domain.TimeRegion.Days[0], request2.Domain.TimeRegion.Days[0]);
Assert.AreEqual <int>(request1.Domain.TimeRegion.Days[1], request2.Domain.TimeRegion.Days[1]);
Assert.AreEqual <int>(request1.Domain.TimeRegion.Hours[0], request2.Domain.TimeRegion.Hours[0]);
Assert.AreEqual <int>(request1.Domain.TimeRegion.Hours[1], request2.Domain.TimeRegion.Hours[1]);
Assert.AreEqual <SpatialRegionSpecification>(SpatialRegionSpecification.Cells, request2.Domain.SpatialRegionType);
Assert.AreEqual <DateTime>(request1.ReproducibilityTimestamp, request2.ReproducibilityTimestamp);
}
