/// <summary>
///
/// </summary>
public double CalculateV(ITrip trip)
{
double v = 0;
v += CSchoolBus;
if (trip.TripChain.Person.Licence)
{
v += DriversLicence;
}
if (trip.TripChain.Person.Youth)
{
v += YouthPassenger;
v += YouthWalk;
}
if (trip.TripChain.Person.YoungAdult)
{
v += YoungAdultPassenger;
v += YoungAdultWalk;
}
if (trip.Purpose == Activity.School)
{
v += SchoolPurpose;
}
else if (trip.TripNumber > 1 && trip.TripChain.Trips[trip.TripChain.Trips.IndexOf(trip) - 1].Purpose == Activity.School)
{
v += SchoolPurpose;
}
v += Data.TravelTime(trip.OriginalZone, trip.DestinationZone, trip.ActivityStartTime).ToMinutes() * Distance;
v += trip.TripChain.Person.Age * Age;
return(v);
}
/// <summary>
/// Calcualtes the V value for the given trip
/// </summary>
/// <param name="trip">The trip to calcualte for</param>
/// <returns>The V for the trip</returns>
public double CalculateV(ITrip trip)
{
double V = 0;
IZone o = trip.OriginalZone, d = trip.DestinationZone;
if ((o == d) & UseIntrazonalRegression)
{
V += IntrazonalConstantWeight + o.InternalDistance * IntrazonalDistanceWeight;
}
else
{
V += this.Constant;
V += AutoData.TravelTime(o, d, trip.ActivityStartTime).ToMinutes() * this.travelTime;
V += AutoData.TravelCost(o, d, trip.ActivityStartTime) * this.travelCost;
}
V += d.ParkingCost * parking;
if (trip.Purpose == Activity.Market | trip.Purpose == Activity.JointMarket)
{
V += this.dpurp_shop_drive;
}
else if (trip.Purpose == Activity.IndividualOther | trip.Purpose == Activity.JointOther)
{
V += this.dpurp_oth_drive;
}
return(V);
}
public float CalculateV(IZone origin, IZone destination, Time time)
{
CheckInterchangeZone();
var zoneArray = Root.ZoneSystem.ZoneArray;
var flatOrigin = zoneArray.GetFlatIndex(origin.ZoneNumber);
var flatDestination = zoneArray.GetFlatIndex(destination.ZoneNumber);
var flatInterchange = zoneArray.GetFlatIndex(InterchangeZone.ZoneNumber);
// Make sure that this is a valid trip first
var toDestinationTime = Second.InVehicleTravelTime(flatInterchange, flatDestination, time).ToMinutes();
if (toDestinationTime > MaxAccessToDestinationTime)
{
return(float.NaN);
}
float v = LogParkingFactor * LogOfParking;
if (ClosestZone.GetFlatData()[flatOrigin])
{
v += Closest;
}
// calculate this second in case the toDestinationTime is invalid
// Cost of accessing the station
v += AccessInVehicleTravelTime * First.TravelTime(flatOrigin, flatInterchange, time).ToMinutes()
+ (AccessCost * (First.TravelCost(flatOrigin, flatInterchange, time) + FareTTC));
// Station to Destination time
v += InVehicleTravelTime * toDestinationTime;
// Walk Time
v += WalkTime * Second.WalkTime(flatInterchange, flatDestination, time).ToMinutes();
return(v);
}
/// <summary>
/// Calculates the V value for the given trip
/// </summary>
/// <param name="trip">The trip to calculate for</param>
/// <returns>The V for the trip</returns>
public double CalculateV(ITrip trip)
{
double v = 0;
IZone o = trip.OriginalZone, d = trip.DestinationZone;
if ((o == d) & UseIntrazonalRegression)
{
v += IntrazonalConstantWeight + o.InternalDistance * IntrazonalDistanceWeight;
}
else
{
v += Constant;
v += AutoData.TravelTime(o, d, trip.ActivityStartTime).ToMinutes() * TravelTimeBeta;
v += AutoData.TravelCost(o, d, trip.ActivityStartTime) * TravelCostBeta;
}
v += d.ParkingCost * Parking;
if (trip.Purpose == Activity.Market | trip.Purpose == Activity.JointMarket)
{
v += DpurpShopDrive;
}
else if (trip.Purpose == Activity.IndividualOther | trip.Purpose == Activity.JointOther)
{
v += DpurpOthDrive;
}
return(v);
}
/// <summary>
/// Computes the utility of a single interchange
/// </summary>
/// <param name="o">flat origin zone</param>
/// <param name="d">flat destination zone</param>
/// <param name="zones">an array of zones</param>
/// <param name="interchange">the flat interchange zone to use</param>
/// <param name="egressZones"></param>
/// <param name="maxDistance">The maximum distance allowed</param>
/// <param name="selectedEgressZones"></param>
/// <param name="result">the utility of using this interchange</param>
/// <param name="distance">The distance the origin is from the interchange in auto travel time</param>
/// <param name="accessStationIndex"></param>
/// <param name="egressUtility"></param>
/// <param name="egressTime"></param>
/// <param name="egressZone"></param>
/// <returns>True if this is a valid interchange zone, false if not feasible.</returns>
// ReSharper disable once UnusedParameter.Local
private bool ComputeUtility(int o, int d, IZone[] zones, int interchange, int accessStationIndex, int[] egressZones, float maxDistance, float[][] egressUtility, float[][] egressTime, int[][] selectedEgressZones, out float result, out float distance, out IZone egressZone)
{
float v = ComputeAccessUtility(o, interchange, out distance);
// our total travel time / distance is the egress time plus the time it takes to get to the station to begin with
if (egressTime[accessStationIndex][d] == 0)
{
throw new XTMFRuntimeException(this, "In '" + Name + "' the egress time between zone " + zones[egressZones[accessStationIndex]].ZoneNumber + " and " + zones[d].ZoneNumber + " was equal to 0!");
}
if (distance <= AutoNetwork.TravelTime(o, d, TimeOfDay).ToMinutes())
{
var egressUtil = egressUtility[accessStationIndex][d];
// Step 1, compute the egress station, and the utility from access station to egress to destination
if (distance < maxDistance & !float.IsNaN(v) & !float.IsNaN(egressUtil))
{
egressZone = zones[selectedEgressZones[accessStationIndex][d]];
// Step 2, compute the utility going from origin to access station
v += egressUtil;
result = v;
return(true);
}
}
egressZone = null;
result = float.NaN;
return(false);
}
/// <summary>
/// Computes the utility of a single interchange
/// </summary>
/// <param name="o">flat origin zone</param>
/// <param name="d">flat destination zone</param>
/// <param name="zones">an array of zones</param>
/// <param name="interchange">the flat interchange zone to use</param>
/// <param name="maxDistance">The maximum distance allowed</param>
/// <param name="result">the utility of using this interchange</param>
/// <param name="distanceByAuto">The distance the origin is from the interchange in auto travel time</param>
/// <param name="parking"></param>
/// <returns>True if this is a valid interchange zone, false if not feasible.</returns>
private bool ComputeUtility(int o, int d, IZone[] zones, int interchange, float[] parking, float maxDistance,
out float result, out float distanceByAuto)
{
result = float.NaN;
Time ivtt, walk, wait, boarding;
float cost;
float v = 0.0f;
var destinationDistance = AutoNetwork.TravelTime(o, d, TimeOfDay).ToMinutes();
if (Access)
{
// distance is actually the travel time
distanceByAuto = AutoNetwork.TravelTime(o, interchange, TimeOfDay).ToMinutes();
// there is no need to continue if we have already found the max number of paths that are shorter
// it also a valid choice to drive longer in order to use the access station compared to just going to the final destination.
// we also are not feasible if there is no parking spots
if (distanceByAuto >= maxDistance | destinationDistance < distanceByAuto | parking[interchange] <= 0)
{
return(false);
}
// get the from interchange to destination costs (we need to include boarding here even though we don't actually use it in our utility function
// making individual calls for the data would be more expensive
if (!TransitNetwork.GetAllData(interchange, d, TimeOfDay, out ivtt, out walk, out wait, out boarding, out cost) | ivtt <= Time.Zero | walk <= Time.Zero)
{
return(false);
}
}
else
{
// This will be executed if we want to run the EGRESS model
// distance is actually the travel time from the station we get off at to our destination
distanceByAuto = AutoNetwork.TravelTime(interchange, d, TimeOfDay).ToMinutes();
// make sure we clip properly
if (distanceByAuto >= maxDistance | destinationDistance < distanceByAuto | parking[interchange] <= 0)
{
return(false);
}
// in egress the transit trip is actually before the drive, so origin to the interchange is transit
if (!TransitNetwork.GetAllData(o, interchange, TimeOfDay, out ivtt, out walk, out wait, out boarding, out cost) | ivtt <= Time.Zero | walk <= Time.Zero)
{
return(false);
}
}
v += IvttFactor * ivtt.ToMinutes()
+ WaitTimeFactor * wait.ToMinutes()
+ WalkTimeFactor * walk.ToMinutes()
+ BoardingFactor * boarding.ToMinutes();
v += AutoTimeFactor * distanceByAuto;
v += AutoCostFactor * AutoNetwork.TravelCost(o, interchange, TimeOfDay);
v += ParkingFactor * (float)Math.Log(parking[interchange]);
v += ParkingCostFactor * zones[interchange].ParkingCost;
// Now add in the origin to interchange zone utilities
result = v;
return(true);
}
private float CalculateDATTime(Time time, IZone originalZone, int accessFlat, IZone destinationZone, bool access)
{
var origin = ZoneSystem.GetFlatIndex(originalZone.ZoneNumber);
var destination = ZoneSystem.GetFlatIndex(destinationZone.ZoneNumber);
if (access)
{
return((AutoNetwork.TravelTime(origin, accessFlat, time)
+ TransitNetwork.TravelTime(accessFlat, destination, time)).ToMinutes());
}
else
{
return((TransitNetwork.TravelTime(origin, accessFlat, time)
+ AutoNetwork.TravelTime(accessFlat, destination, time)).ToMinutes());
}
}
/// <summary>
/// Calculate the utility between two zones
/// </summary>
/// <param name="pdD"></param>
/// <param name="zoneO">The flat origin index</param>
/// <param name="pdO"></param>
/// <param name="zoneD"></param>
/// <param name="workerIndex"></param>
/// <returns>The utility between the two zones.</returns>
private float CalculateUtilityToE(int pdO, int pdD, int zoneO, int zoneD, int workerIndex)
{
var segment = GetSegment(pdO, pdD);
if (segment == null)
{
return(0);
}
// Worker Categories:
// 0 = No Car / No License
// 1 = Less cars than people with licenses
// 2 = More or equal cars to persons with licenses
float perceivedTime = AutoNetwork.TravelTime(zoneO, zoneD, TimeOfDay).ToMinutes();
var utility = Math.Exp((workerIndex == 0 ? segment.PassengerTime : segment.AutoTime) * perceivedTime +
(workerIndex == 2 ? segment.SaturatedVehicles : 0));
// transit
TransitNetwork.GetAllData(zoneO, zoneD, TimeOfDay, out float trueTime, out float walk, out float wait, out perceivedTime, out float cost);
if (perceivedTime > 0)
{
utility += Math.Exp(segment.TransitTime * perceivedTime + segment.TransitConstant);
}
var constants = segment.ExpSegmentConstant;
if (zoneO == zoneD)
{
constants *= segment.ExpIntrazonalConstant;
}
if (pdO == pdD)
{
constants *= segment.ExpIntraPDConstant;
}
return((float)(utility * constants));
}
private float CalculateDATTime(SparseArray <IZone> _zoneSystem, INetworkData _autoNetwork, ITripComponentData _transitNetwork, Time time,
IZone originalZone, int accessFlat, IZone destinationZone, bool access)
{
var origin = _zoneSystem.GetFlatIndex(originalZone.ZoneNumber);
var destination = _zoneSystem.GetFlatIndex(destinationZone.ZoneNumber);
if (access)
{
return((_autoNetwork.TravelTime(origin, accessFlat, time)
+ _transitNetwork.TravelTime(accessFlat, destination, time)).ToMinutes());
}
else
{
return((_transitNetwork.TravelTime(origin, accessFlat, time)
+ _autoNetwork.TravelTime(accessFlat, destination, time)).ToMinutes());
}
}
override public float CalculateV(IZone origin, IZone destination, Time time)
{
if (IsContained(origin, destination))
{
return(Aivtt * NetworkData.TravelTime(origin, destination, time).ToMinutes());
}
return(0);
}
private float[] ComputeFriction(IZone[] zones, IDemographicCategory cat, float[] friction)
{
var numberOfZones = zones.Length;
float[] ret = friction ?? (new float[numberOfZones * numberOfZones]);
// let it setup the modes so we can compute friction
cat.InitializeDemographicCategory();
try
{
Parallel.For(0, numberOfZones, new ParallelOptions {
MaxDegreeOfParallelism = Environment.ProcessorCount
}, delegate(int j)
{
var destination = zones[j];
if (!InverseLookup(destination.RegionNumber, out int regionIndex))
{
// make sure to reset the friction to zero
for (int i = 0; i < numberOfZones; i++)
{
ret[i * numberOfZones + j] = float.NegativeInfinity;
}
return;
}
// store the log of the population and the employment since we will be using this for each origin
var employmentLog = (float)Math.Log((destination.Employment - destination.ManufacturingEmployment) + 1);
var populationLog = (float)Math.Log(destination.Population + 1);
for (int i = 0; i < numberOfZones; i++)
{
var origin = zones[i];
if (origin.RegionNumber <= 0)
{
ret[i * numberOfZones + j] = float.NegativeInfinity;
}
else
{
var autoTime = RegionEmploymentGeneralParameter[regionIndex] *
NetworkData.TravelTime(origin, destination, SimulationTime).ToMinutes();
var destinationUtility = RegionEmploymentParameter[regionIndex] * employmentLog
+ RegionPopulationParameter[regionIndex] * populationLog;
// this isn't friction, it is V where friction will be e^V
ret[i * numberOfZones + j] = destinationUtility + autoTime;
}
}
});
}
catch (AggregateException e)
{
if (e.InnerException is XTMFRuntimeException)
{
throw new XTMFRuntimeException(this, e.InnerException.Message);
}
throw new XTMFRuntimeException(this, e.InnerException?.Message + "\r\n" + e.InnerException?.StackTrace);
}
// Use the Log-Sum from the V's as the impedence function
return(ret);
}
private void LoadTimes(SparseTwinIndex <float> data, INetworkData network)
{
var flatData = data.GetFlatData();
var time = TimeToLoad;
for (int i = 0; i < flatData.Length; i++)
{
var row = flatData[i];
for (int j = 0; j < row.Length; j++)
{
row[j] = network.TravelTime(i, j, time).ToMinutes();
}
}
}
public bool Feasible(IZone originZone, IZone destinationZone, Time time)
{
var zoneArray = Root.ZoneSystem.ZoneArray;
var origin = zoneArray.GetFlatIndex(originZone.ZoneNumber);
var destination = zoneArray.GetFlatIndex(destinationZone.ZoneNumber);
if (CurrentlyFeasible <= 0)
{
return(false);
}
if (AdvancedNetworkData == null)
{
return(NetworkData.ValidOd(origin, destination, time) && (!CheckPositiveIVTT || NetworkData.TravelTime(origin, destination, time).ToMinutes() > 0));
}
AdvancedNetworkData.GetAllData(origin, destination, time, out float ivtt, out float walk, out float wait, out float boarding, out float cost);
return(AdvancedNetworkData.ValidOd(origin, destination, time) &&
((!CheckPositiveIVTT || ivtt > 0)) &&
((!CheckPositiveWalk || walk > 0)));
}
/// <summary>
/// Calculate the utility between two zones
/// </summary>
/// <param name="zoneO">The flat origin index</param>
/// <param name="zoneJ">The flat destination index</param>
/// <returns>The utility between the two zones.</returns>
public float CalculateUtilityToE(int pdO, int pdD, int zoneO, int zoneD, int workerIndex, float distance)
{
var segment = GetSegment(pdO, pdD);
if (segment == null)
{
return(0);
}
double utility = 0.0;
// Worker Categories:
// 0 = No Car / No License
// 1 = Less cars than people with licenses
// 2 = More or equal cars to persons with licenses
float time = AutoNetwork.TravelTime(zoneO, zoneD, TimeOfDay).ToMinutes();
utility = Math.Exp((workerIndex == 0 ? segment.PassengerTime : segment.AutoTime) * time +
(workerIndex == 2 ? segment.SaturatedVehicles : 0));
// transit
time = TransitNetwork.TravelTime(zoneO, zoneD, TimeOfDay).ToMinutes();
if (time > 0)
{
utility += Math.Exp(segment.TransitTime * time + segment.TransitConstant);
}
// distance
if (distance < segment.MaxDistance)
{
utility += Math.Exp(segment.Distance * distance + segment.DistanceConstant);
}
var constants = 1.0;
if (zoneO == zoneD)
{
constants *= segment.ExpIntrazonalConstant;
}
if (pdO == pdD)
{
constants *= segment.ExpIntraPDConstant;
}
return((float)(utility * constants));
}
private float[] ComputeFriction(IZone[] zones, IDemographicCategory cat, float[] friction)
{
var numberOfZones = zones.Length;
float[] ret = friction == null ? new float[numberOfZones * numberOfZones] : friction;
// let it setup the modes so we can compute friction
cat.InitializeDemographicCategory();
Parallel.For(0, numberOfZones, new ParallelOptions {
MaxDegreeOfParallelism = Environment.ProcessorCount
}, delegate(int i)
{
int index = i * numberOfZones;
var origin = zones[i];
if (!InverseLookup(zones[i].RegionNumber, out int regionIndex))
{
for (int j = 0; j < numberOfZones; j++)
{
ret[index++] = 0;
}
return;
}
for (int j = 0; j < numberOfZones; j++)
{
var destination = zones[j];
var autoTime = NetworkData.TravelTime(origin, destination, SimulationTime);
var population = destination.Population;
ret[index++] = (float)(RegionAutoParameter[regionIndex] * autoTime.ToMinutes()
// population
+ RegionPopulationParameter[regionIndex] * Math.Log(population + 1)
// employment
+ RegionEmploymentProfessionalParameter[regionIndex] * Math.Log(destination.ProfessionalEmployment + 1)
+ RegionEmploymentGeneralParameter[regionIndex] * Math.Log(destination.GeneralEmployment + 1)
+ RegionEmploymentSalesParameter[regionIndex] * Math.Log(destination.RetailEmployment + 1)
+ RegionEmploymentManufacturingParameter[regionIndex] * Math.Log(destination.ManufacturingEmployment + 1));
}
});
// Use the Log-Sum from the V's as the impedence function
return(ret);
}
private void ComputeFriction(IZone[] zones, int numberOfZones, float[] ret)
{
Parallel.For(0, numberOfZones, new ParallelOptions {
MaxDegreeOfParallelism = Environment.ProcessorCount
}, delegate(int i)
{
var origin = zones[i];
if (!InverseLookup(origin.RegionNumber, out int regionIndex))
{
return;
}
int index = (i * numberOfZones);
for (int j = 0; j < numberOfZones; j++)
{
var destination = zones[j];
ret[index++] = (float)(RegionAutoParameter[regionIndex] * NetworkData.TravelTime(origin, destination, SimulationTime).ToMinutes()
// population
+ RegionPopulationParameter[regionIndex] * Math.Log(destination.Population + 1)
// employment
+ RegionNonManufacturingEmploymentParameter[regionIndex] * Math.Log(destination.ProfessionalEmployment
+ destination.GeneralEmployment + destination.RetailEmployment + 1));
}
});
}
public Time TravelTime(IZone origin, IZone destination, Time time)
{
return(Network.TravelTime(origin, destination, time));
}
/// <summary>
/// This gets the travel time between zones
/// </summary>
/// <param name="origin">Where to start</param>
/// <param name="destination">Where to go</param>
/// <param name="time">What time of day is it? (hhmm.ss)</param>
/// <returns>The amount of time it will take</returns>
public Time TravelTime(IZone origin, IZone destination, Time time)
{
return(AutoData.TravelTime(origin, destination, time));
}
public bool ProduceResult(Pair <IZone, IZone> data)
{
return(NetworkData.TravelTime(data.First, data.Second, SimulationTime) > Time.Zero);
}
