/// <summary>
/// Resolve the scheduling conflicts for the household
/// </summary>
/// <param name="household">The household to resolve</param>
public static ModeAssignmentHouseHold ResolveConflicts(this ITashaHousehold household)
{
if (!TestForNullModeSet(household))
{
return(ModeAssignmentHouseHold.NULL_SET);
}
if (TestForSimpleCase(household)) //more vehicles than people
{
// do what we need to do to assign vehicles to everyone
//DoAssignment(household);
return(ModeAssignmentHouseHold.SIMPLE_CASE);
}
if (TestForAdvancedCase(household)) //more vehicles than overlaps
{
//DoAssignment(household);
return(ModeAssignmentHouseHold.SIMPLE_CASE);
}
// resort to the complex case
IVehicleType[] bestAssignment = FindBestPossibleAssignment(household.AllTripChains(), new List <IVehicle>(household.Vehicles));
if (bestAssignment == null)
{
return(ModeAssignmentHouseHold.NULL_SET);
}
return(ModeAssignmentHouseHold.ADVANCED_CASE);
}
/// <summary>
/// Adds the auxiliary trip chain to the person if enough vehicles are available
/// </summary>
/// <param name="household"></param>
/// <param name="optimalSets"></param>
private void AddPassengerTrips(ITashaHousehold household, Dictionary <ITashaPerson, List <ITripChain> > optimalSets)
{
foreach (var optSet in optimalSets)
{
ITashaPerson person = optSet.Key;
List <ITripChain> optimalSet = optSet.Value;
if (person.AuxTripChains == null)
{
person.AuxTripChains = new List <ITripChain>(5);
}
else
{
person.AuxTripChains.Clear();
}
var length = optimalSet.Count;
for (int i = 0; i < length; i++)
{
var vehicles = optimalSet[i].RequiresVehicle;
var vehiclesLength = vehicles.Count;
for (int j = 0; j < vehiclesLength; j++)
{
if (household.NumberOfVehicleAvailable(new TashaTimeSpan(optimalSet[i].StartTime, optimalSet[i].EndTime), vehicles[j], true) > 0)
{
person.AuxTripChains.Add(optimalSet[i]);
}
}
}
}
}
public void HouseholdIterationComplete(ITashaHousehold household, int hhldIteration, int totalHouseholdIterations)
{
// Gather the number of household iterations
HouseholdIterations = totalHouseholdIterations;
// now execute
Execute(household, hhldIteration);
}
public void Execute(ITashaHousehold household, int iteration)
{
var persons = household.Persons;
bool taken = false;
WriteLock.Enter(ref taken);
for(int i = 0; i < persons.Length; i++)
{
var expanionFactor = persons[i].ExpansionFactor;
var tripChains = persons[i].TripChains;
for(int j = 0; j < tripChains.Count; j++)
{
var tripChain = tripChains[j].Trips;
for(int k = 0; k < tripChain.Count; k++)
{
var mode = tripChain[k].Mode;
for(int l = 0; l < Modes.Length; l++)
{
if(Modes[l] == mode)
{
Counts[l] += expanionFactor;
break;
}
}
}
}
}
if(taken) WriteLock.Exit(true);
}
public void Execute(ITashaHousehold household)
{
lock ( this )
{
var householdData = household["SData"] as Tasha.Scheduler.SchedHouseholdData;
ResultDict["JointMarket"] += household.ExpansionFactor * householdData.JointMarketProject.Schedule.EpisodeCount;
NumberDict["JointMarket"] += householdData.JointMarketProject.Schedule.EpisodeCount;
ResultDict["JointOther"] += household.ExpansionFactor * householdData.JointOtherProject.Schedule.EpisodeCount;
NumberDict["JointOther"] += householdData.JointOtherProject.Schedule.EpisodeCount;
foreach ( var person in household.Persons )
{
var schedData = person["SData"];
var personData = person["SData"] as Tasha.Scheduler.SchedulerPersonData;
var workSched = personData.WorkSchedule.Schedule;
var schoolSched = personData.SchoolSchedule.Schedule;
var marketSched = personData.MarketSchedule.Schedule;
var otherSched = personData.OtherSchedule.Schedule;
ResultDict["Work"] += household.ExpansionFactor * workSched.EpisodeCount;
NumberDict["Work"] += workSched.EpisodeCount;
ResultDict["School"] += schoolSched.EpisodeCount * household.ExpansionFactor;
NumberDict["School"] += schoolSched.EpisodeCount;
ResultDict["Market"] += marketSched.EpisodeCount * household.ExpansionFactor;
NumberDict["Market"] += marketSched.EpisodeCount;
ResultDict["Other"] += household.ExpansionFactor * otherSched.EpisodeCount;
NumberDict["Other"] += otherSched.EpisodeCount;
}
}
}
public void Execute(ITashaHousehold household, int iteration)
{
lock (this)
{
foreach (var person in household.Persons)
{
foreach (var tripChain in person.TripChains)
{
foreach (var trip in tripChain.Trips)
{
var householdIterations = trip.ModesChosen == null ? 1 : trip.ModesChosen.Length;
for (int i = 0; i < householdIterations; i++)
{
if (trip.ModesChosen?[i] == null)
{
Validate1.Write("UnsolvedModeChoice,Household#=");
Validate1.WriteLine(household.HouseholdId);
}
else
{
if (trip.ModesChosen[i].ModeName == "Auto" && !person.Licence)
{
Validate1.Write("NoLicenseAutoSelected,Household#=");
Validate1.Write(household.HouseholdId);
Validate1.Write("Person#=");
Validate1.WriteLine(Array.IndexOf(household.Persons, person));
}
}
}
}
}
}
}
}
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 Execute(ITashaHousehold household, int iteration)
{
var zoneSystem = Root.ZoneSystem.ZoneArray;
var homeIndex = zoneSystem.GetFlatIndex(household.HomeZone.ZoneNumber);
foreach (var person in household.Persons)
{
var expansionFactor = person.ExpansionFactor;
var occ = person.Occupation;
Dictionary <TTSEmploymentStatus, float[][]> occDictionary;
if (occ != Occupation.NotEmployed && Data.TryGetValue(occ, out occDictionary))
{
float[][] empData;
if (occDictionary.TryGetValue(person.EmploymentStatus, out empData))
{
var zone = person.EmploymentZone;
if (zone != null)
{
var employmentZone = zoneSystem.GetFlatIndex(zone.ZoneNumber);
if (employmentZone >= 0)
{
var row = empData[homeIndex];
bool taken = false;
WriteLock.Enter(ref taken);
row[employmentZone] += expansionFactor;
if (taken)
{
WriteLock.Exit(true);
}
}
}
}
}
}
}
private static void AssignFeasibility(ITashaHousehold household)
{
//loop through each trip in the household and assign all possible auxiliary trips
var modes = TashaRuntime.SharedModes;
var nonSharedModes = TashaRuntime.NonSharedModes.Count;
var modesLength = modes.Count;
// clear out all of the aux trip chains to begin with
var persons = household.Persons;
for (int i = 0; i < persons.Length; i++)
{
persons[i].AuxTripChains.Clear();
}
for (int i = 0; i < persons.Length; i++)
{
var tripChains = persons[i].TripChains;
for (int j = 0; j < tripChains.Count; j++)
{
var trips = tripChains[j].Trips;
for (int k = 0; k < trips.Count; k++)
{
ModeData md = ModeData.Get(trips[k]); //get the mode data saved on the object
for (int l = 0; l < modesLength; l++)
{
if (!(md.Feasible[l + nonSharedModes] = modes[l].Feasible(trips[k])))
{
}
}
}
}
}
}
public void Execute(ITashaHousehold household, int iteration)
{
//Determine the worker category
int nVehicles = household.Vehicles.Length;
int nDrivers = household.Persons.Count((ITashaPerson p) => p.Licence);
int wcat;
if (nVehicles == 0)
{
wcat = 0;
}
else
{
wcat = (nVehicles > nDrivers) ? 2 : 1;
}
foreach (var person in household.Persons)
{
var empStat = person.EmploymentStatus;
if (empStat == TMG.TTSEmploymentStatus.FullTime | empStat == TMG.TTSEmploymentStatus.PartTime) continue; //Skip unemployed persons
IZone employmentZone = person.EmploymentZone;
if ( employmentZone == null ) continue;
var distance = (int) (this._ZoneDistances[household.HomeZone.ZoneNumber, employmentZone.ZoneNumber] * this.CoordinateFactor);
int index = this.HistogramBins.IndexOf(distance);
if (index < 0)
{
index = this.HistogramBins.Count;
}
bool taken = false;
WriteLock.Enter(ref taken);
this._BinData[index][wcat] += person.ExpansionFactor;
if (taken) WriteLock.Exit(true);
}
}
public void HouseholdComplete(ITashaHousehold household, bool success)
{
if (success)
{
lock (this)
{
var writeHeader = !File.Exists(OutputFile);
using (StreamWriter writer = new StreamWriter(OutputFile, true))
{
if (writeHeader)
{
writer.WriteLine("HouseholdID,HouseholdIteration,Household Utility");
}
var util = Utilities[household.HouseholdId];
for (int i = 0; i < util.Length; i++)
{
writer.Write(household.HouseholdId);
writer.Write(',');
writer.Write(i);
writer.Write(',');
writer.WriteLine(util[i]);
}
}
}
}
else
{
throw new XTMFRuntimeException(this, "A household was not able to be resolved.");
}
}
private void Run(ITashaHousehold household)
{
int[][][] eventCount = new int[NumberOfDistributionsLocal][][];
bool invalidHousehold = false;
var numberOfPeople = household.Persons.Length;
Time[] workStartTimes = new Time[numberOfPeople];
Time[] workEndTimes = new Time[numberOfPeople];
for (int p = 0; p < numberOfPeople; p++)
{
AssignEpisodes(household.Persons[p], ref workStartTimes[p], ref workEndTimes[p], null);
}
System.Threading.Tasks.Parallel.For(0, numberOfPeople, delegate(int personNumber)
{
ITashaPerson person = household.Persons[personNumber];
Time workStartTime = workStartTimes[personNumber];
Time workEndTime = workEndTimes[personNumber];
FirstPass(eventCount, ref invalidHousehold, person);
AddPimaryWorkEpisode(person, eventCount, workStartTime, workEndTime);
LunchPass(person, eventCount, workStartTime, workEndTime);
});
// check to see if we have an invalid household, if we do we do not add the data!
if (invalidHousehold)
{
return;
}
StoreResults(household.ExpansionFactor, eventCount);
Interlocked.Increment(ref CurrentHousehold);
Progress = ((float)CurrentHousehold / NumberOfHouseholds) / TotalIterations + CompletedIterationPercentage;
household.Recycle();
}
/// <summary>
/// turn household activities into trip chains
/// </summary>
/// <param name="household"></param>
/// <param name="householdIterations"></param>
/// <param name="minimumAtHomeTime"></param>
internal static void BuildChains(this ITashaHousehold household, int householdIterations, Time minimumAtHomeTime)
{
foreach (var person in household.Persons)
{
BuildPersonChain(person, householdIterations, minimumAtHomeTime);
}
}
internal static void AddHouseholdProjects(this ITashaHousehold household, Schedule schedule, Random random)
{
for (int i = 0; i < schedule.EpisodeCount; i++)
{
var episode = (Episode)schedule.Episodes[i];
episode.ContainingSchedule = schedule;
var people = episode.People;
if (people != null)
{
bool first = true;
IZone zone = null;
foreach (var person in people)
{
var pData = (SchedulerPersonData)person["SData"];
//var check = pData.Schedule.EpisodeCount > 0;
var ep = new ActivityEpisode(new TimeWindow(episode.StartTime, episode.EndTime) /*window*/,
schedule.Episodes[i].ActivityType, person);
if (first)
{
pData.Schedule.Insert(ep, random);
zone = ep.Zone;
first = false;
}
else
{
pData.Schedule.Insert(ep, zone);
pData.Schedule.CheckEpisodeIntegrity();
}
}
}
}
}
public void Execute(ITashaHousehold household, int iteration)
{
foreach(var period in TimePeriods)
{
period.Execute(household);
}
}
internal static void GeneratePersonSchedules(this ITashaHousehold household, Random random, int householdIterations, Time minimumAtHomeTime)
{
var data = (household["SData"] as SchedHouseholdData);
// Generate each person's schedule
foreach (var person in household.Persons)
{
person.GenerateWorkSchoolSchedule(random);
}
// Make each person attend the household level projects
household.AddHouseholdProjects(data, random);
//Generate other/market schedules
foreach (var person in household.Persons)
{
//person.Generate
person.AddPersonalProjects(random);
}
// Clean up the people's schedules
household.CleanupSchedules();
// Add in the trip chains here for each person
household.BuildChains(householdIterations, minimumAtHomeTime);
}
public void Execute(ITashaHousehold household, int iteration)
{
var autoNetworkData = this.Root.NetworkData.FirstOrDefault((network) => network.NetworkType == this.NetworkName);
var zones = this.Root.ZoneSystem.ZoneArray.GetFlatData();
if (autoNetworkData == null)
{
throw new XTMFRuntimeException("We could not find the '" + this.NetworkName + "' network!");
}
foreach (var person in household.Persons)
{
foreach (var tripChain in person.TripChains)
{
for (int i = 0; i < tripChain.Trips.Count - 1; i++)
{
var trip = tripChain.Trips[i];
var nextTrip = tripChain.Trips[i + 1];
if (trip.Purpose == Activity.Market && nextTrip.Purpose == Activity.Market)
{
var originIndex = this.Root.ZoneSystem.ZoneArray.GetFlatIndex(trip.OriginalZone.ZoneNumber);
// run my logic here
for (int j = 0; j < zones.Length; j++)
{
var travelTime = autoNetworkData.TravelTime(originIndex, j, trip.TripStartTime);
}
}
}
}
}
}
public void HouseholdComplete(ITashaHousehold household, bool success)
{
if ( success )
{
lock ( this )
{
var writeHeader = !File.Exists( OutputFile );
using ( StreamWriter writer = new StreamWriter( OutputFile, true ) )
{
if ( writeHeader )
{
writer.WriteLine( "HouseholdID,HouseholdIteration,Household Utility" );
}
var util = Utilities[household.HouseholdId];
for ( int i = 0; i < util.Length; i++ )
{
writer.Write( household.HouseholdId );
writer.Write( ',' );
writer.Write( i );
writer.Write( ',' );
writer.WriteLine( util[i] );
}
}
}
}
else
{
throw new XTMFRuntimeException( "A household was not able to be resolved." );
}
}
public void Execute(ITashaHousehold household)
{
lock (this)
{
var householdData = (Tasha.Scheduler.SchedHouseholdData)household["SData"];
ResultDict["JointMarket"] += household.ExpansionFactor * householdData.JointMarketProject.Schedule.EpisodeCount;
NumberDict["JointMarket"] += householdData.JointMarketProject.Schedule.EpisodeCount;
ResultDict["JointOther"] += household.ExpansionFactor * householdData.JointOtherProject.Schedule.EpisodeCount;
NumberDict["JointOther"] += householdData.JointOtherProject.Schedule.EpisodeCount;
foreach (var person in household.Persons)
{
var personData = (Tasha.Scheduler.SchedulerPersonData)person["SData"];
var workSched = personData.WorkSchedule.Schedule;
var schoolSched = personData.SchoolSchedule.Schedule;
var marketSched = personData.MarketSchedule.Schedule;
var otherSched = personData.OtherSchedule.Schedule;
ResultDict["Work"] += household.ExpansionFactor * workSched.EpisodeCount;
NumberDict["Work"] += workSched.EpisodeCount;
ResultDict["School"] += schoolSched.EpisodeCount * household.ExpansionFactor;
NumberDict["School"] += schoolSched.EpisodeCount;
ResultDict["Market"] += marketSched.EpisodeCount * household.ExpansionFactor;
NumberDict["Market"] += marketSched.EpisodeCount;
ResultDict["Other"] += household.ExpansionFactor * otherSched.EpisodeCount;
NumberDict["Other"] += otherSched.EpisodeCount;
}
}
}
public void Execute(ITashaHousehold household, int iteration)
{
var homeZone = _zones.GetFlatIndex(household.HomeZone.ZoneNumber);
foreach (var person in household.Persons)
{
int emp = GetEmp(person);
int occ = GetOcc(person);
if (ValidPerson(emp, occ))
{
var workerCategory = GetWorkerCategory(person, household);
var empZone = person.EmploymentZone;
if (empZone == null)
{
continue;
}
var flatEmpZone = _zones.GetFlatIndex(empZone.ZoneNumber);
float expansionFactor = person.ExpansionFactor;
_zonalEmployment[emp][occ][flatEmpZone] += expansionFactor;
if (!ExternalPDs.Contains(empZone.PlanningDistrict))
{
_zonalResidence[emp][occ][homeZone] += expansionFactor;
}
_zonalWorkerCategories[emp][occ][homeZone][flatEmpZone][workerCategory] += expansionFactor;
}
}
}
private void Run(int iteration, ITashaHousehold household)
{
var persons = household.Persons;
var eventCount = new int[NumberOfDistributionsLocal];
var addZero = new bool[NumberOfDistributionsLocal];
household.CreateHouseholdProjects();
for (int i = 0; i < persons.Length; i++)
{
persons[i].InitializePersonalProjects();
}
for (int i = 0; i < persons.Length; i++)
{
Time workStartTime;
Time workEndTime;
ITashaPerson person = household.Persons[i];
AssignWorkSchoolEpisodes(persons[i], out workStartTime, out workEndTime, null);
var primaryVehicle = PrimaryMode.RequiresVehicle;
for (int j = 0; j < addZero.Length; j++)
{
eventCount[j] = 0;
addZero[j] = false;
}
FirstPass(person, primaryVehicle, eventCount);
int lunches = LunchPass(person, eventCount, ref workStartTime, ref workEndTime);
AddWorkTrip(person, eventCount, addZero, ref workStartTime, ref workEndTime);
ProcessZeroes(person, workStartTime, eventCount, addZero, lunches);
// while adding the results back we need to do this in serial
StoreResults(person.ExpansionFactor, eventCount, addZero);
}
System.Threading.Interlocked.Increment(ref CurrentHousehold);
Progress = ((float)CurrentHousehold / NumberOfHouseholds) / TotalIterations + CompletedIterationPercentage;
household.Recycle();
}
public void HouseholdIterationComplete(ITashaHousehold household)
{
var persons = household.Persons;
foreach (var person in persons)
{
var tripChains = person.TripChains;
if (tripChains.Count > 0)
{
var personalModeChoices = OperatingOn[person];
var expansionFactor = person.ExpansionFactor;
foreach (var tripChain in tripChains)
{
foreach (var trip in tripChain.Trips)
{
// if the trip is within the catchment area record it
if (ContainedZones.Contains(trip.OriginalZone.ZoneNumber))
{
var startTime = trip.TripStartTime;
if (startTime >= StartTime && startTime < EndTime)
{
personalModeChoices[Root.Modes[trip.Mode]] += expansionFactor;
}
}
}
}
}
}
}
public static HouseholdWorkSchoolProjectStatus GetWorkSchoolProjectStatus(ITashaHousehold household)
{
bool evening_workschool = false;
bool morning_workschool = false;
bool any_workschool = false;
foreach(var person in household.Persons)
{
PersonWorkSchoolProjectStatus workschoolProjectStatus = SchedulerPerson.GetWorkSchoolProjectStatus(person);
if(workschoolProjectStatus == PersonWorkSchoolProjectStatus.FullTimeEveningWorkOrSchool ||
workschoolProjectStatus == PersonWorkSchoolProjectStatus.FullTimeDayAndEveningWorkOrSchool ||
workschoolProjectStatus == PersonWorkSchoolProjectStatus.Other)
evening_workschool = true;
if(workschoolProjectStatus == PersonWorkSchoolProjectStatus.FullTimeNoEveningWorkOrSchool ||
workschoolProjectStatus == PersonWorkSchoolProjectStatus.FullTimeDayAndEveningWorkOrSchool ||
workschoolProjectStatus == PersonWorkSchoolProjectStatus.PartTimeDay ||
workschoolProjectStatus == PersonWorkSchoolProjectStatus.PartTimeEvening)
morning_workschool = true;
if(workschoolProjectStatus > 0) any_workschool = true;
}
if(!any_workschool) return HouseholdWorkSchoolProjectStatus.NoWorkOrSchool; // noone in hhld works or attends school today
else if(!evening_workschool) return HouseholdWorkSchoolProjectStatus.NoEveningWorkOrSchool; //there is work/school, but none after 6:00pm
else if(!morning_workschool) return HouseholdWorkSchoolProjectStatus.EveningWorkOrSchool; //there is evening work/school, but no work/school before 1:00pm
else return HouseholdWorkSchoolProjectStatus.DayAndEveningWorkOrSchool; // there is work/school before 1pm and after 6pm
}
public void Execute(ITashaHousehold household, int iteration)
{
lock ( this )
{
foreach ( var person in household.Persons )
{
foreach ( var tripChain in person.TripChains )
{
foreach ( var trip in tripChain.Trips )
{
var householdIterations = trip.ModesChosen == null ? 1 : trip.ModesChosen.Length;
for ( int i = 0; i < householdIterations; i++ )
{
if ( trip.ModesChosen[i] == null )
{
this.Validate1.Write( "Problem in household #" );
this.Validate1.WriteLine( household.HouseholdId );
}
else
{
if ( trip.ModesChosen[i].ModeName == "Auto" )
{
Count += 1;
}
}
}
}
}
}
}
}
public void HouseholdComplete(ITashaHousehold household, bool success)
{
if (WriteThisIteration)
{
var householdNumber = household.HouseholdId;
lock (this)
{
int personNumber = 0;
foreach (var person in household.Persons)
{
personNumber++;
var tripNumber = 1;
foreach (var tripChain in person.TripChains)
{
var numberOfWorkTrips = tripChain.Trips.Count(trip => trip.Purpose == Activity.PrimaryWork || trip.Purpose == Activity.SecondaryWork || trip.Purpose == Activity.WorkBasedBusiness);
var numberOfTripInTour = tripChain.Trips.Count;
var trips = tripChain.Trips;
for (int i = 0; i < trips.Count; i++)
{
SaveTrip(tripChain, trips[i], householdNumber, personNumber,
tripNumber, numberOfWorkTrips, numberOfTripInTour, i);
tripNumber++;
}
}
}
}
}
}
public void Execute(ITashaHousehold household)
{
lock (this)
{
foreach (var person in household.Persons)
{
var expFactor = person.ExpansionFactor;
foreach (var tripChain in person.TripChains)
{
foreach (var trip in tripChain.Trips)
{
Dictionary <int, float> activityDictionary = GetDictionary(trip.Purpose);
int hour = trip.ActivityStartTime.Hours;
if (activityDictionary.ContainsKey(hour))
{
activityDictionary[hour] += expFactor;
}
else
{
activityDictionary.Add(hour, expFactor);
}
}
}
}
}
}
internal static void CheckAndUpdateLatestWorkingTime(this ITashaHousehold household, Time time)
{
if (((SchedHouseholdData)household["SData"]).LatestWorkingTime < time)
{
((SchedHouseholdData)household["SData"]).LatestWorkingTime = time;
}
}
/// <summary>
/// Gets the number of vehicles available in the household for the given timespan
/// </summary>
/// <param name="h"></param>
/// <param name="span"></param>
/// <param name="vehicleType"></param>
/// <param name="includeAuxTripChains"></param>
/// <returns></returns>
public static int NumberOfVehicleAvailable(this ITashaHousehold h, TashaTimeSpan span, IVehicleType vehicleType, bool includeAuxTripChains)
{
Dictionary <TashaTimeSpan, int> availabilities = h.FindVehicleAvailabilites(vehicleType, includeAuxTripChains);
var vehicles = h.Vehicles;
int available = 0;
for (int i = 0; i < vehicles.Length; i++)
{
if (vehicles[i].VehicleType == vehicleType)
{
available++;
}
}
foreach (var a in availabilities)
{
if ((a.Key.Start < span.End) && (a.Key.End > span.Start))
{
// this is strictly less than since we want the min of the vehicles
if (a.Value < available)
{
available = a.Value;
}
}
}
return(available);
}
public void Execute(ITashaHousehold household, int iteration)
{
var persons = household.Persons;
bool taken = false;
WriteLock.Enter(ref taken);
for (int i = 0; i < persons.Length; i++)
{
var expanionFactor = persons[i].ExpansionFactor;
var tripChains = persons[i].TripChains;
for (int j = 0; j < tripChains.Count; j++)
{
var tripChain = tripChains[j].Trips;
for (int k = 0; k < tripChain.Count; k++)
{
var mode = tripChain[k].Mode;
for (int l = 0; l < Modes.Length; l++)
{
if (Modes[l] == mode)
{
Counts[l] += expanionFactor;
break;
}
}
}
}
}
if (taken)
{
WriteLock.Exit(true);
}
}
public void Execute(ITashaHousehold household)
{
lock (this)
{
foreach(var person in household.Persons)
{
var expFactor = person.ExpansionFactor;
foreach(var tripChain in person.TripChains)
{
foreach(var trip in tripChain.Trips)
{
Dictionary<int, float> activityDictionary = GetDictionary(trip.Purpose);
int hour = trip.ActivityStartTime.Hours;
if(activityDictionary.ContainsKey(hour))
{
activityDictionary[hour] += expFactor;
}
else
{
activityDictionary.Add(hour, expFactor);
}
}
}
}
}
}
/// <summary>
/// Gets all the trip chains and auxiliary trip chains that use the specified vehicle
/// </summary>
/// <param name="household"></param>
/// <param name="vehicle"></param>
/// <returns></returns>
public static List <ITripChain> AllTripChainsWithAuxThatUseVehicle(this ITashaHousehold household, IVehicleType vehicle)
{
List <ITripChain> trips = new List <ITripChain>();
//flatten households trips
foreach (var p in household.Persons)
{
foreach (var tc in p.TripChains)
{
if (tc.requiresVehicle.Contains(vehicle))
{
trips.Add(tc);
}
}
foreach (var tc in p.AuxTripChains)
{
if (tc.requiresVehicle.Contains(vehicle))
{
trips.Add(tc);
}
}
}
return(trips);
}
public void Execute(ITashaHousehold household)
{
lock (this)
{
foreach (var person in household.Persons)
{
var expFactor = person.ExpansionFactor;
if (person["SData"] is SchedulerPersonData data)
{
var workSched = data.WorkSchedule.Schedule;
var schoolSched = data.SchoolSchedule.Schedule;
GatherData(workSched, WorkStartTime, true, expFactor);
GatherData(workSched, WorkEndTime, false, expFactor);
GatherData(schoolSched, SchoolStartTime, true, expFactor);
GatherData(schoolSched, SchoolEndTime, false, expFactor);
CalculateWorkingPersons(workSched, expFactor);
//GatherDuration( workSched, this.WorkDuration, false );
if (workSched.EpisodeCount > 0)
{
Time duration = workSched.Episodes[workSched.EpisodeCount - 1].EndTime - workSched.Episodes[0].StartTime;
int index = GetBucketIndex(duration);
if (index >= 0 && index < WorkStartTime.Length)
{
WorkDuration[index] += expFactor;
}
}
}
}
}
}
public void Execute(ITashaHousehold household, int iteration)
{
var persons = household.Persons;
for (int i = 0; i < persons.Length; i++)
{
if (persons[i].Age >= MinimumAge)
{
var expansionFactor = persons[i].ExpansionFactor;
var tripChains = persons[i].TripChains;
for (int j = 0; j < tripChains.Count; j++)
{
var tripChain = tripChains[j].Trips;
for (int k = 0; k < tripChain.Count; k++)
{
int index = (((int)(TripStartTime ? tripChain[k].TripStartTime : tripChain[k].ActivityStartTime).ToMinutes()) / 30);
var tripStartIndex = index < 0 ? (index % NumberOfTimeBins + NumberOfTimeBins) % NumberOfTimeBins : index % NumberOfTimeBins;
var array = GetPurposeCount(tripChain, k);
var tripModeIndex = GetTripModeIndex(tripChain[k].Mode);
if (tripModeIndex >= 0)
{
var row = array[tripStartIndex];
lock (array[tripStartIndex])
{
row[tripModeIndex] += expansionFactor;
}
}
}
}
}
}
}
internal IZone ProduceResult(Random random, ITashaHousehold household, ITashaPerson person)
{
var pop = (float)random.NextDouble();
var index = PickAZoneToSelect(pop, household, person, person.ExpansionFactor);
return(Zones[index]);
}
public void Execute(ITashaHousehold household, int iteration)
{
var persons = household.Persons;
for (int i = 0; i < persons.Length; i++)
{
if (persons[i].Age >= MinimumAge)
{
var expansionFactor = persons[i].ExpansionFactor;
var tripChains = persons[i].TripChains;
for (int j = 0; j < tripChains.Count; j++)
{
var tripChain = tripChains[j].Trips;
for (int k = 0; k < tripChain.Count; k++)
{
int index = (((int)(TripStartTime ? tripChain[k].TripStartTime : tripChain[k].ActivityStartTime).ToMinutes()) / 30);
var tripStartIndex = index < 0 ? (index % NumberOfTimeBins + NumberOfTimeBins) % NumberOfTimeBins : index % NumberOfTimeBins;
var array = GetPurposeCount(tripChain, k);
var tripModeIndex = GetTripModeIndex(tripChain[k].Mode);
if (tripModeIndex >= 0)
{
var row = array[tripStartIndex];
lock (array[tripStartIndex])
{
row[tripModeIndex] += expansionFactor;
}
}
}
}
}
}
}
public void HouseholdIterationComplete(ITashaHousehold household, int hhldIteration, int totalHouseholdIterations)
{
var persons = household.Persons;
lock (this)
{
foreach (var person in persons)
{
var expFactor = person.ExpansionFactor;
foreach (var tripChain in person.TripChains)
{
foreach (var trip in tripChain.Trips)
{
if (UsesModeToCheck(trip.Mode))
{
var startIndex = GetTimeBin(trip.TripStartTime);
if (startIndex >= 0)
{
TripBins[startIndex] += expFactor;
}
}
}
}
}
}
}
public static int GetFrequency(ITashaHousehold household, Activity activity, Random random, int maxFreq, int householdPD, int workPD, GenerationAdjustment[] generationAdjustments)
{
bool feasibleFreq = false;
int freq = maxFreq;
while (!feasibleFreq)
{
freq = Distribution.GetRandomFrequencyValue(
0, Distribution.NumberOfFrequencies - 1, random, Distribution.GetDistributionID(household, activity),
householdPD, workPD, generationAdjustments);
if (freq == 0)
{
feasibleFreq = true;
}
if (!Distribution.GetRandomStartTimeFrequency(
Distribution.GetDistributionID(household, activity), freq,
0, Scheduler.StartTimeQuanta - 1, random, out Time startTime))
{
// a bad thing happens here
}
else if (startTime != Time.StartOfDay)
{
feasibleFreq = true;
}
}
return(freq);
}
internal static bool GetDuration(ITashaHousehold household, Activity activity, Time startTime, Random random, out Time duration)
{
int length = Scheduler.StartTimeQuanta - 1 - Distribution.TimeOfDayToDistribution(startTime);
return(Distribution.GetRandomStartDurationTimeFrequency(Distribution.GetDistributionID(household, activity), startTime, 0, length, random,
out duration));
}
public void Execute(ITashaHousehold household, int iteration)
{
var autoNetworkData = this.Root.NetworkData.FirstOrDefault( (network) => network.NetworkType == this.NetworkName );
var zones = this.Root.ZoneSystem.ZoneArray.GetFlatData();
if ( autoNetworkData == null )
{
throw new XTMFRuntimeException( "We could not find the '" + this.NetworkName + "' network!" );
}
foreach ( var person in household.Persons )
{
foreach ( var tripChain in person.TripChains )
{
for ( int i = 0; i < tripChain.Trips.Count - 1; i++ )
{
var trip = tripChain.Trips[i];
var nextTrip = tripChain.Trips[i + 1];
if ( trip.Purpose == Activity.Market && nextTrip.Purpose == Activity.Market )
{
var originIndex = this.Root.ZoneSystem.ZoneArray.GetFlatIndex( trip.OriginalZone.ZoneNumber );
// run my logic here
for(int j = 0; j < zones.Length; j++)
{
var travelTime = autoNetworkData.TravelTime( originIndex, j, trip.TripStartTime );
}
}
}
}
}
}
public void Execute(ITashaHousehold household, int iteration)
{
lock ( this )
{
foreach ( var person in household.Persons )
{
foreach ( var tripChain in person.TripChains )
{
int CurrentNumberOfTrips = tripChain.Trips.Count;
if ( NumberOfTrips.ContainsKey( CurrentNumberOfTrips ) ) // Has this scenario occured previously?
{
NumberOfTrips[CurrentNumberOfTrips] += 1; // If it has, add one more occurence to it.
}
else
{
NumberOfTrips.Add( CurrentNumberOfTrips, 1 ); // If it hasn't, create the scenario and give it a value of one occurence at this point.
}
if ( CurrentNumberOfTrips == 1 )
{
throw new XTMFRuntimeException( "Household " + household.HouseholdId + " has a trip chain with only one trip. The trip chain belongs to person number " + person.Id );
}
}
}
}
}
private int ClassifyHousehold(ITashaHousehold household)
{
int category;
int zoneNumber = household.HomeZone.ZoneNumber;
if (TaxibotServedHouseholds.Contains(zoneNumber))
{
category = 2;
}
else
{
var numberOfLicenses = 0;
var numberOfVehicles = household.Vehicles.Length;
if (numberOfVehicles > 0)
{
var persons = household.Persons;
for (int i = 0; i < persons.Length; i++)
{
if (persons[i].Licence)
{
numberOfLicenses++;
}
}
}
category = numberOfLicenses == 0 ? 0 : (numberOfVehicles < numberOfLicenses ? 1 : 2);
}
if (SaveWorkerCategory != null)
{
RecordHouseholdCategory(category, zoneNumber, household.ExpansionFactor);
}
return(category);
}
public void HouseholdIterationComplete(ITashaHousehold household, int hhldIteration, int totalHouseholdIterations)
{
for ( int i = 0; i < household.Persons.Length; i++ )
{
for ( int j = 0; j < household.Persons[i].TripChains.Count; j++ )
{
if ( household.Persons[i].TripChains[j].JointTrip && !household.Persons[i].TripChains[j].JointTripRep )
{
continue;
}
for ( int k = 0; k < household.Persons[i].TripChains[j].Trips.Count; k++ )
{
var trip = household.Persons[i].TripChains[j].Trips[k];
if ( trip.Mode == this.Root.AllModes[PassengerIndex] )
{
using ( StreamWriter Writer = new StreamWriter( this.OutputFile, true ) )
{
var originalTrip = trip["Driver"] as ITrip;
var originalDistance = this.Root.ZoneSystem.Distances[originalTrip.OriginalZone.ZoneNumber, originalTrip.DestinationZone.ZoneNumber];
var passengerDistance = this.Root.ZoneSystem.Distances[trip.OriginalZone.ZoneNumber, trip.DestinationZone.ZoneNumber];
float firstLeg;
float secondLeg;
if ( originalTrip.OriginalZone == trip.OriginalZone )
{
firstLeg = 0;
}
if ( originalTrip.DestinationZone == trip.DestinationZone )
{
secondLeg = 0;
}
firstLeg = this.Root.ZoneSystem.Distances[originalTrip.OriginalZone.ZoneNumber, trip.OriginalZone.ZoneNumber];
secondLeg = this.Root.ZoneSystem.Distances[trip.DestinationZone.ZoneNumber, originalTrip.DestinationZone.ZoneNumber];
var newDistance = ( passengerDistance + firstLeg + secondLeg );
if ( Data.Keys.Contains( passengerDistance ) )
{
Data[passengerDistance].Add( newDistance );
}
else
{
Data.TryAdd( passengerDistance, new List<float>() );
Data[passengerDistance].Add( newDistance );
}
//Writer.WriteLine( "{0}, {1}, {2}, {3}, {4}", household.HouseholdId, household.Persons[i].Id, originalTrip.TripChain.Person.Id, passengerDistance, newDistance );
}
}
}
}
}
}
public void Execute(ITashaHousehold household, int iteration)
{
var householdFitness = (float)EvaluateHousehold(household);
bool taken = false;
FitnessUpdateLock.Enter(ref taken);
Thread.MemoryBarrier();
Fitness += householdFitness;
if(taken) FitnessUpdateLock.Exit(true);
}
public ModeChoiceHouseholdData(ITashaHousehold household, int numberOfModes, int numberOfVehicleTypes)
{
var persons = household.Persons;
var personData = PersonData = new ModeChoicePersonData[persons.Length];
for ( int i = 0; i < personData.Length; i++ )
{
personData[i] = new ModeChoicePersonData( persons[i].TripChains, numberOfModes, numberOfVehicleTypes );
}
}
public void Run(ITashaHousehold household)
{
Random householdRandom = new Random( this.Seed * household.HouseholdId );
var persons = household.Persons;
List<IActivityEpisode>[] episodes = InitializeEpisodes( persons );
GenerateEpisodes( household, householdRandom, persons, episodes );
OrderPriorities( episodes );
ScheduleEpisodes( household, householdRandom, persons, episodes );
}
public void Execute(ITashaHousehold household, int iteration)
{
var persons = household.Persons;
var pd = household.HomeZone.PlanningDistrict;
var expFactor = household.ExpansionFactor;
for ( int i = 0; i < persons.Length; i++ )
{
this.Data.AddEntry( persons[i], pd, expFactor );
}
}
/// <summary>
/// Creates a new person
/// </summary>
/// <param name="household">The household that this person belongs to, may not be null!</param>
/// <param name="id">The identifyer for this person</param>
/// <param name="age">The age of this person</param>
/// <param name="employmentStatus">How this person is employed, if at all</param>
/// <param name="studentStatus">If this person is a student, and if so what type of student</param>
/// <param name="female">Is this person female</param>
/// <param name="licence">Does this person have a driver's licence</param>
public Person(ITashaHousehold household, int id, int age, Occupation occupation, TTSEmploymentStatus employmentStatus, StudentStatus studentStatus, bool license, bool female)
: this()
{
this.Household = household;
this.Id = id;
this.Age = age;
this.Occupation = occupation;
this.EmploymentStatus = employmentStatus;
this.StudentStatus = studentStatus;
this.Licence = license;
this.Female = female;
}
/// <summary>
/// Creates a new person
/// </summary>
/// <param name="household">The household that this person belongs to, may not be null!</param>
/// <param name="id">The identifyer for this person</param>
/// <param name="age">The age of this person</param>
/// <param name="employmentStatus">How this person is employed, if at all</param>
/// <param name="studentStatus">If this person is a student, and if so what type of student</param>
/// <param name="female">Is this person female</param>
/// <param name="licence">Does this person have a driver's licence</param>
public Person(ITashaHousehold household, int id, int age, Occupation occupation, TTSEmploymentStatus employmentStatus, StudentStatus studentStatus, bool license, bool female)
: this()
{
Household = household;
Id = id;
Age = age;
Occupation = occupation;
EmploymentStatus = employmentStatus;
StudentStatus = studentStatus;
Licence = license;
Female = female;
}
public void Execute(ITashaHousehold household, int iteration)
{
lock ( this )
{
foreach ( var p in household.Persons )
{
if ( p.TripChains.Count < 1 )
continue; //Skip people with no trips
var sb = new StringBuilder();
if ( string.IsNullOrEmpty( this.HomeAnchorOverrideName ) )
{
sb.Append( Activity.Home.ToString() );
}
else
{
var x = p.TripChains[0].GetVariable( this.HomeAnchorOverrideName );
if ( x != null ) sb.Append( x.ToString() );
else sb.Append( Activity.Home.ToString() );
}
foreach ( var trip in p.TripChains[0].Trips )
{
sb.AppendFormat( ",{0}", trip.Purpose.ToString() );
}
var key = sb.ToString();
if ( this.data.ContainsKey( key ) )
{
if ( this.UseExpansionFactor )
{
this.data[key] += household.ExpansionFactor;
}
else
{
this.data[key]++;
}
}
else
{
if ( this.UseExpansionFactor )
{
this.data.Add( key, household.ExpansionFactor );
}
else
{
this.data.Add( key, 1 );
}
}
}
}
}
public void Generate(ITashaHousehold household, ITashaPerson person, List<IActivityEpisode> episodes, Random rand)
{
if ( person.StudentStatus == StudentStatus.FullTime )
{
this.School.Generate( household, person, episodes, rand );
this.Work.Generate( household, person, episodes, rand );
}
else
{
this.Work.Generate( household, person, episodes, rand );
this.School.Generate( household, person, episodes, rand );
}
}
public void Execute(ITashaHousehold household, int iteration)
{
int[] agesTemp = new int[AgeSets.Count];
var persons = household.Persons;
for ( int i = 0; i < persons.Length; i++ )
{
var index = this.AgeSets.IndexOf( persons[i].Age );
if ( index >= 0 )
{
agesTemp[index]++;
}
}
this.Data.Add( agesTemp, household.HomeZone.PlanningDistrict, household.Vehicles.Length, household.ExpansionFactor );
}
public void Execute(ITashaHousehold household)
{
foreach ( var person in household.Persons )
{
var data = person["SData"] as SchedulerPersonData;
if ( data != null )
{
var sched = data.Schedule;
this.CalculateWorkingPersons( sched, this.WorkingPersons, WorkActivities, true );
this.CalculateWorkingPersons( sched, this.MarketPersons, MarketActivities, true );
this.CalculateWorkingPersons( sched, this.OtherPersons, OtherActivities, true );
}
}
}
public void Execute(ITashaHousehold household, int iteration)
{
lock (Results)
{
foreach (var person in household.Persons)
{
var expFactor = person.ExpansionFactor;
var dailyTripsByPerson = Math.Min(person.TripChains.Sum(tc => tc.Trips.Count), MaxTrips);
foreach (var tripChain in person.TripChains)
{
var tripChainLength = Math.Min(tripChain.Trips.Count, MaxTrips);
Results[tripChainLength][dailyTripsByPerson] += expFactor;
}
}
}
}
public void HouseholdIterationComplete(ITashaHousehold household, int hhldIteration, int totalHouseholdIterations)
{
if (Calculate)
{
for (int i = 0; i < household.Persons.Length; i++)
{
float toAdd = household.Persons[i].ExpansionFactor / totalHouseholdIterations;
for (int j = 0; j < household.Persons[i].TripChains.Count; j++)
{
for (int k = 0; k < household.Persons[i].TripChains[j].Trips.Count; k++)
{
var mode = household.Persons[i].TripChains[j].Trips[k].Mode;
var tripStartTime = household.Persons[i].TripChains[j].Trips[k].TripStartTime;
if (tripStartTime.Hours >= 6 && tripStartTime.Hours < 9)
{
lock (this)
{
AddToDictionary(AMModeDictionary, mode, toAdd);
}
}
else if (tripStartTime.Hours >= 9 && tripStartTime.Hours < 15)
{
lock (this)
{
AddToDictionary(MDModeDictionary, mode, toAdd);
}
}
else if (tripStartTime.Hours >= 15 && tripStartTime.Hours < 19)
{
lock (this)
{
AddToDictionary(PMModeDictionary, mode, toAdd);
}
}
else
{
lock (this)
{
AddToDictionary(EVModeDictionary, mode, toAdd);
}
}
}
}
}
}
}
public void Execute(ITashaHousehold household, int iteration)
{
// only run on the last iteration
if ( iteration == Root.TotalIterations - 1 )
{
lock (this)
{
foreach ( var person in household.Persons )
{
foreach ( var tripChain in person.TripChains )
{
foreach ( var trip in tripChain.Trips )
{
float CurrentDistance = 0;
if ( trip.Mode == null )
{
continue;
}
if ( trip.OriginalZone == trip.DestinationZone )
{
CurrentDistance += trip.OriginalZone.InternalDistance;
}
else
{
CurrentDistance += ( Math.Abs( trip.OriginalZone.X - trip.DestinationZone.X ) + Math.Abs( trip.OriginalZone.Y - trip.DestinationZone.Y ) );
}
if ( DistancesDictionary.ContainsKey( trip.Purpose ) )
{
var record = DistancesDictionary[trip.Purpose];
record.TotalDistance += CurrentDistance * 0.001f;
record.Records++;
}
else
{
DistancesDictionary.Add( trip.Purpose, new DistanceCount( CurrentDistance * 0.001f, 1 ) );
}
}
}
}
}
}
}
public void HouseholdComplete(ITashaHousehold household, bool success)
{
float[][] util;
if ( success )
{
if ( !HouseUtilities.TryRemove( household, out util ) )
{
return;
}
lock ( this )
{
int tripChains = 0;
foreach ( var person in household.Persons )
{
tripChains += person.TripChains.Count;
}
var writeHeader = !File.Exists( OutputFile );
using ( StreamWriter writer = new StreamWriter( OutputFile, true ) )
{
if ( writeHeader )
{
writer.WriteLine( "HouseholdID,ouseholdIteration,First Household Utility,Second Household Utility,After Passenger Household Utility, TripChains Count" );
}
for ( int i = 0; i < util.Length; i++ )
{
writer.Write( household.HouseholdId );
writer.Write( ',' );
writer.Write( i );
writer.Write( ',' );
writer.Write( util[i][0] );
writer.Write( ',' );
writer.Write( util[i][1] );
writer.Write( ',' );
writer.Write( util[i][2] );
writer.Write( ',' );
writer.WriteLine( tripChains );
}
}
}
}
}
public void Execute(ITashaHousehold household, int iteration)
{
// we only want to process this data on our last iteration
if ( iteration < this.TotalIterations - 1 )
{
return;
}
var expansionFactor = household.ExpansionFactor;
foreach ( var person in household.Persons )
{
var index = AgeSets.IndexOf( person.Age );
if ( index >= 0 )
{
lock ( this.AgeSetCount )
{
this.AgeSetCount[index] += expansionFactor;
}
}
}
}
public void Execute(ITashaHousehold household, int iteration)
{
var persons = household.Persons;
for(int i = 0; i < persons.Length; i++)
{
if(persons[i].Age >= MinimumAge)
{
var expansionFactor = persons[i].ExpansionFactor;
var tripChains = persons[i].TripChains;
for(int j = 0; j < tripChains.Count; j++)
{
var tripChain = tripChains[j].Trips;
for(int k = 0; k < tripChain.Count; k++)
{
var tripStart = tripChain[k].TripStartTime;
var mode = tripChain[k].Mode;
int modeIndex = -1;
for(int l = 0; l < Modes.Length; l++)
{
if(Modes[l] == mode)
{
modeIndex = l;
break;
}
}
var activity = tripChain[k].Purpose;
if(modeIndex >= 0)
{
for(int l = 0; l < TimePeriods.Length; l++)
{
if(TimePeriods[l].Execute(tripStart, modeIndex, expansionFactor, activity))
{
break;
}
}
}
}
}
}
}
}
public void Execute(ITashaHousehold household, int iteration)
{
lock ( this )
{
foreach ( var person in household.Persons )
{
foreach ( var tripChain in person.TripChains )
{
var chain = tripChain.Trips;
for ( int i = 0; i < ( chain.Count - 1 ); i++ )
{
var thisTrip = chain[i];
var nextTrip = chain[i + 1];
var currentMode = thisTrip.Mode;
thisTrip.Mode = Root.AutoMode;
var hours = thisTrip.ActivityStartTime.Hours;
var duration = (int)( ( nextTrip.TripStartTime - thisTrip.ActivityStartTime ).ToMinutes() );
KeyValuePair<Activity, int> bob = new KeyValuePair<Activity, int>( thisTrip.Purpose, hours );
List<int> ourList;
if ( DurationsDict.TryGetValue( bob, out ourList ) )
{
ourList.Add( duration );
}
else
{
ourList = new List<int>();
ourList.Add( duration );
DurationsDict[bob] = ourList;
}
thisTrip.Mode = currentMode;
}
}
}
}
}
public void Execute(ITashaHousehold household, int iteration)
{
lock ( this )
{
float ExpansionFactor = household.ExpansionFactor;
foreach ( var person in household.Persons )
{
foreach ( var tripChain in person.TripChains )
{
foreach ( var trip in tripChain.Trips )
{
float OverallDistance;
if ( trip.OriginalZone == trip.DestinationZone )
{
OverallDistance = trip.OriginalZone.InternalDistance;
}
else
{
OverallDistance = ( Math.Abs( trip.OriginalZone.X - trip.DestinationZone.X ) + Math.Abs( trip.OriginalZone.Y - trip.DestinationZone.Y ) );
}
if ( Results.ContainsKey( ( TripStartTime ? trip.TripStartTime : trip.ActivityStartTime ).Hours ) )
{
Results[( TripStartTime ? trip.TripStartTime : trip.ActivityStartTime ).Hours].Add( OverallDistance );
}
else
{
List<float> Distance = new List<float>();
Distance.Add( OverallDistance );
Results.Add( ( TripStartTime ? trip.TripStartTime : trip.ActivityStartTime ).Hours, Distance );
}
}
}
}
}
}
