public void UpdateSegmentsForSegmentBetweenLocations()
{
var network = GetNetwork();
NetworkCoverage route = new NetworkCoverage
{
Network = network,
SegmentGenerationMethod = SegmentGenerationMethod.SegmentBetweenLocations
};
// [---------------------------------------------------]
// 5 60
// 40
route.Locations.Values.Add(new NetworkLocation(network.Branches[0], 5.0));
route.Locations.Values.Add(new NetworkLocation(network.Branches[0], 60.0));
route.Locations.Values.Add(new NetworkLocation(network.Branches[0], 40.0));
// expect location to be sorted uysing offset
// [ 5-----40
// 40-----------------60
Assert.AreEqual(2, route.Segments.Values.Count);
Assert.AreEqual(5.0, route.Segments.Values[0].Chainage);
Assert.AreEqual(40.0, route.Segments.Values[0].EndChainage);
Assert.AreEqual(40.0, route.Segments.Values[1].Chainage);
Assert.AreEqual(60.0, route.Segments.Values[1].EndChainage);
}
public void NetworkCoverageLocationsAreUpdatedWhenBranchGeometryChanges()
{
var network = RouteHelperTest.GetSnakeHydroNetwork(false, new Point(0, 0), new Point(100, 0));
var networkCoverage = new NetworkCoverage {
Network = network
};
//define a point halfway the branch
IBranch firstBranch = network.Branches[0];
networkCoverage[new NetworkLocation(firstBranch, 50)] = 2.0;
//make sure we are 'initialized' (CODE SMELL SNIFF UGH)
Assert.AreEqual(1, networkCoverage.Locations.Values.Count);
//change the branch geometry
firstBranch.Length = 200;
firstBranch.Geometry = new LineString(new[]
{
new Coordinate(0, 0),
new Coordinate(200, 0)
});
//assert the coverage scaled along..so the point should now be at 100
Assert.AreEqual(100, networkCoverage.Locations.Values[0].Offset);
}
public void SegmentsForTimeFilteredCoverage()
{
var network = CreateNetwork();
var dateTime = DateTime.Now;
var networkCoverage = new NetworkCoverage("test", true)
{
Network = network
};
// test for defaultvalue
// set values for only one t.
INetworkLocation nl11 = new NetworkLocation(network.Branches[0], 0.0);
INetworkLocation nl12 = new NetworkLocation(network.Branches[0], 100.0);
INetworkLocation nl13 = new NetworkLocation(network.Branches[1], 100.0);
networkCoverage[dateTime, nl11] = 0.1;
networkCoverage[dateTime, nl12] = 0.2;
networkCoverage[dateTime, nl13] = 0.3;
//action! filter on t1
var filtered = (INetworkCoverage)networkCoverage.FilterTime(dateTime);
//segments should not be affected
Assert.AreEqual(networkCoverage.Segments.Values.Count, filtered.Segments.Values.Count);
}
public void WorksWithTimeDependentNetworkCoverage()
{
var timeNetworkCoverage = new NetworkCoverage("timedep", true);
timeNetworkCoverage.Network = network;
var t1 = new DateTime(2000, 1, 1);
var t2 = new DateTime(2000, 1, 2);
timeNetworkCoverage[t1, new NetworkLocation(network.Branches[0], 1)] = 10.0;
timeNetworkCoverage[t1, new NetworkLocation(network.Branches[1], 2)] = 20.0;
timeNetworkCoverage[t2, new NetworkLocation(network.Branches[0], 1)] = 30.0;
timeNetworkCoverage[t2, new NetworkLocation(network.Branches[1], 2)] = 40.0;
var timeCoverageBindingList = new NetworkCoverageBindingList(timeNetworkCoverage);
Assert.AreEqual(4, timeCoverageBindingList.ColumnNames.Count());
//columns shifted
Assert.AreEqual("Location_Branch", timeCoverageBindingList.GetItemProperties(null)[1].Name);
var newOffset = 1.5;
Assert.AreNotEqual(newOffset, timeNetworkCoverage.Locations.Values[0].Chainage);
timeCoverageBindingList[0][2] = newOffset;
timeCoverageBindingList[0].EndEdit(); //commit changes
Assert.AreEqual(newOffset, timeNetworkCoverage.Locations.Values[0].Chainage);
var gridView = new DataGridView { DataSource = timeCoverageBindingList };
WindowsFormsTestHelper.ShowModal(gridView);
}
public void NextValueOnNextBranch()
{
var network = new Network();
var node1 = new Node("node1");
var node2 = new Node("node2");
var node3 = new Node("node3");
network.Nodes.Add(node1);
network.Nodes.Add(node2);
network.Nodes.Add(node3);
var branch1 = new Branch("branch1", node1, node2, 100.0);
var branch2 = new Branch("branch2", node1, node2, 200.0);
network.Branches.Add(branch1);
network.Branches.Add(branch2);
// create network coverate
var networkCoverage = new NetworkCoverage {
Network = network
};
NetworkLocationNextValueGenerator networkLocationNextValueGenerator = new NetworkLocationNextValueGenerator(networkCoverage);
networkCoverage.Locations.Values.Add(new NetworkLocation(branch1, 100));
Assert.AreEqual(new NetworkLocation(branch1, 101), networkLocationNextValueGenerator.GetNextValue());
}
public void GeometryForTimeFilteredCoverage()
{
var network = RouteHelperTest.GetSnakeHydroNetwork(false, new Point(0, 0), new Point(100, 0), new Point(100, 200));
var dateTime = DateTime.Now;
var networkCoverage = new NetworkCoverage("test", true)
{
Network = network
};
// test for defaultvalue
// set values for only one t.
INetworkLocation nl11 = new NetworkLocation(network.Branches[0], 0.0);
INetworkLocation nl12 = new NetworkLocation(network.Branches[0], 100.0);
INetworkLocation nl13 = new NetworkLocation(network.Branches[1], 100.0);
networkCoverage[dateTime, nl11] = 0.1;
networkCoverage[dateTime, nl12] = 0.2;
networkCoverage[dateTime, nl13] = 0.3;
//action! filter on t1
var filtered = networkCoverage.FilterTime(dateTime);
//segments should not be affected
Assert.AreEqual(networkCoverage.Geometry.EnvelopeInternal, filtered.Geometry.EnvelopeInternal);
}
public void ShowNetworkCoverageAsLayerWithNoneSegmentationType()
{
// create network
var network = MapTestHelper.CreateMockNetwork();
mocks.ReplayAll();
var networkCoverage = new NetworkCoverage {
Network = network, SegmentGenerationMethod = SegmentGenerationMethod.None
};
var networkCoverageLayer = new NetworkCoverageGroupLayer {
NetworkCoverage = networkCoverage
};
// set values
var branch1 = network.Branches[0];
var branch2 = network.Branches[1];
networkCoverage[new NetworkLocation(branch1, 4.0)] = 0.1;
networkCoverage[new NetworkLocation(branch1, 16.0)] = 0.2;
networkCoverage[new NetworkLocation(branch2, 4.0)] = 0.3;
networkCoverage[new NetworkLocation(branch2, 12.0)] = 0.4;
networkCoverage[new NetworkLocation(branch2, 16.0)] = 0.5;
var map = new Map(new Size(1000, 1000));
map.Layers.Add(networkCoverageLayer);
MapTestHelper.ShowModal(map);
}
public void Evaluate()
{
// create network
var network = new Network();
var node1 = new Node("node1");
var node2 = new Node("node2");
network.Nodes.Add(node1);
network.Nodes.Add(node2);
var branch1 = new Branch("branch1", node1, node2, 100.0)
{
Geometry = GeometryFromWKT.Parse("LINESTRING (0 0, 100 0)")
};
network.Branches.Add(branch1);
// create network coverage
INetworkCoverage networkCoverage = new NetworkCoverage {
Network = network
};
networkCoverage.Locations.InterpolationType = ApproximationType.Linear;
networkCoverage[new NetworkLocation(network.Branches[0], 0.0)] = 0;
networkCoverage[new NetworkLocation(network.Branches[0], 100.0)] = 10;
// evaluate
var value = networkCoverage.Evaluate <double>(50.0, 0.0);
value.Should().Be.EqualTo(5); // linear interpolation
}
private void AddNetworkCoverageAndTool()
{
INetworkCoverage networkCoverage = new NetworkCoverage {
Network = network
};
networkCoverageGroupLayer.NetworkCoverage = networkCoverage;
((FeatureCollection)networkCoverageGroupLayer.LocationLayer.DataSource).AddNewFeatureFromGeometryDelegate =
AddFeatureFromGeometryDelegate;
/* no references to DeltaShell, TODO: move LayerPropertiesEditor into SharpMap.UI
* mapControl.MouseDoubleClick += delegate
* {
* var dialog = new LayerPropertiesEditorDialog(networkCoverageLayer.SegmentLayer);
* dialog.Show(mapControl);
* };
*/
mapControl.Map.Layers.Add(networkCoverageGroupLayer);
var networkCoverageTool = new NewNetworkFeatureTool(l => l.Equals(networkCoverageGroupLayer.LocationLayer), "new location");
mapControl.Tools.Add(networkCoverageTool);
networkCoverageGroupLayer.LocationLayer.FeatureEditor.SnapRules.Add(new SnapRule
{
SnapRole = SnapRole.FreeAtObject,
Obligatory = true,
PixelGravity = 40
});
return;
}
public void UpdateSegmentsForSegmentBetweenLocationsReversedForRouteBetweenLocation()
{
var network = GetNetwork();
NetworkCoverage route = new NetworkCoverage
{
Network = network,
SegmentGenerationMethod = SegmentGenerationMethod.RouteBetweenLocations
};
route.Locations.IsAutoSorted = false;
route.Locations.Values.Add(new NetworkLocation(network.Branches[0], 60.0));
route.Locations.Values.Add(new NetworkLocation(network.Branches[0], 40.0));
route.Locations.Values.Add(new NetworkLocation(network.Branches[0], 5.0));
// expect location not to be sorted
// [ 60-----40
// 40-----------------5
//NetworkCoverageHelper.UpdateSegments(route);
Assert.AreEqual(2, route.Segments.Values.Count);
Assert.AreEqual(60.0, route.Segments.Values[0].Chainage);
Assert.AreEqual(40.0, route.Segments.Values[0].EndChainage);
Assert.IsFalse(route.Segments.Values[0].DirectionIsPositive);
Assert.AreEqual(40.0, route.Segments.Values[1].Chainage);
Assert.AreEqual(5.0, route.Segments.Values[1].EndChainage);
Assert.IsFalse(route.Segments.Values[1].DirectionIsPositive);
}
public void GenerateSegmentPerLocation()
{
var network = CreateNetwork();
var networkCoverage = new NetworkCoverage
{
Network = network,
SegmentGenerationMethod = SegmentGenerationMethod.SegmentPerLocation
};
networkCoverage[new NetworkLocation(network.Branches[0], 10.0)] = 0.1;
networkCoverage[new NetworkLocation(network.Branches[0], 50.0)] = 0.5;
networkCoverage[new NetworkLocation(network.Branches[0], 90.0)] = 0.9;
Assert.AreEqual(3, networkCoverage.Segments.Values.Count);
// [--10--------------50-------------------------------90---]
// [----------][-----------------------][-------------------]
// 0 30 70 100
Assert.AreEqual(0, networkCoverage.Segments.Values[0].Offset, 1.0e-6);
Assert.AreEqual(30, networkCoverage.Segments.Values[0].EndOffset, 1.0e-6);
Assert.AreEqual(30, networkCoverage.Segments.Values[1].Offset, 1.0e-6);
Assert.AreEqual(70, networkCoverage.Segments.Values[1].EndOffset, 1.0e-6);
Assert.AreEqual(70, networkCoverage.Segments.Values[2].Offset, 1.0e-6);
Assert.AreEqual(100, networkCoverage.Segments.Values[2].EndOffset, 1.0e-6);
}
public void ShowNetworkCoverageAsRoute()
{
// create network
var network = MapTestHelper.CreateMockNetwork();
mocks.ReplayAll();
var networkCoverage = new NetworkCoverage { Network = network, SegmentGenerationMethod = SegmentGenerationMethod.RouteBetweenLocations };
var networkCoverageLayer = new NetworkCoverageLayer {NetworkCoverage = networkCoverage};
NetworkCoverageLayerHelper.SetupRouteNetworkCoverageLayerTheme(networkCoverageLayer, null);
// set values
var branch1 = network.Branches[0];
var branch2 = network.Branches[1];
networkCoverage[new NetworkLocation(branch1, 4.0)] = 0.1;
networkCoverage[new NetworkLocation(branch1, 16.0)] = 0.2;
networkCoverage[new NetworkLocation(branch2, 4.0)] = 0.3;
networkCoverage[new NetworkLocation(branch2, 12.0)] = 0.4;
networkCoverage[new NetworkLocation(branch2, 16.0)] = 0.5;
var map = new Map(new Size(1000, 1000));
map.Layers.Add(networkCoverageLayer);
// add branch layer
var branchLayer = new VectorLayer {DataSource = new FeatureCollection{Features = (IList) network.Branches} };
branchLayer.Style.Outline.Width = 25;
branchLayer.Style.Outline.Color = Pens.LightGray.Color;
map.Layers.Add(branchLayer);
MapTestHelper.Show(map);
}
public void GetLocationsForAnotherRoute()
{
var network = CreateThreeNodesNetwork();
var branch = (Branch)network.Branches[0];
var source = new NetworkCoverage {
Network = network
};
source[new NetworkLocation(branch, 10.0)] = 10.0;
source[new NetworkLocation(branch, 50.0)] = 30.0;
source[new NetworkLocation(branch, 60.0)] = 20.0;
source[new NetworkLocation(branch, 80.0)] = 10.0;
//90-->0-->80
var route = RouteHelper.CreateRoute(new[] { new NetworkLocation(branch, 90.0)
, new NetworkLocation(branch, 0.0), new NetworkLocation(branch, 80) });
var expectedLocations = new[]
{
new NetworkLocation(branch, 90.0)
, new NetworkLocation(branch, 80.0)
, new NetworkLocation(branch, 60.0)
, new NetworkLocation(branch, 50.0)
, new NetworkLocation(branch, 10.0)
, new NetworkLocation(branch, 0)
, new NetworkLocation(branch, 10.0)
, new NetworkLocation(branch, 50.0)
, new NetworkLocation(branch, 60.0)
, new NetworkLocation(branch, 80.0)
};
var actualLocations = RouteHelper.GetLocationsInRoute(source, route);
Assert.AreEqual(expectedLocations, actualLocations);
}
public void ShowNetworkCoverageAsLayer()
{
// create network
var network = MapTestHelper.CreateMockNetwork();
mocks.ReplayAll();
var networkCoverage = new NetworkCoverage {
Network = network
};
var networkCoverageLayer = new NetworkCoverageLayer {
NetworkCoverage = networkCoverage
};
// set values
var branch1 = network.Branches[0];
var branch2 = network.Branches[1];
networkCoverage[new NetworkLocation(branch1, 4.0)] = 0.1;
networkCoverage[new NetworkLocation(branch1, 16.0)] = 0.2;
networkCoverage[new NetworkLocation(branch2, 4.0)] = 0.3;
networkCoverage[new NetworkLocation(branch2, 12.0)] = 0.4;
networkCoverage[new NetworkLocation(branch2, 16.0)] = 0.5;
var map = new Map(new Size(1000, 1000));
map.Layers.Add(networkCoverageLayer);
MapTestHelper.Show(map);
}
public void AddCoverages()
{
var network = RouteHelperTest.GetSnakeNetwork(false, new Point(0, 0), new Point(100, 0),
new Point(100, 100));
var location = new NetworkLocation(network.Branches[0], 0);
var coverageA = new NetworkCoverage {
Network = network
};
var coverageB = new NetworkCoverage {
Network = network
};
//add a uniform coverage B to a
coverageB.DefaultValue = 100.0;
coverageA[location] = 40.0;
coverageA.Add(coverageB);
Assert.AreEqual(140.0, coverageA[location]);
//define a value for B so it no longer uses default value
coverageB[location] = -20.0;
//should substract the -20 now
coverageA.Add(coverageB);
Assert.AreEqual(120.0, coverageA[location]);
}
public void UpdateSegmentsForSegmentBetweenLocations()
{
var network = GetNetwork();
NetworkCoverage route = new NetworkCoverage
{
Network = network,
SegmentGenerationMethod = SegmentGenerationMethod.SegmentBetweenLocations
};
// [---------------------------------------------------]
// 5 60
// 40
route.Locations.Values.Add(new NetworkLocation(network.Branches[0], 5.0));
route.Locations.Values.Add(new NetworkLocation(network.Branches[0], 60.0));
route.Locations.Values.Add(new NetworkLocation(network.Branches[0], 40.0));
// expect location to be sorted uysing offset
// [ 5-----40
// 40-----------------60
Assert.AreEqual(2, route.Segments.Values.Count);
Assert.AreEqual(5.0, route.Segments.Values[0].Chainage);
Assert.AreEqual(40.0, route.Segments.Values[0].EndChainage);
Assert.AreEqual(40.0, route.Segments.Values[1].Chainage);
Assert.AreEqual(60.0, route.Segments.Values[1].EndChainage);
}
public void SubstractTimeDependentCoverages()
{
var network = RouteHelperTest.GetSnakeNetwork(false, new Point(0, 0), new Point(100, 0),
new Point(100, 100));
var location = new NetworkLocation(network.Branches[0], 0);
var coverageA = new NetworkCoverage {
Network = network, IsTimeDependent = true
};
var coverageB = new NetworkCoverage {
Network = network, IsTimeDependent = true
};
var dates = new[] { new DateTime(2000, 1, 1), new DateTime(2001, 1, 1) };
//add a uniform coverage B to a
coverageB.DefaultValue = 100.0;
coverageB.Time.SetValues(dates);
coverageA[dates[0], location] = 40.0;
coverageA[dates[1], location] = 10.0;
coverageA.Substract(coverageB);
Assert.AreEqual(-60.0, coverageA[dates[0], location]);
Assert.AreEqual(-90.0, coverageA[dates[1], location]);
}
public void AnotherInterpolationNoTime()
{
var network = CreateNetwork();
INetworkCoverage networkCoverage = new NetworkCoverage {
Network = network
};
networkCoverage[new NetworkLocation(network.Branches[0], 10.0)] = 0.1;
networkCoverage[new NetworkLocation(network.Branches[0], 90.0)] = 0.9;
networkCoverage.Locations.ExtrapolationType = ApproximationType.Constant;
networkCoverage.Locations.InterpolationType = ApproximationType.Linear;
// at the exact locations
Assert.AreEqual(0.1, networkCoverage.Evaluate(new NetworkLocation(network.Branches[0], 10.0)));
Assert.AreEqual(0.9, networkCoverage.Evaluate(new NetworkLocation(network.Branches[0], 90.0)));
// at start and end outside the locations
Assert.AreEqual(0.10, networkCoverage.Evaluate(new NetworkLocation(network.Branches[0], 5.0)));
Assert.AreEqual(0.90, networkCoverage.Evaluate(new NetworkLocation(network.Branches[0], 95.0)), 1e-6);
// in between the 2 locations
Assert.AreEqual(0.35, networkCoverage.Evaluate(new NetworkLocation(network.Branches[0], 35.0)), 1e-6);
}
public void PropertyChangedIsFiredOnValuesAdd()
{
var network = MapTestHelper.CreateMockNetwork();
var networkCoverage = new NetworkCoverage {
Network = network
};
var networkCoverageFeatureCollection = new NetworkCoverageFeatureCollection
{
NetworkCoverage = networkCoverage,
NetworkCoverageFeatureType = NetworkCoverageFeatureType.Locations
};
var callCount = 0;
((INotifyPropertyChanged)networkCoverageFeatureCollection).PropertyChanged += (s, e) => { callCount++; };
networkCoverage.Locations.Values.Add(new NetworkLocation {
Branch = network.Branches[0], Offset = 0.0
});
//2 one for component, one for argument
Assert.AreEqual(2, callCount);
}
public void CreateFeatureCollectionForNetworkLocationsAndSegments()
{
var network = MapTestHelper.CreateMockNetwork();
var networkCoverage = new NetworkCoverage {
Network = network
};
var networkLocationFeatureProvider = new NetworkCoverageFeatureCollection
{
NetworkCoverage = networkCoverage,
NetworkCoverageFeatureType = NetworkCoverageFeatureType.Locations
};
var segmentFeatureProvider = new NetworkCoverageFeatureCollection
{
NetworkCoverage = networkCoverage,
NetworkCoverageFeatureType = NetworkCoverageFeatureType.Segments
};
networkCoverage.Locations.Values.Add(new NetworkLocation {
Branch = network.Branches[0], Offset = 0.0
});
Assert.AreEqual(1, networkLocationFeatureProvider.Features.Count);
Assert.AreEqual(1, segmentFeatureProvider.Features.Count);
}
public void SetUp()
{
network = RouteHelperTest.GetSnakeNetwork(false, new Point(0, 0), new Point(100, 0), new Point(100, 100));
networkCoverage = new NetworkCoverage { Network = network };
networkCoverage.Locations.NextValueGenerator = new NetworkLocationNextValueGenerator(networkCoverage);
networkCoverageBindingList = new NetworkCoverageBindingList(networkCoverage);
}
public void FilterCoverageDoesNotReturnCoverageWhenReduced()
{
NetworkCoverage coverage = new NetworkCoverage();
coverage.IsTimeDependent = true;
//fix the coverage on a location so we have a funtion with only one argument...time.
var filtered = coverage.Filter(new VariableReduceFilter(coverage.Locations));
Assert.IsFalse(filtered is INetworkCoverage);
}
public void AddingTimeSlicesShouldBeFastUsingMemoryStore()
{
var random = new Random();
//50 branches
var network = RouteHelperTest.GetSnakeNetwork(false, 50);
//10 offsets
var offsets = new[] { 0, 10, 20, 30, 40, 50, 60, 70, 80, 90 };
//500 locations
var locations = offsets.SelectMany(o => network.Branches, (o, b) => new NetworkLocation(b, o)).ToList();
var values = (from o in locations
select (double)random.Next(100) / 10).ToList();
//setup the coverage with fixed size locations
var networkCoverage = new NetworkCoverage() { IsTimeDependent = true, Network = network };
networkCoverage.Locations.FixedSize = 500;
networkCoverage.Locations.SetValues(locations.OrderBy(l => l));
var startTime = new DateTime(2000, 1, 1);
// add 10000 slices in time..
var times = from i in Enumerable.Range(1, 1000)
select startTime.AddDays(i);
int outputTimeStepIndex = 0;
//write like a flowmodel ..
TestHelper.AssertIsFasterThan(2000, () =>
{
foreach (var t in times)
{
//high performance writing. Using indexes instead of values.
var locationsIndexFilter =
new VariableIndexRangeFilter(networkCoverage.Locations,
0,
networkCoverage.Locations.
FixedSize - 1);
//current timestep starts at 1 and is increased before outputvalues are set now..hence -2 to get a 0 for the 1st
//int timeIndex = currentTimeStep - 1;
var timeIndexFilter =
new VariableIndexRangeFilter(networkCoverage.Time,
outputTimeStepIndex);
networkCoverage.Time.AddValues(new[] { t });
networkCoverage.SetValues(values,
new[]
{
locationsIndexFilter,
timeIndexFilter
});
outputTimeStepIndex++;
}
});
}
public void AddCoveragesThrowsExceptionIfNetworksDontMatch()
{
var coverageA = new NetworkCoverage {
Network = new Network()
};
var coverageB = new NetworkCoverage {
Network = new Network()
};
coverageA.Add(coverageB);
}
public void ShowNetworkCoverageAsLayerWithSegmentBetweenLocationsFullyCoveredType()
{
// create network
var network = MapTestHelper.CreateMockNetwork();
mocks.ReplayAll();
var networkCoverage = new NetworkCoverage
{
Network = network,
IsTimeDependent = true,
SegmentGenerationMethod = SegmentGenerationMethod.SegmentBetweenLocationsFullyCovered
};
var networkCoverageLayer = new NetworkCoverageGroupLayer {
NetworkCoverage = networkCoverage
};
var time1 = new DateTime(2010, 1, 1);
// set values
var branch1 = network.Branches[0];
var branch2 = network.Branches[1];
networkCoverage[time1, new NetworkLocation(branch1, 0.0)] = 0.1;
networkCoverage[time1, new NetworkLocation(branch1, 10.0)] = 0.2;
networkCoverage[time1, new NetworkLocation(branch1, 50.0)] = 0.3;
networkCoverage[time1, new NetworkLocation(branch1, 100.0)] = 0.4;
// no coverage point for branch2 offset 0
// the fully covered option will look for the begin node point
// on other branches (branch 1 offset 100 == node2 == branch2 offset 0)
networkCoverage[time1, new NetworkLocation(branch2, 20.0)] = 0.5;
networkCoverage[time1, new NetworkLocation(branch2, 40.0)] = 0.6;
networkCoverage[time1, new NetworkLocation(branch2, 60.0)] = 0.7;
networkCoverage[time1, new NetworkLocation(branch2, 100.0)] = 0.8;
var time2 = new DateTime(2010, 1, 2);
foreach (var location in networkCoverage.Locations.Values)
{
networkCoverage[time2, location] = (double)networkCoverage[time1, location] * 2;
}
networkCoverage.Locations.InterpolationType = InterpolationType.Constant;
networkCoverageLayer.SegmentLayer.LabelLayer.LabelColumn = "SegmentNumber";
networkCoverageLayer.SegmentLayer.LabelLayer.Visible = true;
var map = new Map(new Size(1000, 1000));
map.Layers.Add(networkCoverageLayer);
networkCoverageLayer.SetCurrentTimeSelection(time2, time2);
MapTestHelper.ShowModal(map);
}
public void DefaultValueTest()
{
var network = CreateNetwork();
INetworkCoverage networkCoverage = new NetworkCoverage {
Network = network, DefaultValue = 0.33
};
INetworkLocation nl11 = new NetworkLocation(network.Branches[0], 0.0);
// no network location set in networkCoverage expect the default value to return
Assert.AreEqual(0.33, networkCoverage.Evaluate(nl11));
}
public void SetUp()
{
network = RouteHelperTest.GetSnakeNetwork(false, new Point(0, 0), new Point(100, 0), new Point(100, 100));
networkCoverage = new NetworkCoverage {
Network = network
};
networkCoverage.Locations.NextValueGenerator = new NetworkLocationNextValueGenerator(networkCoverage);
networkCoverageBindingList = new NetworkCoverageBindingList(networkCoverage);
}
public void ExtractTimeSliceUseLocationsFromTarget()
{
var network = GetNetwork();
var networkCoverage = new NetworkCoverage("test", true)
{
Network = network
};
DateTime[] dateTimes = new DateTime[10];
for (int i = 0; i < 10; i++)
{
dateTimes[i] = new DateTime(2000, 1, 1, 1, /* minute */ i, 0);
networkCoverage[dateTimes[i], new NetworkLocation(network.Branches[0], 10.0)] = 10.0 + i;
networkCoverage[dateTimes[i], new NetworkLocation(network.Branches[0], 50.0)] = 50.0 + i;
networkCoverage[dateTimes[i], new NetworkLocation(network.Branches[0], 90.0)] = 90.0 + i;
networkCoverage[dateTimes[i], new NetworkLocation(network.Branches[1], 10.0)] = 110.0 + i;
networkCoverage[dateTimes[i], new NetworkLocation(network.Branches[1], 50.0)] = 150.0 + i;
networkCoverage[dateTimes[i], new NetworkLocation(network.Branches[1], 90.0)] = 190.0 + i;
}
var slice = new NetworkCoverage("slice", false)
{
Network = network
};
Assert.AreEqual(false, slice.IsTimeDependent);
slice[new NetworkLocation(network.Branches[0], 20.0)] = 2;
slice[new NetworkLocation(network.Branches[0], 80.0)] = 8;
slice[new NetworkLocation(network.Branches[1], 20.0)] = 12;
slice[new NetworkLocation(network.Branches[1], 80.0)] = 18;
NetworkCoverageHelper.ExtractTimeSlice(networkCoverage, slice,
new DateTime(2000, 1, 1, 1, /* minute */ 0, 0), false);
// expected results at time step 0 are 20 80 120 180; this are interpolated values
Assert.AreEqual(4, slice.Locations.Values.Count);
Assert.AreEqual(10 /*20*/, slice.Evaluate(new NetworkLocation(network.Branches[0], 20.0)), 1.0e-6);
Assert.AreEqual(50 /*80*/, slice.Evaluate(new NetworkLocation(network.Branches[0], 80.0)), 1.0e-6);
Assert.AreEqual(90 /*120*/, slice.Evaluate(new NetworkLocation(network.Branches[1], 20.0)), 1.0e-6);
Assert.AreEqual(110 /*180*/, slice.Evaluate(new NetworkLocation(network.Branches[1], 80.0)), 1.0e-6);
NetworkCoverageHelper.ExtractTimeSlice(networkCoverage, slice,
new DateTime(2000, 1, 1, 1, /* minute */ 3, 0), false);
// expected results at time step 3 are 23 83 123 183; this are interpolated values
Assert.AreEqual(4, slice.Locations.Values.Count);
Assert.AreEqual(13 /*23*/, slice.Evaluate(new NetworkLocation(network.Branches[0], 20.0)), 1.0e-6);
Assert.AreEqual(53 /*83*/, slice.Evaluate(new NetworkLocation(network.Branches[0], 80.0)), 1.0e-6);
Assert.AreEqual(93 /*123*/, slice.Evaluate(new NetworkLocation(network.Branches[1], 20.0)), 1.0e-6);
Assert.AreEqual(113 /*183*/, slice.Evaluate(new NetworkLocation(network.Branches[1], 80.0)), 1.0e-6);
}
public void LayerCollectionIsReadOnly()
{
//create a layer with a coverate
NetworkCoverage networkCoverage = GetNetworkCoverage();
networkCoverage.Components[0].Name = "kees";
var networkCoverageLayer = new NetworkCoverageGroupLayer {
NetworkCoverage = networkCoverage
};
Assert.IsTrue(networkCoverageLayer.HasReadOnlyLayersCollection);
}
public void SubstractComplexCoveragesFromClonedNetworks()
{
var network = RouteHelperTest.GetSnakeNetwork(false, new Point(0, 0), new Point(100, 0), new Point(200, 0));
var blNetwork = RouteHelperTest.GetSnakeNetwork(false, new Point(0, 0), new Point(100, 0), new Point(100, 100));
var waterLevel = new NetworkCoverage {
Network = network
};
var bedLevel = new NetworkCoverage {
Network = blNetwork
};
var branchA = network.Branches[0];
var branchB = network.Branches[1];
var blBranchB = blNetwork.Branches[1];
var locationA1 = new NetworkLocation(branchA, 0);
var locationA2 = new NetworkLocation(branchA, branchA.Length / 2);
var locationA3 = new NetworkLocation(branchA, branchA.Length);
var locationB1 = new NetworkLocation(branchB, 0);
var locationB2 = new NetworkLocation(branchB, branchB.Length / 2);
var locationB3 = new NetworkLocation(branchB, branchB.Length);
var blLocationB1 = new NetworkLocation(blBranchB, 0);
var blLocationB2 = new NetworkLocation(blBranchB, blBranchB.Length / 2);
var blLocationB3 = new NetworkLocation(blBranchB, blBranchB.Length);
//add a uniform coverage B to a
bedLevel.DefaultValue = 100.0;
bedLevel[blLocationB1] = 100.0;
bedLevel[blLocationB2] = 120.0;
bedLevel[blLocationB3] = 80.0;
waterLevel[locationA1] = 140.0;
waterLevel[locationA2] = 110.0;
waterLevel[locationA3] = 90.0;
waterLevel[locationB1] = 120.0;
waterLevel[locationB2] = 130.0;
waterLevel[locationB3] = 140.0;
waterLevel.Substract(bedLevel);
var waterDepth = waterLevel;
Assert.AreEqual(40.0, waterDepth[locationA1]);
Assert.AreEqual(10.0, waterDepth[locationA2]);
Assert.AreEqual(-10.0, waterDepth[locationA3]);
Assert.AreEqual(20.0, waterDepth[locationB1]);
Assert.AreEqual(130.0, waterDepth[locationB2]);
Assert.AreEqual(140.0, waterDepth[locationB3]);
}
public void DefaultValueTestInvalidTime()
{
var network = CreateNetwork();
var networkCoverage = new NetworkCoverage("test", true)
{
Network = network, DefaultValue = 0.33
};
INetworkLocation nl11 = new NetworkLocation(network.Branches[0], 0.0);
// no network location set in networkCoverage expect the default value to return
Assert.AreEqual(0.33, networkCoverage.Evaluate(DateTime.Now, nl11));
}
public void SetUp()
{
network = RouteHelperTest.GetSnakeNetwork(false, new Point(0, 0), new Point(100, 0), new Point(100, 100));
networkCoverage = new NetworkCoverage { Network = network };
//add locations
networkCoverage[new NetworkLocation(network.Branches[0], 1.0)] = 10.0;
networkCoverage[new NetworkLocation(network.Branches[0], 2.0)] = 20.0;
networkCoverage.Locations.NextValueGenerator = new NetworkLocationNextValueGenerator(networkCoverage);
networkCoverageBindingList = new NetworkCoverageBindingList(networkCoverage);
}
public void GenerageSegmentsWhenLocationsAreAdded()
{
var network = CreateNetwork();
var networkCoverage = new NetworkCoverage {
Network = network
};
networkCoverage[new NetworkLocation(network.Branches[0], 10.0)] = 0.1;
networkCoverage[new NetworkLocation(network.Branches[0], 50.0)] = 0.5;
networkCoverage[new NetworkLocation(network.Branches[0], 90.0)] = 0.9;
Assert.AreEqual(3, networkCoverage.Segments.Values.Count);
}
public void DoesNotBubbleEventsFromNetwork()
{
var network = RouteHelperTest.GetSnakeHydroNetwork(false, new Point(0, 0), new Point(100, 0), new Point(100, 200));
var networkCoverage = new NetworkCoverage("test", true)
{
Network = network
};
(networkCoverage as INotifyPropertyChanged).PropertyChanged += (s, e) =>
{
Assert.Fail("No Bubbling please!");
};
network.Nodes[0].Name = "kees";
}
public void ExtraTimeSliceFromNonTimeDependentNetworkCoverage()
{
var network = GetNetwork();
var networkCoverage = new NetworkCoverage("test", false)
{
Network = network
};
networkCoverage[new NetworkLocation(network.Branches[0], 10.0)] = 10.0;
networkCoverage[new NetworkLocation(network.Branches[0], 90.0)] = 90.0;
networkCoverage[new NetworkLocation(network.Branches[1], 10.0)] = 110.0;
networkCoverage[new NetworkLocation(network.Branches[1], 90.0)] = 190.0;
// networkcoverage is not time dependent thus expect an argumentexception
NetworkCoverageHelper.ExtractTimeSlice(networkCoverage, DateTime.Now);
}
public void SubstractCoverages()
{
var network = RouteHelperTest.GetSnakeNetwork(false, new Point(0, 0), new Point(100, 0),
new Point(100, 100));
var location = new NetworkLocation(network.Branches[0], 0);
var coverageA = new NetworkCoverage { Network = network };
var coverageB = new NetworkCoverage { Network = network };
//add a uniform coverage B to a
coverageB.DefaultValue = 100.0;
coverageA[location] = 40.0;
coverageA.Substract(coverageB);
Assert.AreEqual(-60.0, coverageA[location]);
}
public void SetUp()
{
network = RouteHelperTest.GetSnakeNetwork(false, new Point(0, 0), new Point(100, 0), new Point(100, 100));
networkCoverage = new NetworkCoverage {
Network = network
};
//add locations
networkCoverage[new NetworkLocation(network.Branches[0], 1.0)] = 10.0;
networkCoverage[new NetworkLocation(network.Branches[0], 2.0)] = 20.0;
networkCoverage.Locations.NextValueGenerator = new NetworkLocationNextValueGenerator(networkCoverage);
networkCoverageBindingList = new NetworkCoverageBindingList(networkCoverage);
}
public IFunction CreateFunction(IEnumerable<IVariable> variables)
{
IVariable component = variables.First(f => !f.IsIndependent);
//TODO: set name correctly
INetworkCoverage networkCoverage = new NetworkCoverage
{
Name = "networkcoverage",
Arguments = new EventedList<IVariable>(component.Arguments),
Components = new EventedList<IVariable>(new[] {component}),
Network = network
};
//component.Store.Functions.Add(networkCoverage);
return networkCoverage;
}
/// <summary>
/// Add a new empty route to the map in a newly added coverage Layer.
/// </summary>
/// <param name="map"></param>
/// <param name="network"></param>
/// <returns></returns>
public static void AddNewRoute2Map(Map map, INetwork network)
{
int count = map.Layers.Count(l => l is INetworkCoverageLayer);
var routeCoverage = new NetworkCoverage(string.Format("route_{0}", (count + 1)), false, "Offset", "m")
{
Network = network,
SegmentGenerationMethod = SegmentGenerationMethod.RouteBetweenLocations
};
//no sorting on route locations.
routeCoverage.Locations.AutoSort = false;
routeCoverage.Segments.AutoSort = false;
var networkCoverageLayer = new NetworkCoverageLayer
{
NetworkCoverage = routeCoverage,
Name = routeCoverage.Name,
Map = map
};
map.Layers.Insert(0, networkCoverageLayer);
}
public void FeaturesChangedIsFiredOnValuesAdd()
{
var network = MapTestHelper.CreateMockNetwork();
var networkCoverage = new NetworkCoverage { Network = network };
var networkCoverageFeatureCollection = new NetworkCoverageFeatureCollection
{
NetworkCoverage = networkCoverage,
NetworkCoverageFeatureType = NetworkCoverageFeatureType.Locations
};
var callCount = 0;
networkCoverageFeatureCollection.FeaturesChanged += (s, e) => { callCount++; };
networkCoverage.Locations.Values.Add(new NetworkLocation { Branch = network.Branches[0], Chainage = 0.0 });
Assert.AreEqual(2, callCount);
}
public void SubstractComplexCoverages()
{
var network = RouteHelperTest.GetSnakeNetwork(false, new Point(0, 0), new Point(100, 0),
new Point(100, 100));
var waterLevel = new NetworkCoverage { Network = network };
var bedLevel = new NetworkCoverage { Network = network };
var branchA = network.Branches[0];
var branchB = network.Branches[1];
var locationA1 = new NetworkLocation(branchA, 0);
var locationA2 = new NetworkLocation(branchA, branchA.Length/2);
var locationA3 = new NetworkLocation(branchA, branchA.Length);
var locationB1 = new NetworkLocation(branchB, 0);
var locationB2 = new NetworkLocation(branchB, branchB.Length/2);
var locationB3 = new NetworkLocation(branchB, branchB.Length);
//add a uniform coverage B to a
bedLevel.DefaultValue = 100.0;
bedLevel[locationB1] = 100.0;
bedLevel[locationB2] = 120.0;
bedLevel[locationB3] = 80.0;
waterLevel[locationA1] = 140.0;
waterLevel[locationA2] = 110.0;
waterLevel[locationA3] = 90.0;
waterLevel[locationB1] = 120.0;
waterLevel[locationB2] = 130.0;
waterLevel[locationB3] = 140.0;
waterLevel.Substract(bedLevel);
var waterDepth = waterLevel;
Assert.AreEqual(40.0, waterDepth[locationA1]);
Assert.AreEqual(10.0, waterDepth[locationA2]);
Assert.AreEqual(-10.0, waterDepth[locationA3]);
Assert.AreEqual(20.0, waterDepth[locationB1]);
Assert.AreEqual(10.0, waterDepth[locationB2]);
Assert.AreEqual(60.0, waterDepth[locationB3]);
}
public void UpdateSegmentsForRoute()
{
var network = GetNetwork();
NetworkCoverage route = new NetworkCoverage
{
Network = network,
SegmentGenerationMethod = SegmentGenerationMethod.RouteBetweenLocations
};
// [---------------------------------------------------]
// 5 60
route.Locations.Values.Add(new NetworkLocation(network.Branches[0], 5.0));
route.Locations.Values.Add(new NetworkLocation(network.Branches[0], 60.0));
// expected result
// [5-----------------------60]
Assert.AreEqual(1, route.Segments.Values.Count);
Assert.AreEqual(5.0, route.Segments.Values[0].Chainage);
Assert.AreEqual(60.0, route.Segments.Values[0].EndChainage);
}
public void SubstractTimeDependentCoverages()
{
var network = RouteHelperTest.GetSnakeNetwork(false, new Point(0, 0), new Point(100, 0),
new Point(100, 100));
var location = new NetworkLocation(network.Branches[0], 0);
var coverageA = new NetworkCoverage {Network = network, IsTimeDependent = true};
var coverageB = new NetworkCoverage {Network = network, IsTimeDependent = true};
var dates = new[] {new DateTime(2000, 1, 1), new DateTime(2001, 1, 1)};
//add a uniform coverage B to a
coverageB.DefaultValue = 100.0;
coverageB.Time.SetValues(dates);
coverageA[dates[0], location] = 40.0;
coverageA[dates[1], location] = 10.0;
coverageA.Substract(coverageB);
Assert.AreEqual(-60.0, coverageA[dates[0], location]);
Assert.AreEqual(-90.0, coverageA[dates[1], location]);
}
public void CreateFeatureCollectionForNetworkLocationsAndSegments()
{
var network = MapTestHelper.CreateMockNetwork();
var networkCoverage = new NetworkCoverage { Network = network };
var networkLocationFeatureProvider = new NetworkCoverageFeatureCollection
{
NetworkCoverage = networkCoverage,
NetworkCoverageFeatureType = NetworkCoverageFeatureType.Locations
};
var segmentFeatureProvider = new NetworkCoverageFeatureCollection
{
NetworkCoverage = networkCoverage,
NetworkCoverageFeatureType = NetworkCoverageFeatureType.Segments
};
networkCoverage.Locations.Values.Add(new NetworkLocation {Branch = network.Branches[0], Offset = 0.0 });
Assert.AreEqual(1, networkLocationFeatureProvider.Features.Count);
Assert.AreEqual(1, segmentFeatureProvider.Features.Count);
}
public void AddCoverages()
{
var network = RouteHelperTest.GetSnakeNetwork(false, new Point(0, 0), new Point(100, 0),
new Point(100, 100));
var location = new NetworkLocation(network.Branches[0], 0);
var coverageA = new NetworkCoverage { Network = network };
var coverageB = new NetworkCoverage { Network = network };
//add a uniform coverage B to a
coverageB.DefaultValue = 100.0;
coverageA[location] = 40.0;
coverageA.Add(coverageB);
Assert.AreEqual(140.0,coverageA[location]);
//define a value for B so it no longer uses default value
coverageB[location] = -20.0;
//should substract the -20 now
coverageA.Add(coverageB);
Assert.AreEqual(120.0,coverageA[location]);
}
public void NextValueOnSameBranch()
{
var network = new Network();
var node1 = new Node("node1");
var node2 = new Node("node2");
network.Nodes.Add(node1);
network.Nodes.Add(node2);
var branch1 = new Branch("branch1", node1, node2, 100.0);
network.Branches.Add(branch1);
// create network coverate
var networkCoverage = new NetworkCoverage { Network = network };
NetworkLocationNextValueGenerator networkLocationNextValueGenerator = new NetworkLocationNextValueGenerator(networkCoverage);
INetworkLocation location = networkLocationNextValueGenerator.GetNextValue();
Assert.AreEqual(new NetworkLocation(branch1, 0), location);
networkCoverage.Locations.Values.Add(location);
Assert.AreEqual(new NetworkLocation(branch1, 1), networkLocationNextValueGenerator.GetNextValue());
}
public void WriteSlicesUsingTimeFilterShouldBeTheSameAsUsingIndexFilter()
{
var network = CreateNetwork();
var networkCoverage = new NetworkCoverage("test", true) { Network = network };
var locations = new[] { new NetworkLocation(network.Branches[0], 0.0),
new NetworkLocation(network.Branches[0], 100.0),
new NetworkLocation(network.Branches[1], 100.0) };
networkCoverage.SetLocations(locations);
networkCoverage.Locations.FixedSize = locations.Length;
var networkCoverage2 = new NetworkCoverage("test", true) { Network = network };
networkCoverage2.SetLocations(locations);
networkCoverage2.Locations.FixedSize = locations.Length;
// set 1000 values using time filters in coverage 1 and 2
var startTime = new DateTime(2000, 1, 1);
for (int i = 0; i < 1000;i++ )
{
IEnumerable<double> values = new[] { 1.0, 2.0, 3.0 }.Select(d => d * i);
DateTime currentTime = startTime.AddMinutes(i);
//set values for coverage 1 using value filter
networkCoverage.Time.AddValues(new[] { currentTime });
var timeValueFilter = new VariableValueFilter<DateTime>(networkCoverage.Time, currentTime);
networkCoverage.SetValues(values,timeValueFilter);
//set values for coverage 2 using index filter
networkCoverage2.Time.AddValues(new[] { currentTime });
var timeIndexFilter = new VariableIndexRangeFilter(networkCoverage2.Time, i);
networkCoverage2.SetValues(values, timeIndexFilter);
}
Assert.AreEqual(networkCoverage.Components[0].Values,networkCoverage2.Components[0].Values);
}
public void ShowNetworkCoverageAsLayer()
{
// create network
var network = MapTestHelper.CreateMockNetwork();
mocks.ReplayAll();
var networkCoverage = new NetworkCoverage { Network = network };
var networkCoverageLayer = new NetworkCoverageGroupLayer {NetworkCoverage = networkCoverage};
// set values
var branch1 = network.Branches[0];
var branch2 = network.Branches[1];
networkCoverage[new NetworkLocation(branch1, 4.0)] = 0.1;
networkCoverage[new NetworkLocation(branch1, 16.0)] = 0.2;
networkCoverage[new NetworkLocation(branch2, 4.0)] = 0.3;
networkCoverage[new NetworkLocation(branch2, 12.0)] = 0.4;
networkCoverage[new NetworkLocation(branch2, 16.0)] = 0.5;
var map = new Map(new Size(1000, 1000));
map.Layers.Add(networkCoverageLayer);
MapTestHelper.ShowModal(map);
}
public void ShowNetworkCoverageAsLayerWithNoneSegmentationType()
{
// create network
var network = MapTestHelper.CreateMockNetwork();
mocks.ReplayAll();
var networkCoverage = new NetworkCoverage { Network = network, SegmentGenerationMethod = SegmentGenerationMethod.None };
var networkCoverageLayer = new NetworkCoverageLayer { NetworkCoverage = networkCoverage };
// set values
var branch1 = network.Branches[0];
var branch2 = network.Branches[1];
networkCoverage[new NetworkLocation(branch1, 4.0)] = 0.1;
networkCoverage[new NetworkLocation(branch1, 16.0)] = 0.2;
networkCoverage[new NetworkLocation(branch2, 4.0)] = 0.3;
networkCoverage[new NetworkLocation(branch2, 12.0)] = 0.4;
networkCoverage[new NetworkLocation(branch2, 16.0)] = 0.5;
var map = new Map(new Size(1000, 1000));
map.Layers.Add(networkCoverageLayer);
MapTestHelper.Show(map);
}
public void ExtraTimeSliceFromNonTimeDependentNetworkCoverage()
{
var network = GetNetwork();
var networkCoverage = new NetworkCoverage("test", false) { Network = network };
networkCoverage[new NetworkLocation(network.Branches[0], 10.0)] = 10.0;
networkCoverage[new NetworkLocation(network.Branches[0], 90.0)] = 90.0;
networkCoverage[new NetworkLocation(network.Branches[1], 10.0)] = 110.0;
networkCoverage[new NetworkLocation(network.Branches[1], 90.0)] = 190.0;
// networkcoverage is not time dependent thus expect an argumentexception
NetworkCoverageHelper.ExtractTimeSlice(networkCoverage, DateTime.Now);
}
public void ExtractNonExistingTimeSliceFromNetworkCoverage()
{
var network = GetNetwork();
var networkCoverage = new NetworkCoverage("test", true) { Network = network };
DateTime dateTime = DateTime.Now;
networkCoverage[dateTime, new NetworkLocation(network.Branches[0], 10.0)] = 10.0;
networkCoverage[dateTime, new NetworkLocation(network.Branches[0], 90.0)] = 90.0;
networkCoverage[dateTime, new NetworkLocation(network.Branches[1], 10.0)] = 110.0;
networkCoverage[dateTime, new NetworkLocation(network.Branches[1], 90.0)] = 190.0;
// networkcoverage is time dependent but queried time is not available.
NetworkCoverageHelper.ExtractTimeSlice(networkCoverage, dateTime + new TimeSpan(1, 0, 0));
}
public void GetLocationsForSegmentInCorrectOrder()
{
var network = CreateThreeNodesNetwork();
var branch = (Branch) network.Branches[0];
var source = new NetworkCoverage { Network = network };
source[new NetworkLocation(branch, 10.0)] = 10;
source[new NetworkLocation(branch, 50.0)] = 30;
source[new NetworkLocation(branch, 60.0)] = 20;
source[new NetworkLocation(branch, 80.0)] = 10;
// retrieve the location of source that overlap with segmentUp
var segmentUp = new NetworkSegment { Branch = branch, Offset = 30, Length = 40 };
var locationsUp = RouteHelper.GetLocationsForSegment(segmentUp, source, false).ToList();
Assert.AreEqual(new NetworkLocation(branch, 50.0),locationsUp[0]);
Assert.AreEqual(new NetworkLocation(branch, 60.0), locationsUp[1]);
// retrieve the location of source that overlap with segmentDown; the direction
// is negative and the location offset are thus descending
var segmentDown = new NetworkSegment
{
Branch = branch,
Offset = 90,
Length = 50,
DirectionIsPositive = false
};
var locationsDown = RouteHelper.GetLocationsForSegment(segmentDown, source, false).ToList();
Assert.AreEqual(new NetworkLocation(branch, 80.0), locationsDown[0]);
Assert.AreEqual(new NetworkLocation(branch, 60.0), locationsDown[1]);
Assert.AreEqual(new NetworkLocation(branch, 50.0), locationsDown[2]);
}
public void ExtractTimeSlice()
{
var network = GetNetwork();
var networkCoverage = new NetworkCoverage("test", true) { Network = network };
DateTime []dateTimes = new DateTime[10];
for (int i = 0; i < 10; i++)
{
dateTimes[i] = new DateTime(2000, 1, 1, 1, /* minute */i, 0);
networkCoverage[dateTimes[i], new NetworkLocation(network.Branches[0], 10.0)] = 10.0 + i;
networkCoverage[dateTimes[i], new NetworkLocation(network.Branches[0], 90.0)] = 90.0 + i;
networkCoverage[dateTimes[i], new NetworkLocation(network.Branches[1], 10.0)] = 110.0 + i;
networkCoverage[dateTimes[i], new NetworkLocation(network.Branches[1], 90.0)] = 190.0 + i;
}
INetworkCoverage slice = NetworkCoverageHelper.ExtractTimeSlice(networkCoverage, new DateTime(2000, 1, 1, 1, /* minute */0, 0));
Assert.AreEqual(false, slice.IsTimeDependent);
Assert.AreEqual(10.0 + 0, slice.Evaluate(new NetworkLocation(network.Branches[0], 10.0)));
Assert.AreEqual(90.0 + 0, slice.Evaluate(new NetworkLocation(network.Branches[0], 90.0)));
Assert.AreEqual(110.0 + 0, slice.Evaluate(new NetworkLocation(network.Branches[1], 10.0)));
Assert.AreEqual(190.0 + 0, slice.Evaluate(new NetworkLocation(network.Branches[1], 90.0)));
//slice = NetworkCoverageHelper.ExtractTimeSlice(networkCoverage, new DateTime(2000, 1, 1, 1, /* minute */9, 0));
slice = new NetworkCoverage(networkCoverage.Name, false);
NetworkCoverageHelper.ExtractTimeSlice(networkCoverage, slice,
new DateTime(2000, 1, 1, 1, /* minute */9, 0), true);
Assert.AreEqual(false, slice.IsTimeDependent);
Assert.AreEqual(10.0 + 9, slice.Evaluate(new NetworkLocation(network.Branches[0], 10.0)));
Assert.AreEqual(90.0 + 9, slice.Evaluate(new NetworkLocation(network.Branches[0], 90.0)));
Assert.AreEqual(110.0 + 9, slice.Evaluate(new NetworkLocation(network.Branches[1], 10.0)));
Assert.AreEqual(190.0 + 9, slice.Evaluate(new NetworkLocation(network.Branches[1], 90.0)));
// just repeat the previous action; refilling a coverage should also work
NetworkCoverageHelper.ExtractTimeSlice(networkCoverage, slice,
new DateTime(2000, 1, 1, 1, /* minute */9, 0), true);
Assert.AreEqual(false, slice.IsTimeDependent);
Assert.AreEqual(10.0 + 9, slice.Evaluate(new NetworkLocation(network.Branches[0], 10.0)));
Assert.AreEqual(90.0 + 9, slice.Evaluate(new NetworkLocation(network.Branches[0], 90.0)));
Assert.AreEqual(110.0 + 9, slice.Evaluate(new NetworkLocation(network.Branches[1], 10.0)));
Assert.AreEqual(190.0 + 9, slice.Evaluate(new NetworkLocation(network.Branches[1], 90.0)));
}
public void ExtractTimeSliceNoDataValues()
{
var network = GetNetwork();
var networkCoverage = new NetworkCoverage("test", true) { Network = network };
DateTime dateTime = DateTime.Now;
networkCoverage[dateTime, new NetworkLocation(network.Branches[0], 10.0)] = 10.0;
networkCoverage[dateTime, new NetworkLocation(network.Branches[0], 90.0)] = 90.0;
networkCoverage[dateTime, new NetworkLocation(network.Branches[1], 10.0)] = 110.0;
networkCoverage[dateTime, new NetworkLocation(network.Branches[1], 90.0)] = 190.0;
networkCoverage.Components[0].NoDataValues.Add(16.0);
INetworkCoverage slice = NetworkCoverageHelper.ExtractTimeSlice(networkCoverage, dateTime);
Assert.AreEqual(networkCoverage.Components[0].NoDataValues.Count, slice.Components[0].NoDataValues.Count);
for (int i = 0; i < slice.Components[0].NoDataValues.Count; i++)
{
Assert.AreEqual(networkCoverage.Components[0].NoDataValues[i], slice.Components[0].NoDataValues[i]);
}
}
public void GetLocationsForRoute()
{
var network = CreateThreeNodesNetwork();
var branch = (Branch)network.Branches[0];
var source = new NetworkCoverage { Network = network };
source[new NetworkLocation(branch, 10.0)] = 10;
source[new NetworkLocation(branch, 50.0)] = 30;
source[new NetworkLocation(branch, 60.0)] = 20;
source[new NetworkLocation(branch, 80.0)] = 10;
var route = RouteHelper.CreateRoute(new[] { new NetworkLocation(branch, 0.0)
, new NetworkLocation(branch, 90.0) });
var expectedLocations = new[]
{
new NetworkLocation(branch, 0.0)
, new NetworkLocation(branch, 10.0)
, new NetworkLocation(branch, 50.0)
, new NetworkLocation(branch, 60.0)
, new NetworkLocation(branch, 80.0)
, new NetworkLocation(branch, 90)
};
Assert.AreEqual(expectedLocations, RouteHelper.GetLocationsInRoute(source, route));
}
public void GetRouteSegments()
{
INetwork network = CreateThreeNodesNetwork();
NetworkCoverage route = new NetworkCoverage
{
Network = network,
SegmentGenerationMethod = SegmentGenerationMethod.RouteBetweenLocations
};
route.Locations.AutoSort = false;
route.Locations.Values.Add(new NetworkLocation(network.Branches[0], 0));
route.Locations.Values.Add(new NetworkLocation(network.Branches[0], 100.0));
Assert.AreEqual(1, route.Segments.Values.Count);
Assert.AreEqual(100, route.Segments.Values[0].EndOffset);
Assert.AreEqual(0, route.Segments.Values[0].Offset);
}
public void LocationAreUniqueIsCorrect()
{
//take a input coverage e.g depth Ci
//take a route coverage Cr
//result is Function dependend of X with components equal to the components of Ci
//where x is distance along Cr
var network = CreateThreeNodesNetwork();
NetworkCoverage source = new NetworkCoverage { Network = network };
source[new NetworkLocation(network.Branches[0], 10.0)] = 10;
source[new NetworkLocation(network.Branches[0], 50.0)] = 30;
source[new NetworkLocation(network.Branches[1], 50.0)] = 20;
source[new NetworkLocation(network.Branches[1], 150.0)] = 10;
NetworkCoverage returningRoute = new NetworkCoverage
{
Network = network,
SegmentGenerationMethod = SegmentGenerationMethod.RouteBetweenLocations
};
//route going back to branch 0
returningRoute.Locations.Values.Add(new NetworkLocation(network.Branches[0], 5.0));
returningRoute.Locations.Values.Add(new NetworkLocation(network.Branches[1], 60.0));
returningRoute.Locations.Values.Add(new NetworkLocation(network.Branches[0], 10.0));
Assert.IsFalse((RouteHelper.LocationsAreUniqueOnRoute(source, returningRoute)));
NetworkCoverage singleRoute = new NetworkCoverage
{
Network = network,
SegmentGenerationMethod = SegmentGenerationMethod.SegmentBetweenLocations
};
//route going one way
singleRoute.Locations.Values.Add(new NetworkLocation(network.Branches[0], 5.0));
singleRoute.Locations.Values.Add(new NetworkLocation(network.Branches[1], 60.0));
Assert.IsTrue((RouteHelper.LocationsAreUniqueOnRoute(source, singleRoute)));
}
public void ExtractTimeSliceUseLocationsFromTarget()
{
var network = GetNetwork();
var networkCoverage = new NetworkCoverage("test", true) { Network = network };
DateTime[] dateTimes = new DateTime[10];
for (int i = 0; i < 10; i++)
{
dateTimes[i] = new DateTime(2000, 1, 1, 1, /* minute */i, 0);
networkCoverage[dateTimes[i], new NetworkLocation(network.Branches[0], 10.0)] = 10.0 + i;
networkCoverage[dateTimes[i], new NetworkLocation(network.Branches[0], 50.0)] = 50.0 + i;
networkCoverage[dateTimes[i], new NetworkLocation(network.Branches[0], 90.0)] = 90.0 + i;
networkCoverage[dateTimes[i], new NetworkLocation(network.Branches[1], 10.0)] = 110.0 + i;
networkCoverage[dateTimes[i], new NetworkLocation(network.Branches[1], 50.0)] = 150.0 + i;
networkCoverage[dateTimes[i], new NetworkLocation(network.Branches[1], 90.0)] = 190.0 + i;
}
var slice = new NetworkCoverage("slice", false) { Network = network };
Assert.AreEqual(false, slice.IsTimeDependent);
slice[new NetworkLocation(network.Branches[0], 20.0)] = 2;
slice[new NetworkLocation(network.Branches[0], 80.0)] = 8;
slice[new NetworkLocation(network.Branches[1], 20.0)] = 12;
slice[new NetworkLocation(network.Branches[1], 80.0)] = 18;
NetworkCoverageHelper.ExtractTimeSlice(networkCoverage, slice,
new DateTime(2000, 1, 1, 1, /* minute */0, 0), false);
// expected results at time step 0 are 20 80 120 180; this are interpolated values
Assert.AreEqual(4, slice.Locations.Values.Count);
Assert.AreEqual(10 /*20*/, slice.Evaluate(new NetworkLocation(network.Branches[0], 20.0)), 1.0e-6);
Assert.AreEqual(50 /*80*/, slice.Evaluate(new NetworkLocation(network.Branches[0], 80.0)), 1.0e-6);
Assert.AreEqual(90 /*120*/, slice.Evaluate(new NetworkLocation(network.Branches[1], 20.0)), 1.0e-6);
Assert.AreEqual(110 /*180*/, slice.Evaluate(new NetworkLocation(network.Branches[1], 80.0)), 1.0e-6);
NetworkCoverageHelper.ExtractTimeSlice(networkCoverage, slice,
new DateTime(2000, 1, 1, 1, /* minute */3, 0), false);
// expected results at time step 3 are 23 83 123 183; this are interpolated values
Assert.AreEqual(4, slice.Locations.Values.Count);
Assert.AreEqual(13 /*23*/, slice.Evaluate(new NetworkLocation(network.Branches[0], 20.0)), 1.0e-6);
Assert.AreEqual(53 /*83*/, slice.Evaluate(new NetworkLocation(network.Branches[0], 80.0)), 1.0e-6);
Assert.AreEqual(93 /*123*/, slice.Evaluate(new NetworkLocation(network.Branches[1], 20.0)), 1.0e-6);
Assert.AreEqual(113 /*183*/, slice.Evaluate(new NetworkLocation(network.Branches[1], 80.0)), 1.0e-6);
}
public void GetRouteLength()
{
var network = CreateThreeNodesNetwork();
NetworkCoverage route = new NetworkCoverage
{
Network = network,
SegmentGenerationMethod = SegmentGenerationMethod.RouteBetweenLocations
};
route.Locations.AutoSort = false;
//route going back to branch 0
route.Locations.Values.Add(new NetworkLocation(network.Branches[0], 5.0));
route.Locations.Values.Add(new NetworkLocation(network.Branches[1], 60.0));
route.Locations.Values.Add(new NetworkLocation(network.Branches[0], 10.0));
Assert.AreEqual(305.0, RouteHelper.GetRouteLength(route));
}
public void UpdateSegmentsForSegmentBetweenLocationsReversed()
{
var network = GetNetwork();
NetworkCoverage route = new NetworkCoverage
{
Network = network,
SegmentGenerationMethod = SegmentGenerationMethod.SegmentBetweenLocations
};
route.Locations.IsAutoSorted = false;
route.Locations.Values.Add(new NetworkLocation(network.Branches[0], 60.0));
route.Locations.Values.Add(new NetworkLocation(network.Branches[0], 40.0));
route.Locations.Values.Add(new NetworkLocation(network.Branches[0], 5.0));
// expect location not to be sorted
// [ 60-----40
// 40-----------------5
//NetworkCoverageHelper.UpdateSegments(route);
Assert.AreEqual(2, route.Segments.Values.Count);
Assert.AreEqual(60.0, route.Segments.Values[0].Chainage);
Assert.AreEqual(40.0, route.Segments.Values[0].EndChainage);
Assert.IsFalse(route.Segments.Values[0].DirectionIsPositive);
Assert.AreEqual(40.0, route.Segments.Values[1].Chainage);
Assert.AreEqual(5.0, route.Segments.Values[1].EndChainage);
Assert.IsFalse(route.Segments.Values[1].DirectionIsPositive);
}
