private void RunSerial(int iteration)
{
if (LoadAllHouseholds)
{
var households = HouseholdLoader.ToArray();
NumberOfHouseholds = households.Length;
Console.WriteLine(StartingHouseholds);
for (int i = 0; i < households.Length; i++)
{
ITashaHousehold hhld = households[i];
Run(iteration, hhld);
}
}
else
{
if (iteration >= 1)
{
HouseholdLoader.Reset();
}
Console.WriteLine(StartingHouseholds);
foreach (var hhld in HouseholdLoader)
{
Run(iteration, hhld);
}
Console.WriteLine(FinishedProcessingHouseholds);
}
}
public void Start()
{
Status = "Loading Data";
ZoneSystem.LoadData();
if (PostHousehold != null)
{
foreach (var module in PostHousehold)
{
module.Load(TotalIterations);
}
}
for (int i = 0; i < TotalIterations; i++)
{
CurrentHousehold = 0;
HouseholdLoader.LoadData();
RunIteration(i);
}
if (PostRun != null)
{
foreach (var module in PostRun)
{
module.Start();
}
}
ZoneSystem.UnloadData();
}
public void Start()
{
ZoneSystem.LoadData();
HouseholdLoader.LoadData();
var hhlds = HouseholdLoader.ToArray();
System.Threading.Tasks.Parallel.ForEach(AllModes, delegate(ITashaMode mode)
{
var am = ZoneSystem.ZoneArray.CreateSquareTwinArray <float>();
var pm = ZoneSystem.ZoneArray.CreateSquareTwinArray <float>();
var ff = ZoneSystem.ZoneArray.CreateSquareTwinArray <float>();
Status = "Calculating All Modes";
CreateData(hhlds, mode, am, pm, ff);
Status = "Writing to Files...";
Progress = 0;
WriteData(am, MatrixNumber, mode.ModeName + "AM.311");
Progress = (float)0.33;
WriteData(pm, MatrixNumber, mode.ModeName + "PM.311");
Progress = (float)0.66;
WriteData(ff, MatrixNumber, mode.ModeName + "FF.311");
Progress = 1;
});
ZoneSystem.UnloadData();
}
public void Start()
{
Status = "Loading Data";
for (int i = 0; i < ResultsArray.Length; i++)
{
ResultsArray[i] = new float[MaxFrequencyLocal + 1];
}
ZoneSystem.LoadData();
if (PostHousehold != null)
{
foreach (var module in PostHousehold)
{
module.Load(TotalIterations);
}
}
IterationPercentage = 1f / TotalIterations;
for (int i = 0; i < TotalIterations; i++)
{
CurrentHousehold = 0;
CompletedIterationPercentage = i * IterationPercentage;
HouseholdLoader.LoadData();
RunIteration(i);
}
if (PostRun != null)
{
foreach (var module in PostRun)
{
module.Start();
}
}
ZoneSystem.UnloadData();
}
public void Start()
{
ZoneSystem.LoadData();
if (PostHousehold != null)
{
foreach (var module in PostHousehold)
{
module.Load(TotalIterations);
}
}
IterationPercentage = 1f / TotalIterations;
//if (this.Scheduler != null)
//{
//this.Scheduler.LoadOneTimeLocalData();
//}
for (int i = 0; i < TotalIterations; i++)
{
CurrentHousehold = 0;
CompletedIterationPercentage = i * IterationPercentage;
HouseholdLoader.LoadData();
RunIteration(i);
}
if (PostRun != null)
{
foreach (var module in PostRun)
{
module.Start();
}
}
ZoneSystem.UnloadData();
}
private void RunSerial(int iteration)
{
var households = HouseholdLoader.ToArray();
for (int i = 0; i < households.Length; i++)
{
ITashaHousehold household = households[i];
Run(iteration, household);
}
}
private void RunIteration(int i)
{
if (NetworkData != null)
{
System.Threading.Tasks.Parallel.ForEach(NetworkData,
delegate(INetworkData network)
{
network.LoadData();
});
}
if (PostScheduler != null)
{
foreach (var module in PostScheduler)
{
module.IterationStarting(i);
}
}
if (PostHousehold != null)
{
foreach (var module in PostHousehold)
{
module.IterationStarting(i);
}
}
RunSerial();
if (NetworkData != null)
{
foreach (var network in NetworkData)
{
network.UnloadData();
}
}
if (PostScheduler != null)
{
foreach (var module in PostScheduler)
{
module.IterationFinished(i);
}
}
if (PostHousehold != null)
{
foreach (var module in PostHousehold)
{
module.IterationFinished(i);
}
}
HouseholdLoader.Reset();
}
private void RunParallel(int iteration)
{
var hhlds = HouseholdLoader.ToArray();
System.Threading.Tasks.Parallel.For(0, hhlds.Length,
delegate(int i)
{
ITashaHousehold hhld = hhlds[i];
Run(iteration, hhld);
}
);
}
private void RunIteration(int i)
{
foreach (var network in NetworkData)
{
network.LoadData();
}
if (PostScheduler != null)
{
foreach (var module in PostScheduler)
{
module.IterationStarting(i);
}
}
if (PostHousehold != null)
{
foreach (var module in PostHousehold)
{
module.IterationStarting(i);
}
}
RunSerial(i);
if (NetworkData != null)
{
foreach (var network in NetworkData)
{
network.UnloadData();
}
}
if (PostScheduler != null)
{
foreach (var module in PostScheduler)
{
module.IterationFinished(i);
}
}
if (PostHousehold != null)
{
foreach (var module in PostHousehold)
{
module.IterationFinished(i);
}
}
HouseholdLoader.Reset();
}
private void RunSerial()
{
Status = "Calculating Start Time Distributions";
Progress = 0;
var households = HouseholdLoader.ToArray();
for (int i = 0; i < households.Length; i++)
{
ITashaHousehold household = households[i];
Run(household);
Progress = (float)i / households.Length;
}
ModifyStartTimes();
PrintResults();
}
private void RunSerial(int iteration)
{
Status = "Calculating Distributions...";
Progress = 0;
var households = HouseholdLoader.ToArray();
for (int i = 0; i < households.Length; i++)
{
ITashaHousehold household = households[i];
Run(iteration, household);
Progress = (float)i / households.Length;
}
ModifyResults();
SaveResults();
}
public void Start()
{
ResultsArray = new float[NumberOfDistributionsLocal][][];
for (int i = 0; i < ResultsArray.Length; i++)
{
ResultsArray[i] = new float[MaxFrequencyLocal + 1][];
for (int j = 0; j < ResultsArray[i].Length; j++)
{
ResultsArray[i][j] = new float[StartTimeQuantums];
}
}
Status = "Loading Data";
ZoneSystem.LoadData();
if (PostHousehold != null)
{
foreach (var module in PostHousehold)
{
module.Load(TotalIterations);
}
}
IterationPercentage = 1f / TotalIterations;
for (int i = 0; i < TotalIterations; i++)
{
CurrentHousehold = 0;
CompletedIterationPercentage = i * IterationPercentage;
HouseholdLoader.LoadData();
RunIteration(i);
}
if (PostRun != null)
{
foreach (var module in PostRun)
{
module.Start();
}
}
ZoneSystem.UnloadData();
}
private void RunParallel(int iteration)
{
if (LoadAllHouseholds)
{
var hhlds = HouseholdLoader.ToArray();
NumberOfHouseholds = hhlds.Length;
if (hhlds == null)
{
return;
}
Console.WriteLine(StartingHouseholds);
System.Threading.Tasks.Parallel.For(0, hhlds.Length, new ParallelOptions()
{
MaxDegreeOfParallelism = Environment.ProcessorCount
},
delegate(int i)
{
ITashaHousehold hhld = hhlds[i];
Run(iteration, hhld);
});
Console.WriteLine(FinishedProcessingHouseholds);
}
else
{
Console.WriteLine(StartingHouseholds);
System.Threading.Tasks.Parallel.ForEach(HouseholdLoader, new ParallelOptions()
{
MaxDegreeOfParallelism = Environment.ProcessorCount
},
delegate(ITashaHousehold household)
{
Run(iteration, household);
});
if (CurrentHousehold != NumberOfHouseholds)
{
NumberOfHouseholds = CurrentHousehold;
}
Console.WriteLine(FinishedProcessingHouseholds);
}
}
private void RunSerial()
{
Status = "Calculating Duration/Start Time distributions...";
Progress = 0;
var households = HouseholdLoader.ToArray();
NumberOfHouseholds = households.Length;
for (int i = 0; i < households.Length; i++)
{
ITashaHousehold household = households[i];
Run(household);
Progress = (float)i / households.Length;
}
if (SmoothDurations)
{
System.Threading.Tasks.Parallel.For(0, ResultsArray.Length, id =>
{
// for each start time smooth the distributions
for (int start = 0; start < ResultsArray[id].Length; start++)
{
var originalRow = ResultsArray[id][start];
var smoothedRow = new float[originalRow.Length];
for (int i = 0; i < originalRow.Length; i++)
{
for (int j = 0; j < smoothedRow.Length; j++)
{
var distanceFactor = 1.0f / (Math.Abs(i - j) * DistanceFactor + 1.0f);
smoothedRow[j] += originalRow[i] * distanceFactor;
}
}
ResultsArray[id][start] = smoothedRow;
}
});
}
ModifyDurationsTimes();
PrintResults();
}
private void BuildHouseholdData()
{
// We actually don't need to startup the networks since we don't need their data.
// We just need them so we know that the modes will be satisfied when running
ZoneSystem.LoadData();
HouseholdLoader.LoadData();
var households = HouseholdLoader.ToArray();
VehicleTypes.Add(AutoType);
using (MemoryStream mem = new MemoryStream())
{
BinaryWriter writer = new BinaryWriter(mem);
writer.Write(households.Length);
var numberOfVehicleTypes = VehicleTypes.Count;
writer.Write(numberOfVehicleTypes);
for (int i = 0; i < numberOfVehicleTypes; i++)
{
writer.Write(VehicleTypes[i].VehicleName);
}
foreach (var household in households)
{
// write out all of the household attributes
writer.Write(household.HouseholdId);
writer.Write(household.Persons.Length);
for (int i = 0; i < numberOfVehicleTypes; i++)
{
writer.Write(household.Vehicles.Count((v) => v.VehicleType.VehicleName == VehicleTypes[i].VehicleName));
}
writer.Write(household.HomeZone.ZoneNumber);
SendAttached(writer, household);
foreach (var person in household.Persons)
{
// Send the person's information
writer.Write(person.Age);
writer.Write(person.Female);
writer.Write((Int32)person.EmploymentStatus);
writer.Write((Int32)person.Occupation);
if (person.EmploymentZone == null)
{
writer.Write(-1);
}
else
{
writer.Write(person.EmploymentZone.ZoneNumber);
}
writer.Write((Int32)person.StudentStatus);
if (person.SchoolZone == null)
{
writer.Write(-1);
}
else
{
writer.Write(person.SchoolZone.ZoneNumber);
}
writer.Write(person.Licence);
writer.Write(person.FreeParking);
SendAttached(writer, person);
// Start sending the trip chains
writer.Write(person.TripChains.Count);
foreach (var tripChain in person.TripChains)
{
writer.Write(tripChain.JointTripID);
writer.Write(tripChain.JointTripRep);
SendAttached(writer, tripChain);
writer.Write(tripChain.Trips.Count);
foreach (var trip in tripChain.Trips)
{
writer.Write(trip.OriginalZone.ZoneNumber);
writer.Write(trip.DestinationZone.ZoneNumber);
writer.Write((Int32)trip.Purpose);
writer.Write(trip.ActivityStartTime.Hours);
writer.Write(trip.ActivityStartTime.Minutes);
writer.Write(trip.ActivityStartTime.Seconds);
var mode = ((ITashaMode)trip[ObservedMode]);
if (mode == null)
{
throw new XTMFRuntimeException(this, "In household #" + household.HouseholdId
+ " for Person #" + person.Id + " for Trip #" + trip.TripNumber + " there was no observed mode stored!");
}
writer.Write(mode.ModeName);
SendAttached(writer, trip);
}
}
}
}
writer.Flush();
HouseholdData = mem.ToArray();
}
}
private void RunSerial()
{
Status = "Calculating Distributions...";
var households = HouseholdLoader.ToArray();
var resultList = new BlockingCollection <Result>();
var saveResultsTask = System.Threading.Tasks.Task.Factory.StartNew(() =>
{
// setup data
float[][] combinedResults = new float[6][];
for (int i = 0; i < combinedResults.Length; i++)
{
combinedResults[i] = new float[NumberOfAdults];
}
//process results
foreach (var result in resultList.GetConsumingEnumerable())
{
int offset;
if (result.Children)
{
offset = result.Adults >= 3 ? 0 : 1;
}
else
{
offset = 2;
}
var jointOther = combinedResults[offset];
for (int i = 0; i < jointOther.Length; i++)
{
jointOther[i] += result.JointOthersAdults[i] * result.ExpansionFactor;
}
var jointMarket = combinedResults[offset + 3];
for (int i = 0; i < jointOther.Length; i++)
{
jointMarket[i] += result.JointMarketAdults[i] * result.ExpansionFactor;
}
}
// save results
//NO HEADER
//DistributionID,NumberOfAdults,ExpandedSum,Probability,CDF
using (StreamWriter writer = new StreamWriter(ResultFile.GetFilePath()))
{
for (int dist = 0; dist < combinedResults.Length; dist++)
{
var cdf = 0.0;
var factor = 0.0;
// get sum of expansions
for (int i = 0; i < combinedResults[dist].Length; i++)
{
factor += combinedResults[dist][i];
}
// compute factor
factor = 1 / factor;
if (double.IsInfinity(factor) | double.IsNaN(factor))
{
factor = 0;
}
for (int i = 0; i < combinedResults[dist].Length; i++)
{
var probability = combinedResults[dist][i] * factor;
cdf += probability;
writer.Write(dist);
writer.Write(',');
writer.Write(i);
writer.Write(',');
writer.Write(combinedResults[dist][i]);
writer.Write(',');
writer.Write(combinedResults[dist][i] * factor);
writer.Write(',');
writer.WriteLine(cdf);
}
}
}
});
System.Threading.Tasks.Parallel.For(0, households.Length, i =>
{
Run(households[i], resultList);
});
resultList.CompleteAdding();
saveResultsTask.Wait();
}
public void Start()
{
// setup the status to be initializing
_Status = null;
_Progress = () => 0f;
CurrentIteration = 0;
if (!VehicleTypes.Contains(AutoType))
{
VehicleTypes.Add(AutoType);
}
ZoneSystem.LoadData();
if (PreRun != null)
{
foreach (var module in PreRun)
{
module.Start();
}
}
IterationPercentage = 1f / TotalIterations;
if (PostScheduler != null)
{
foreach (var module in PostScheduler)
{
module.Load(TotalIterations);
}
}
if (PostHousehold != null)
{
foreach (var module in PostHousehold)
{
module.Load(TotalIterations);
}
}
if (OverrideModeParameters)
{
InitializeParameters();
}
LoadNetworkData(0);
if (Scheduler != null)
{
Scheduler.LoadOneTimeLocalData();
}
if (ModeChoice != null)
{
ModeChoice.LoadOneTimeLocalData();
}
for (int i = 0; i < TotalIterations; i++)
{
if (!_ExitRequested)
{
CurrentHousehold = 0;
CurrentIteration = i;
CompletedIterationPercentage = i * IterationPercentage;
if (LoadAllHouseholds)
{
if (!SkipLoadingHouseholds)
{
HouseholdLoader.LoadData();
}
}
RunIteration(i);
}
}
if (PostRun != null)
{
foreach (var module in PostRun)
{
module.Start();
}
}
ZoneSystem.UnloadData();
}
private void RunIteration(int i)
{
if (NetworkData != null)
{
try
{
System.Threading.Tasks.Parallel.ForEach(NetworkData,
delegate(INetworkData network)
{
network.LoadData();
});
}
catch (AggregateException e)
{
if (e.InnerException != null)
{
throw e.InnerException;
}
}
}
if (PostScheduler != null)
{
foreach (var module in PostScheduler)
{
module.IterationStarting(i);
}
}
if (PostHousehold != null)
{
foreach (var module in PostHousehold)
{
module.IterationStarting(i);
}
}
if (Parallel)
{
RunParallel(i);
}
else
{
RunSerial(i);
}
if (NetworkData != null)
{
foreach (var network in NetworkData)
{
network.UnloadData();
}
}
if (PostScheduler != null)
{
foreach (var module in PostScheduler)
{
module.IterationFinished(i);
}
}
if (PostHousehold != null)
{
foreach (var module in PostHousehold)
{
module.IterationFinished(i);
}
}
HouseholdLoader.Reset();
}
