public void LoadData()
{
var ret = Data;
bool firstTime = false;
if (ret == null)
{
Data = ret = ZoneSystemHelper.CreatePDTwinArray <float>(Root.ZoneSystem.ZoneArray);
firstTime = true;
}
var data = ret.GetFlatData();
// initialize the data
if (data.Length > 0)
{
if (firstTime)
{
for (int i = 0; i < data.Length; i++)
{
var row = data[i];
for (int j = 0; j < row.Length; j++)
{
row[j] = 1.0f;
}
}
}
// now load in our kfactors
for (int i = 0; i < Factors.Length; i++)
{
data[ret.GetFlatIndex(Factors[i].OriginPD)][ret.GetFlatIndex(Factors[i].DestinationPD)] = Factors[i].Factor;
}
}
Loaded = true;
}
private void CreateHighPerformanceLookup(SparseArray <IZone> zoneArray)
{
if (HighPerformanceMap == null)
{
var pds = ZoneSystemHelper.CreatePdArray <int>(zoneArray);
var pdIndexes = pds.ValidIndexArray();
HighPerformanceMap = new int[pdIndexes.Max() + 1][];
Parallel.For(0, HighPerformanceMap.Length, i =>
{
var row = HighPerformanceMap[i] = new int[HighPerformanceMap.Length];
for (int j = 0; j < row.Length; j++)
{
int index = -1;
for (int k = 0; k < Segments.Length; k++)
{
if (Segments[k].OriginPDs.Contains(i) && Segments[k].DestinationPDs.Contains(j))
{
index = k;
break;
}
}
row[j] = index;
}
});
}
}
public void LoadData()
{
var zoneArray = Root.ZoneSystem.ZoneArray;
var zones = zoneArray.GetFlatData();
var resources = ResourcesToAdd.Select(resource => resource.AquireResource <SparseArray <float> >().GetFlatData()).ToArray();
SparseArray <float> data;
data = SaveRatesBasedOnPD ? ZoneSystemHelper.CreatePDArray <float>(zoneArray) : zoneArray.CreateSimilarArray <float>();
var flatData = data.GetFlatData();
if (VectorHelper.IsHardwareAccelerated)
{
for (int j = 0; j < resources.Length; j++)
{
VectorHelper.Add(flatData, 0, flatData, 0, resources[j], 0, flatData.Length);
}
}
else
{
for (int j = 0; j < resources.Length; j++)
{
var currentResource = resources[j];
for (int i = 0; i < currentResource.Length; i++)
{
flatData[i] += currentResource[i];
}
}
}
Data = data;
}
public void IterationStarting(int iteration)
{
var zoneSystem = _zones = Root.ZoneSystem.ZoneArray;
var pdMap = _pds = ZoneSystemHelper.CreatePdArray <float>(zoneSystem);
var numberOfPds = pdMap.GetFlatData().Length;
var numberOfZones = zoneSystem.GetFlatData().Length;
// 4 employment statuses
_zonalResidence = new float[4][][];
_zonalWorkerCategories = new float[4][][][][];
_zonalEmployment = new float[4][][];
for (int emp = 0; emp < _zonalWorkerCategories.Length; emp++)
{
// 4 occupation categories
_zonalResidence[emp] = new float[4][];
_zonalEmployment[emp] = new float[4][];
_zonalWorkerCategories[emp] = new float[4][][][];
for (int occ = 0; occ < _zonalWorkerCategories[emp].Length; occ++)
{
_zonalResidence[emp][occ] = new float[numberOfZones];
_zonalEmployment[emp][occ] = new float[numberOfZones];
_zonalWorkerCategories[emp][occ] = new float[numberOfZones][][];
for (int i = 0; i < _zonalWorkerCategories[emp][occ].Length; i++)
{
_zonalWorkerCategories[emp][occ][i] = new float[numberOfZones][];
for (int j = 0; j < _zonalWorkerCategories[emp][occ][i].Length; j++)
{
_zonalWorkerCategories[emp][occ][i][j] = new float[3];
}
}
}
}
}
public void Start()
{
if (FirstTime || LoadTruthEveryTime)
{
ZoneSystem.LoadData();
foreach (var network in NetworkData)
{
network.LoadData();
}
truth = TruthData.AcquireResource <SparseTwinIndex <float> >().GetFlatData();
TruthData.ReleaseResource();
}
var model = ModelData.AcquireResource <SparseTriIndex <float> >().GetFlatData();
var zones = ZoneSystem.ZoneArray.GetFlatData();
// sum up the truth
if (FirstTime || LoadTruthEveryTime)
{
// we only need to do this once
TruthRows = (from row in truth
select row.Sum()).ToArray();
InverseOfTotalTrips = 1.0f / TruthRows.Sum();
if (AggregateToPlanningDistricts)
{
PDError = ZoneSystemHelper.CreatePDTwinArray <float>(ZoneSystem.ZoneArray);
ZoneToPDIndexMap = (from zone in zones
select PDError.GetFlatIndex(zone.PlanningDistrict)).ToArray();
// transform the truth to be PD based
truth = AggregateResults((new float[][][] { truth }), zones)
.Select(row => row.Select(element => element).ToArray()).ToArray();
}
FirstTime = false;
}
var aggregated = AggregateResults(model, zones);
// calculate the error
float error = ComputeError(truth, aggregated);
// set the value in the root
Root.RetrieveValue = () => error;
if (ModelSaveFile != null)
{
SaveData.SaveMatrix(zones, AggregateResults(model, zones), ModelSaveFile);
}
if (this.DistanceHistogram != null)
{
var distances = ZoneSystem.Distances.GetFlatData();
this.DistanceHistogram.Export(distances, model);
}
ModelData.ReleaseResource();
for (int i = 0; i < PostRun.Length; i++)
{
PostRun[i].Start();
}
}
public void IterationStarting(int iteration)
{
var zoneSystem = Root.ZoneSystem.ZoneArray;
// initialize data structures
HouseholdsByZone = zoneSystem.CreateSimilarArray <List <ITashaHousehold> >();
HouseholdsByRegion = ZoneSystemHelper.CreateRegionArray <List <ITashaHousehold> >(zoneSystem);
SetupSpatialListByElement(HouseholdsByZone.GetFlatData());
SetupSpatialListByElement(HouseholdsByRegion.GetFlatData());
}
public void IterationStarting(int iteration)
{
// initialize data structures
_householdsByPD = ZoneSystemHelper.CreatePdArray <PDData>(Root.ZoneSystem.ZoneArray);
var flat = _householdsByPD.GetFlatData();
for (int i = 0; i < flat.Length; i++)
{
flat[i] = new PDData(_householdsByPD.GetSparseIndex(i));
}
}
public void BuildMatrix()
{
//build the region constants
var planningDistricts = ZoneSystemHelper.CreatePdArray <float>(Root.ZoneSystem.ZoneArray);
var pdIndexes = planningDistricts.ValidIndexArray();
PlanningDistrictConstants = planningDistricts.CreateSquareTwinArray <float>();
var data = PlanningDistrictConstants.GetFlatData();
for (int i = 0; i < data.Length; i++)
{
for (int j = 0; j < data[i].Length; j++)
{
data[i][j] = GetPDConstant(pdIndexes[i], pdIndexes[j]);
}
}
}
public void Load()
{
_zoneSystem = Root.ZoneSystem.ZoneArray;
_planningDistricts = ZoneSystemHelper.CreatePdArray <float>(_zoneSystem);
Zones = _zoneSystem.GetFlatData();
if (SaveWorkerCategory != null)
{
WorkerResults = new float[3][];
for (int i = 0; i < WorkerResults.Length; i++)
{
WorkerResults[i] = new float[Zones.Length];
}
}
_linkages = Linkages.AcquireResource <SparseTriIndex <float> >();
CopyLinkages(_linkages);
SaveLinkagesToFile(_linkages.GetFlatData());
Linkages.ReleaseResource();
}
public void LoadData()
{
var ret = Data;
if (ret == null)
{
Data = ret = ZoneSystemHelper.CreatePdTwinArray <float>(Root.ZoneSystem.ZoneArray);
}
var data = ret.GetFlatData();
// initialize the data
if (data.Length > 0)
{
for (int i = 0; i < data.Length; i++)
{
var row = data[i];
for (int j = 0; j < row.Length; j++)
{
row[j] = 1.0f;
}
}
// now load in our kfactors
for (int o = 0; o < data.Length; o++)
{
var sparseO = ret.GetSparseIndex(o);
for (int d = 0; d < data.Length; d++)
{
var sparseD = ret.GetSparseIndex(d);
foreach (var factor in Factors)
{
if (factor.OriginPD.Contains(sparseO) && factor.DestinationPD.Contains(sparseD))
{
if (data[o][d] != 1.0f)
{
Console.WriteLine($"Warning: In {Name}, multiple KFactors are altering PD{sparseO} to PD{sparseD}!");
}
data[o][d] *= factor.Factor;
}
}
}
}
}
Loaded = true;
}
public void LoadData()
{
var zoneArray = Root.ZoneSystem.ZoneArray;
var resources = ResourcesToAdd.Select(resource => resource.AcquireResource <SparseArray <float> >().GetFlatData()).Union(
ResourcesToAddRaw.Select(source =>
{
source.LoadData();
var ret = source.GiveData();
source.UnloadData();
return(ret.GetFlatData());
})
).ToArray();
SparseArray <float> data;
data = SaveRatesBasedOnPD ? ZoneSystemHelper.CreatePdArray <float>(zoneArray) : zoneArray.CreateSimilarArray <float>();
var flatData = data.GetFlatData();
for (int j = 0; j < resources.Length; j++)
{
VectorHelper.Add(flatData, 0, flatData, 0, resources[j], 0, flatData.Length);
}
Data = data;
}
public void Start()
{
var distances = GetDistances();
var demand = GetDemand();
if (!ZoneSystemHelper.IsSameZoneSystem(demand, distances))
{
throw new XTMFRuntimeException(this, "The zone systems for the demand and distance matrices are not the same!");
}
float intrazonal = 0f;
float pastBins = 0f;
var flatDistances = distances.GetFlatData();
var flatDemand = demand.GetFlatData();
var bins = new float[Bins];
var strideInMeters = Stride * 1000;
// Store the demand into the correct bins
for (int i = 0; i < flatDemand.Length; i++)
{
for (int j = 0; j < flatDemand[i].Length; j++)
{
if (i != j)
{
var index = (int)(flatDistances[i][j] / strideInMeters);
if (index >= bins.Length)
{
pastBins += flatDemand[i][j];
}
else
{
bins[index] += flatDemand[i][j];
}
}
else
{
intrazonal += flatDemand[i][j];
}
}
}
// Save the results to file
try
{
using (var writer = new StreamWriter(SaveTo))
{
writer.WriteLine("Min,Max,Value");
writer.Write("intrazonal,0,");
writer.WriteLine(intrazonal);
for (int i = 0; i < bins.Length; i++)
{
writer.Write(i * Stride);
writer.Write(',');
writer.Write((i + 1) * Stride);
writer.Write(',');
writer.WriteLine(bins[i]);
}
writer.Write(Stride * bins.Length);
writer.Write(",inf,");
writer.WriteLine(pastBins);
}
}
catch (IOException e)
{
throw new XTMFRuntimeException(this, e, $"Unable to write to the file at location '{SaveTo.GetFilePath()}' {e.Message}");
}
}
/// <summary>
/// Gather the data for each PD from the database
/// </summary>
/// <param name="employmentStatusChar">The employment code we want to look at</param>
/// <param name="command">The command / connection to use</param>
/// <param name="zones">The zone system to extract PD's for</param>
/// <returns>The occupation data stored per PD</returns>
private SparseArray <float[]> Execute(char employmentStatusChar, IDbCommand command, SparseArray <IZone> zones)
{
var pds = ZoneSystemHelper.CreatePDArray <float[]>(zones);
command.CommandText = @"
SELECT Persons.EmploymentStatus, PlanningDistrict.PD, Persons.Occupation, SUM(Persons.ExpansionFactor) AS ExpandedPersons
FROM (((Households INNER JOIN Persons ON Households.TTSYear = Persons.TTSYear AND Households.HouseholdId = Persons.HouseholdId)
INNER JOIN HouseholdZones ON Households.TTSYear = HouseholdZones.TTSYear AND Households.HouseholdId = HouseholdZones.HouseholdId)
INNER JOIN PlanningDistrict ON HouseholdZones.ZoneSystem = PlanningDistrict.ZoneSystem AND HouseholdZones.Zone = PlanningDistrict.Zone)
" + "WHERE Households.TTSYear = " + this.TTSYear + " AND HouseholdZones.ZoneSystem = " + this.ZoneSystemNumber + " AND (Persons.EmploymentStatus = '" + employmentStatusChar + "' )"
+ @" AND Persons.Occupation <> '9'
GROUP BY Persons.EmploymentStatus, PlanningDistrict.PD, Persons.Occupation
ORDER BY Persons.EmploymentStatus ASC, PlanningDistrict.PD ASC, Persons.Occupation ASC;
";
using (var reader = command.ExecuteReader())
{
while (reader.Read())
{
var pd = reader.GetInt32(1);
var occ = reader.GetString(2);
bool exists = true;
var data = pds[pd];
if (data == null)
{
if (pds.ContainsIndex(pd))
{
exists = false;
data = new float[4];
}
else
{
continue;
}
}
int index;
switch (occ)
{
case "P":
index = 0;
break;
case "G":
index = 1;
break;
case "S":
index = 2;
break;
case "M":
index = 3;
break;
default:
continue;
}
data[index] = (float)reader.GetDouble(3);
if (!exists)
{
pds[pd] = data;
}
}
}
return(pds);
}
