private SparseArray <float> BuildDistrictRadius()
{
List <int> districts = new List <int>();
List <float> radiusList = new List <float>();
using (CsvReader reader = new CsvReader(this.GetFullPath(this.DistrictRadiusFile)))
{
// burn header
reader.LoadLine( );
while (!reader.EndOfFile)
{
// make sure that we actually loaded data in
if (reader.LoadLine( ) == 0)
{
continue;
}
// if we have data process it
int district;
float radius;
reader.Get(out district, 0);
reader.Get(out radius, 1);
districts.Add(district);
radiusList.Add(radius);
}
}
return(SparseArray <float> .CreateSparseArray(districts.ToArray(), radiusList));
}
private static SparseArray <IZone> InitializeZones(SparseArray <Node> nodes)
{
var flatNodes = nodes.GetFlatData();
List <int> centroids = new List <int>();
for (int i = 0; i < flatNodes.Length; i++)
{
if (flatNodes[i].IsCentroid)
{
centroids.Add(flatNodes[i].Number);
}
}
var centroidIndexes = centroids.ToArray();
var flatzones = new IZone[centroidIndexes.Length];
for (int i = 0; i < centroidIndexes.Length; i++)
{
HOTZone zone = new HOTZone();
var node = nodes[centroidIndexes[i]];
// update the centroid indexes to the sparse space
zone.ZoneNumber = (short)centroidIndexes[i];
zone.X = node.X;
zone.Y = node.Y;
flatzones[i] = zone;
}
return(SparseArray <IZone> .CreateSparseArray(centroidIndexes, flatzones));
}
public void LoadData()
{
var map = ModuleHelper.GetDataFromDatasourceOrResource(ZoneMapFromDataSource, ZoneMapFromResource, UnloadZoneSource);
var zoneData = ModuleHelper.GetDataFromDatasourceOrResource(ODDataFromDataSource, ODDataFromResource, UnloadODDataSource).GetFlatData();
var bins = map.MapValues.ToArray();
var mapOd = SparseArray <float> .CreateSparseArray(bins, null).CreateSquareTwinArray <float>();
var flatMapData = mapOd.GetFlatData();
var toZones = map.KeyToZoneIndex;
for (int originBin = 0; originBin < bins.Length; originBin++)
{
var originZones = toZones[bins[originBin]];
for (int i = 0; i < originZones.Count; i++)
{
var originRow = zoneData[originZones[i]];
for (int destinationBin = 0; destinationBin < bins.Length; destinationBin++)
{
var destinationZones = toZones[bins[destinationBin]];
for (int j = 0; j < destinationZones.Count; j++)
{
flatMapData[originBin][destinationBin] += originRow[destinationZones[j]];
}
}
}
}
Data = mapOd;
}
public void CreateSquareTwinArrayTest()
{
var length = 1000;
Random r = new Random();
int[] baseData = new int[length * length];
int[][] position = GeneratePositions(1, length);
for (int i = 0; i < length; i++)
{
baseData[i] = r.Next();
}
var sparseArray = SparseArray <int> .CreateSparseArray(position[0], new int[length]);
var twinArray = sparseArray.CreateSquareTwinArray <int>();
for (int i = 0; i < length; i++)
{
for (int j = 0; j < length; j++)
{
twinArray[position[0][i], position[0][j]] = baseData[i * length + j];
}
}
for (int i = 0; i < length; i++)
{
for (int j = 0; j < length; j++)
{
if (baseData[i * length + j] != twinArray[position[0][i], position[0][j]])
{
Assert.Fail($"{baseData[i]} != {twinArray[position[0][i], position[0][j]]}");
}
}
}
}
public void CreateSquareTwinArrayTest()
{
var length = 1000;
Random r = new Random();
int[] BaseData = new int[length * length];
int[][] Position = GeneratePositions(1, length);
for (int i = 0; i < length; i++)
{
BaseData[i] = r.Next();
}
var sparseArray = SparseArray <int> .CreateSparseArray(Position[0], new int[length]);
var twinArray = sparseArray.CreateSquareTwinArray <int>();
for (int i = 0; i < length; i++)
{
for (int j = 0; j < length; j++)
{
twinArray[Position[0][i], Position[0][j]] = BaseData[i * length + j];
}
}
for (int i = 0; i < length; i++)
{
for (int j = 0; j < length; j++)
{
if (BaseData[i * length + j] != twinArray[Position[0][i], Position[0][j]])
{
Assert.Fail(String.Format("{0} != {1}", BaseData[i], twinArray[Position[0][i], Position[0][j]]));
}
}
}
}
private SparseArray <string> LinearStringComaSplit(string str)
{
string[] parts = str.Split(',');
int[] place = new int[parts.Length];
for (int i = 0; i < place.Length; i++)
{
place[i] = i;
}
return(SparseArray <string> .CreateSparseArray(place, parts));
}
private void LoadZones()
{
var zoneFile = GetZoneFilePath();
if (!File.Exists(zoneFile))
{
throw new XTMFRuntimeException(this, $"Unable to find a file with the path '{zoneFile}' to load zones from!");
}
List <IZone> zones = new List <IZone>(2500);
var maxColumnSize = 0;
using (var reader = new CsvReader(zoneFile, false))
{
// burn the header
reader.LoadLine();
while (reader.LoadLine(out var columns))
{
maxColumnSize = Math.Max(maxColumnSize, columns);
if (columns >= 23)
{
reader.Get(out int zoneNumber, 0);
reader.Get(out int pd, 1);
reader.Get(out float population, 2);
reader.Get(out float x, 14);
reader.Get(out float y, 15);
reader.Get(out float internalDistance, 16);
reader.Get(out float parkingCost, 21);
zones.Add(new Zone(zoneNumber)
{
PlanningDistrict = pd,
Population = (int)Math.Round(population),
X = x,
Y = y,
InternalDistance = internalDistance,
ParkingCost = parkingCost
});
}
}
}
// check for errors
if (maxColumnSize > 0 && maxColumnSize < 23)
{
throw new XTMFRuntimeException(this, $"When reading the zones there was no row with 23 columns, the maximum size was {maxColumnSize}!");
}
if (zones.Count <= 0)
{
throw new XTMFRuntimeException(this, $"No zones were loaded when reading in the zone file from '{zoneFile}'!");
}
// make sure the zones are in order
zones.Sort((first, second) => (first.ZoneNumber.CompareTo(second.ZoneNumber)));
AllZones = SparseArray <IZone> .CreateSparseArray(zones.Select(z => z.ZoneNumber).ToArray(), zones.ToArray());
}
public void TestSimpleGravityModelSolution()
{
var data = CreateData();
var gm = new GravityModel(data, null, 0.0f, 300);
var o = SparseArray <float> .CreateSparseArray(new[] { 1, 2 }, new float[] { 2, 2 });
var d = SparseArray <float> .CreateSparseArray(new[] { 1, 2 }, new[] { 1.5f, 2.5f });
var ret = gm.ProcessFlow(o, d, new[] { 1, 2 });
var result = ret.GetFlatData();
Assert.AreEqual(0.5f, result[0][0], 0.0001f);
Assert.AreEqual(1.5f, result[0][1], 0.0001f);
Assert.AreEqual(1f, result[1][0], 0.0001f);
Assert.AreEqual(1f, result[1][1], 0.0001f);
}
private SparseArray <int> CreateRegionArray()
{
var zones = Root.ZoneSystem.ZoneArray.GetFlatData();
List <int> regionNumbersFound = new List <int>(10);
for (int i = 0; i < zones.Length; i++)
{
var regionId = zones[i].RegionNumber;
if (!regionNumbersFound.Contains(regionId))
{
regionNumbersFound.Add(regionId);
}
}
var regionArray = regionNumbersFound.ToArray();
return(SparseArray <int> .CreateSparseArray(regionArray, regionArray));
}
public static SparseArray <T> CreateRegionArray <T>(SparseArray <IZone> zoneArray)
{
var zones = zoneArray.GetFlatData();
List <int> regionNumbersFound = new List <int>(10);
for (int i = 0; i < zones.Length; i++)
{
var regionId = zones[i].RegionNumber;
if (!regionNumbersFound.Contains(regionId))
{
regionNumbersFound.Add(regionId);
}
}
var regionArray = regionNumbersFound.ToArray();
return(SparseArray <T> .CreateSparseArray(regionArray, new T[regionArray.Length]));
}
public static SparseArray <T> CreatePdArray <T>(SparseArray <IZone> zoneArray)
{
var zones = zoneArray.GetFlatData();
List <int> pdNumbersFound = new List <int>(10);
for (int i = 0; i < zones.Length; i++)
{
var pdId = zones[i].PlanningDistrict;
if (!pdNumbersFound.Contains(pdId))
{
pdNumbersFound.Add(pdId);
}
}
var pdArray = pdNumbersFound.ToArray();
return(SparseArray <T> .CreateSparseArray(pdArray, new T[pdArray.Length]));
}
private SparseArray <int> CreatePDArray()
{
var zones = this.Root.ZoneSystem.ZoneArray.GetFlatData();
List <int> pdNumbersFound = new List <int>(10);
for (int i = 0; i < zones.Length; i++)
{
var pdID = zones[i].PlanningDistrict;
if (!pdNumbersFound.Contains(pdID))
{
pdNumbersFound.Add(pdID);
}
}
var pdArray = pdNumbersFound.ToArray();
return(SparseArray <int> .CreateSparseArray(pdArray, pdArray));
}
public void SparseArrayTest()
{
var length = 1000000;
Random r = new Random();
int[] baseData = new int[length];
int[][] position = GeneratePositions(1, length);
for (int i = 0; i < length; i++)
{
baseData[i] = r.Next();
}
var sparseData = SparseArray <int> .CreateSparseArray(position[0], baseData);
for (int i = 0; i < length; i++)
{
if (baseData[i] != sparseData[position[0][i]])
{
Assert.Fail($"{baseData[position[0][i]]} != {sparseData[position[0][i]]}");
}
}
}
public void SparseArrayTest()
{
var length = 1000000;
Random r = new Random();
int[] BaseData = new int[length];
int[][] Position = GeneratePositions(1, length);
for (int i = 0; i < length; i++)
{
BaseData[i] = r.Next();
}
var sparseData = SparseArray <int> .CreateSparseArray(Position[0], BaseData);
for (int i = 0; i < length; i++)
{
if (BaseData[i] != sparseData[Position[0][i]])
{
Assert.Fail(String.Format("{0} != {1}", BaseData[Position[0][i]], sparseData[Position[0][i]]));
}
}
}
public void LookupPerformanceTwinArray()
{
var length = 1000;
Random r = new Random();
int[] baseData = new int[length * length];
int[][] position = GeneratePositions(1, length);
for (int i = 0; i < length; i++)
{
baseData[i] = r.Next();
}
var sparseArray = SparseArray <int> .CreateSparseArray(position[0], new int[length]);
var twinArray = sparseArray.CreateSquareTwinArray <int>();
for (int i = 0; i < length; i++)
{
for (int j = 0; j < length; j++)
{
twinArray[position[0][i], position[0][j]] = baseData[i * length + j];
}
}
Stopwatch watch = Stopwatch.StartNew();
{
for (int i = 0; i < length; i++)
{
for (int j = 0; j < length; j++)
{
if (baseData[i * length + j] != twinArray[position[0][i], position[0][j]])
{
Assert.Fail($"{baseData[i]} != {twinArray[position[0][i], position[0][j]]}");
}
}
}
}
watch.Stop();
Console.WriteLine(watch.ElapsedMilliseconds + "ms");
}
private void LoadZones()
{
if (!File.Exists(NWPLocation))
{
throw new XTMFRuntimeException(this, $"Unable to find a network package at the location '{NWPLocation.GetFilePath()}'!");
}
using (ZipArchive archive = new ZipArchive(File.OpenRead(NWPLocation), ZipArchiveMode.Read, false))
{
foreach (var entry in archive.Entries)
{
if (entry.Name.Equals("base.211", StringComparison.InvariantCultureIgnoreCase))
{
using (var reader = new StreamReader(entry.Open()))
{
string line = null;
const string nodesMarker = "t nodes";
while ((line = reader.ReadLine()) != null && line != nodesMarker)
{
;
}
if (line != nodesMarker)
{
throw new XTMFRuntimeException(this, $"While reading in a zone system from {NWPLocation.GetFilePath()} we did not encounter the start of nodes!");
}
// burn the header
reader.ReadLine();
var seperators = new char[] { ' ', '\t' };
List <Zone> zones = new List <Zone>(2500);
while ((line = reader.ReadLine()) != null && line[0] != 't')
{
// ignore blank lines
if (line.Length > 2)
{
// if it is a centroid
if (line[0] == 'a' && line[1] == '*')
{
var split = line.Split(seperators, StringSplitOptions.RemoveEmptyEntries);
if (split.Length < 3)
{
throw new XTMFRuntimeException(this, $"Failed to load the line '{line}' when reading in zones.");
}
if (!(int.TryParse(split[1], out int zoneNumber) &&
float.TryParse(split[2], out float x) &&
float.TryParse(split[3], out float y)))
{
throw new XTMFRuntimeException(this, $"Failed to load the line '{line}' when reading in zones.");
}
zones.Add(new Zone(zoneNumber, x, y));
}
}
}
zones.Sort((z1, z2) => z1.ZoneNumber.CompareTo(z2.ZoneNumber));
AllZones = SparseArray <IZone> .CreateSparseArray(zones.Select(z => z.ZoneNumber).ToArray(), zones.ToArray());
return;
}
}
}
}
throw new XTMFRuntimeException(this, $"The network package located at '{NWPLocation.GetFilePath()}' did not contain a base.211 file to load the zones from!");
}
/// <summary>
/// Load the network from a 211 file
/// </summary>
/// <param name="fileName211"></param>
public void LoadNetwork(string fileName211)
{
Dictionary <int, Node> nodes = new Dictionary <int, Node>();
Dictionary <Pair <int, int>, Link> links = new Dictionary <Pair <int, int>, Link>();
using (StreamReader reader = new StreamReader(fileName211))
{
string line = null;
// run until we get to the link information
while ((line = reader.ReadLine()) != null)
{
string[] parts = line.Split(SplitCharacters, StringSplitOptions.RemoveEmptyEntries);
try
{
var numberOfParts = parts.Length;
if (numberOfParts >= 3 && parts[0].Length > 0)
{
int offset = -1;
if (parts[0][0] == 'a')
{
offset = 0;
}
else if (parts[0][0] == 'c')
{
continue;
}
Node node = new Node();
if (offset == -1)
{
node.IsCentroid = false;
}
else
{
node.IsCentroid = (parts[0].Length >= 2 && parts[0] == "a*");
}
node.Number = int.Parse(parts[1 + offset]);
node.X = float.Parse(parts[2 + offset]);
node.Y = float.Parse(parts[3 + offset]);
if (numberOfParts > 4 + offset)
{
node.USER1 = int.Parse(parts[4 + offset]);
if (numberOfParts > 5 + offset)
{
node.USER2 = int.Parse(parts[5 + offset]);
if (numberOfParts > 6 + offset)
{
node.NodeType = int.Parse(parts[6 + offset]);
node.Modified = false;
if (parts.Length > 7 + offset)
{
node.NodeLabel = parts[7 + offset];
}
else
{
node.NodeLabel = node.Number.ToString();
}
}
}
}
nodes.Add(node.Number, node);
}
}
catch { }
if (line != null && line.StartsWith("t links"))
{
break;
}
}
while ((line = reader.ReadLine()) != null)
{
try
{
string[] parts = line.Split(SplitCharacters, StringSplitOptions.RemoveEmptyEntries);
if (parts.Length > 7)
{
Link link;
link.I = int.Parse(parts[1]);
link.J = int.Parse(parts[2]);
link.Length = float.Parse(parts[3]);
link.Modes = parts[4].ToLower().ToCharArray();
link.LinkType = int.Parse(parts[5]);
link.Lanes = float.Parse(parts[6]);
link.VDF = float.Parse(parts[7]);
// We don't load [8]
link.Speed = float.Parse(parts[9]);
link.Capacity = float.Parse(parts[10]);
link.Modified = false;
links.Add(new Pair <int, int>(link.I, link.J), link);
}
}
catch { }
}
}
// Now that we have loaded the data it is time to create the sparse structures
var numberOfLinks = links.Count;
var first = new int[numberOfLinks];
var second = new int[numberOfLinks];
var data = new Link[numberOfLinks];
int i = 0;
foreach (var l in links.Values)
{
first[i] = l.I;
second[i] = l.J;
data[i] = l;
i++;
}
if (nodes.Values.Count == 0)
{
this.Nodes = null;
}
else
{
this.Nodes = SparseArray <Node> .CreateSparseArray((n => n.Number), nodes.Values.ToArray());
}
if (numberOfLinks == 0)
{
this.Links = null;
}
else
{
this.Links = SparseTwinIndex <Link> .CreateTwinIndex(first, second, data);
}
}
