public UnAssignedModeSet(ITripChain chain, ModeSet mSet, IVehicleType vehicleType)
: this()
{
Chain = chain;
Set = mSet;
VehicleType = vehicleType;
}
/// <summary>
/// Calculates and stores the best trip chain for
/// each type of vehicle (and NPV)
/// </summary>
/// <param name="chain">The chain to calculate</param>
public static void SelectBestPerVehicleType(this ITripChain chain)
{
ModeSet[] best = chain["BestForVehicle"] as ModeSet[];
var sets = ModeSet.GetModeSets(chain);
if (best == null)
{
best = new ModeSet[TashaRuntime.VehicleTypes.Count + 1];
chain.Attach("BestForVehicle", best);
}
for (int i = 0; i < best.Length; i++)
{
best[i] = null;
}
foreach (var set in sets)
{
IVehicleType type = null;
foreach (var mode in set.ChosenMode)
{
if (mode.RequiresVehicle != null)
{
type = mode.RequiresVehicle;
break;
}
}
int index = TashaRuntime.VehicleTypes.IndexOf(type);
best[index + 1] = (best[index + 1] == null || best[index + 1].U < set.U) ? set : best[index + 1];
}
}
public void Recycle()
{
this.VehicleType = null;
this.Release();
if (Vehicles.Count < 100)
{
Vehicle.Vehicles.Add(this);
}
}
public static Vehicle MakeVehicle(IVehicleType type)
{
if (Vehicles.TryTake(out Vehicle v))
{
v.VehicleType = type;
return(v);
}
return(new Vehicle(type));
}
/// <summary>
/// This is called before the start method as a way to pre-check that all of the parameters that are selected
/// are in fact valid for this module.
/// </summary>
/// <param name="error">A string that should be assigned a detailed error</param>
/// <returns>If the validation was successful or if there was a problem</returns>
public bool RuntimeValidation(ref string error)
{
var householdFile = System.IO.Path.Combine(this.TashaRuntime.InputBaseDirectory, this.FileName);
this.AutoType = this.TashaRuntime.AutoType;
try
{
if (!System.IO.File.Exists(householdFile))
{
error = String.Concat("The file ", householdFile, " does not exist!");
return(false);
}
}
catch
{
error = String.Concat("We were unable to access ", householdFile, " the path may be invalid or unavailable at this time.");
return(false);
}
if (this.FilterPassenger)
{
try
{
foreach (var mode in this.TashaRuntime.AllModes)
{
if (mode.ModeName == this.PassengerName)
{
this.Passenger = mode;
return(true);
}
}
}
catch
{
foreach (var mode in this.TashaRuntime.SharedModes)
{
if (mode.ModeName == this.PassengerName)
{
this.Passenger = mode;
return(true);
}
}
}
error = "We did not find any shared mode named " + this.PassengerName + " to filter with!";
return(false);
}
return(true);
}
private void FirstPass(ITashaPerson person, IVehicleType primaryVehicle, int[] eventCount)
{
foreach (var tripChain in person.TripChains)
{
if (tripChain.JointTrip)
{
foreach (var trip in tripChain.Trips)
{
int id = -1;
if (((trip.Purpose == Activity.JointOther) | (trip.Purpose == Activity.JointMarket)) & tripChain.JointTripRep)
{
id = Distribution.GetDistributionID(person.Household, trip.Purpose);
}
else if (tripChain.JointTripRep || !((trip.Purpose == Activity.JointOther) | (trip.Purpose == Activity.JointMarket)))
{
id = Distribution.GetDistributionID(person, trip.Purpose);
}
if (id != -1)
{
CheckForZero(person, id, trip.Purpose);
eventCount[id]++;
}
}
}
else
{
foreach (var trip in tripChain.Trips)
{
if (!IsWorkTrip(trip.Purpose))
{
var id = Distribution.GetDistributionID(person, trip.Purpose);
if (id != -1)
{
CheckForZero(person, id, trip.Purpose);
eventCount[id]++;
}
}
}
}
}
}
/// <summary>
/// This is called before the start method as a way to pre-check that all of the parameters that are selected
/// are in fact valid for this module.
/// </summary>
/// <param name="error">A string that should be assigned a detailed error</param>
/// <returns>If the validation was successful or if there was a problem</returns>
public bool RuntimeValidation(ref string error)
{
this.AutoType = this.TashaRuntime.AutoType;
return true;
}
private Vehicle(IVehicleType type)
{
this.VehicleType = type;
}
public static void FindPossibleAssignments(List <Pair <IVehicleType[], double> > possibleAssignments,
List <ITripChain> chains,
List <IVehicle> vehicles,
int position,
List <UnAssignedModeSet> currentChains,
IVehicleType[] currentAssignment,
double currentU)
{
ModeSet[] sets = (ModeSet[])chains[position]["BestForVehicle"];
if (sets == null)
{
return;
}
var numberOfVehicleTypes = ModeChoice.VehicleTypes.Count + 1;
for (int j = 0; j < numberOfVehicleTypes; j++) //take into account NPV
{
ModeSet set = sets[j];
//if this vehicle cannot be used for this set skip it since we are already considering NPV
if ((set != null) && (set.ChosenMode != null))
{
//a Personal vehicle mode
if (j > 0)
{
UnAssignedModeSet newUms = new UnAssignedModeSet(chains[position], set, set.ChosenMode[0].RequiresVehicle);
List <UnAssignedModeSet> allChainsWithSameVehicle = currentChains.FindAll(n => n.VehicleType == newUms.VehicleType);
List <ITripChain> sameVehicleChains = new List <ITripChain>();
foreach (var ums in allChainsWithSameVehicle)
{
sameVehicleChains.Add(ums.GetChainWithAssignedModes());
}
int count = vehicles.Count(n => n.VehicleType.Equals(newUms.VehicleType));
var availabilities = HouseholdExtender.FindVehicleAvailabilites(sameVehicleChains, count);
foreach (var ums in allChainsWithSameVehicle)
{
ums.ResetChain();
}
ITripChain curChain = newUms.GetChainWithAssignedModes();
var span = new TashaTimeSpan(curChain.StartTime, curChain.EndTime);
newUms.ResetChain();
if (HouseholdExtender.VehicleAvailableInTimeSpan(availabilities, span, count))
{
currentAssignment[position] = newUms.VehicleType;
currentChains.Add(newUms);
}
else
{
continue;
}
}
double newU = currentU + set.U;
if (position + 1 == chains.Count)
{ //end of the line
IVehicleType[] nextAssignment = new IVehicleType[chains.Count];
currentAssignment.CopyTo(nextAssignment, 0);
possibleAssignments.Add(new Pair <IVehicleType[], double>(nextAssignment, newU));
}
else
{
IVehicleType[] nextAssignment = new IVehicleType[chains.Count];
currentAssignment.CopyTo(nextAssignment, 0);
FindPossibleAssignments(possibleAssignments, chains, vehicles, position + 1, new List <UnAssignedModeSet>(currentChains), nextAssignment, newU);
}
}
}
}
/// <summary>
/// Gets if the requested vehicle is available (Excluding auxiliary trips)
/// </summary>
/// <param name="veqType"></param>
/// <param name="start"></param>
/// <param name="end"></param>
/// <param name="hh"></param>
/// <returns></returns>
public int numVehiclesAvailable(IVehicleType veqType, Time start, Time end, ITashaHousehold hh)
{
return ( hh.NumberOfVehicleAvailable( new TashaTimeSpan( start, end ), veqType, false ) );
}
/// <summary>
/// This is called before the start method as a way to pre-check that all of the parameters that are selected
/// are in fact valid for this module.
/// </summary>
/// <param name="error">A string that should be assigned a detailed error</param>
/// <returns>If the validation was successful or if there was a problem</returns>
public bool RuntimeValidation(ref string error)
{
JointTripGenerator.ObsMode = ObservedMode;
var ibd = Root.InputBaseDirectory;
if (ibd == null)
{
error = "The model system's input base directory was null!";
return(false);
}
AutoType = Root.AutoType;
if (SecondVehicleColumnNumber >= 0)
{
if (Root.VehicleTypes == null)
{
error = "In '" + Name + "' we were unable to get the alternative vehicle types for the secondary vehicle!";
return(false);
}
foreach (var vt in Root.VehicleTypes)
{
if (vt.VehicleName == SecondaryVehicleTypeName)
{
SecondaryType = vt;
break;
}
}
if (SecondaryType == null)
{
error = "Could not find vehicle type '" + SecondaryVehicleTypeName + "'.";
return(false);
}
}
if (CalculateJointTrips && !string.IsNullOrWhiteSpace(RideshareModeName))
{
bool found = false;
if (Root.SharedModes == null)
{
error = "In '" + Name + "' we were unable to access any Shared Modes inside of '" + Root.Name + "' Please either turn off rideshare's mode swap or fix the model system!";
return(false);
}
foreach (var sharedMode in Root.SharedModes)
{
if (sharedMode.ModeName == RideshareModeName)
{
Rideshare = sharedMode;
found = true;
break;
}
}
if (!found)
{
error = "In '" + Name + "' we were unable to find a shared mode called '" + RideshareModeName + "' to use for rideshare";
return(false);
}
found = false;
foreach (var nonSharedMode in Root.NonSharedModes)
{
if (nonSharedMode.ModeName == AutoModeName)
{
AutoMode = nonSharedMode;
found = true;
break;
}
}
if (!found)
{
error = "In '" + Name + "' we were unable to find a non shared mode called '" + AutoModeName + "' to use replace with rideshare";
return(false);
}
found = false;
foreach (var nonSharedMode in Root.AllModes)
{
if (nonSharedMode.ModeName == PassengerModeName)
{
PassengerMode = nonSharedMode;
found = true;
break;
}
}
if (!found)
{
error = "In '" + Name + "' we were unable to find a non shared mode called '" + PassengerModeName + "' to use replace with rideshare";
return(false);
}
}
return(true);
}
private bool AssignGoToAndReturnTripChains(ITripChain auxiliaryTripChain, ITashaHousehold household, IVehicleType vehicleType, ITrip trip, ISharedMode mode)
{
if ( numVehiclesAvailable( vehicleType, auxiliaryTripChain.StartTime, auxiliaryTripChain.EndTime, household ) == 0 )
return false;
bool success = false;
bool conflict;
foreach ( var p in household.Persons )
{
if ( !vehicleType.CanUse( p ) )
{
continue;
}
conflict = false;
foreach ( var tc in p.TripChains )
{
if ( tc.StartTime <= auxiliaryTripChain.EndTime && tc.EndTime >= auxiliaryTripChain.StartTime )
{
conflict = true;
break; // go onto next person
}
}
if ( !conflict )
{
//this person has no conflict so give him an aux trip chain
AddAuxTripChain( p, trip.TripChain.Person, copyTrip( auxiliaryTripChain.Trips[0] ), copyTrip( auxiliaryTripChain.Trips[1] ), trip, mode, isDropOffTrip( trip ), null );
success = true;
}
}
return success;
}
/// <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);
}
/// <summary>
/// Gets if the requested vehicle is available (Excluding auxiliary trips)
/// </summary>
/// <param name="veqType"></param>
/// <param name="start"></param>
/// <param name="end"></param>
/// <param name="hh"></param>
/// <returns></returns>
public int numVehiclesAvailable(IVehicleType veqType, Time start, Time end, ITashaHousehold hh)
{
return(hh.NumberOfVehicleAvailable(new TashaTimeSpan(start, end), veqType, false));
}
/// <summary>
/// Returns a dictionary of time spans indicating at which time the # of vehicles not in use
/// </summary>
/// <param name="h"></param>
/// <param name="vehicleType"></param>
/// <returns></returns>
public static Dictionary <TashaTimeSpan, int> FindVehicleAvailabilites(this ITashaHousehold h, IVehicleType vehicleType, bool includeAuxTripChains)
{
return(FindVehicleAvailabilitesHelper(h, vehicleType, includeAuxTripChains));
}
public static int NumberOfVehicleAvailable(List <ITripChain> tripChains, int numVehicles, IVehicleType vehicleType, TashaTimeSpan span)
{
Dictionary <TashaTimeSpan, int> availabilities = FindVehicleAvailabilites(tripChains, numVehicles);
int available = numVehicles;
foreach (var a in availabilities)
{
if ((a.Key.Start < span.End) && (a.Key.End > span.Start))
{
if (a.Value < available)
{
available = a.Value;
}
}
}
return(available);
}
private Vehicle(IVehicleType type)
{
VehicleType = type;
}
private Vehicle(IVehicleType type)
{
this.VehicleType = type;
}
private bool AssignGoToAndReturnTripChains(ITripChain auxiliaryTripChain, ITashaHousehold household, IVehicleType vehicleType, ITrip trip, ISharedMode mode)
{
if (numVehiclesAvailable(vehicleType, auxiliaryTripChain.StartTime, auxiliaryTripChain.EndTime, household) == 0)
{
return(false);
}
bool success = false;
bool conflict;
foreach (var p in household.Persons)
{
if (!vehicleType.CanUse(p))
{
continue;
}
conflict = false;
foreach (var tc in p.TripChains)
{
if (tc.StartTime <= auxiliaryTripChain.EndTime && tc.EndTime >= auxiliaryTripChain.StartTime)
{
conflict = true;
break; // go onto next person
}
}
if (!conflict)
{
//this person has no conflict so give him an aux trip chain
AddAuxTripChain(p, trip.TripChain.Person, copyTrip(auxiliaryTripChain.Trips[0]), copyTrip(auxiliaryTripChain.Trips[1]), trip, mode, isDropOffTrip(trip), null);
success = true;
}
}
return(success);
}
public static Vehicle MakeVehicle(IVehicleType type)
{
Vehicle v;
if ( Vehicle.Vehicles.TryTake( out v ) )
{
v.VehicleType = type;
return v;
}
return new Vehicle( type );
}
public static TashaVehicle MakeVehicle(IVehicleType type)
{
return new TashaVehicle( type );
}
public void Recycle()
{
this.VehicleType = null;
this.Release();
if(Vehicles.Count < 100)
{
Vehicle.Vehicles.Add(this);
}
}
/// <summary>
/// This is called before the start method as a way to pre-check that all of the parameters that are selected
/// are in fact valid for this module.
/// </summary>
/// <param name="error">A string that should be assigned a detailed error</param>
/// <returns>If the validation was successful or if there was a problem</returns>
public bool RuntimeValidation(ref string error)
{
// if our deep ancestor is in fact a tasha runtime
this.TashaRuntime = this.Root as ITashaRuntime;
IList<INetworkData> networks;
if(this.TashaRuntime == null)
{
// check for a 4Step model system template
var tdm = this.Root as ITravelDemandModel;
// if it isn't report the error
if(tdm == null)
{
error = "The Tasha.Modes.Auto Module only works with ITashaRuntime's and ITravelDemandModel's!";
return false;
}
networks = tdm.NetworkData;
}
else
{
if(String.IsNullOrWhiteSpace(this.VehicleTypeName))
{
this.AutoType = this.TashaRuntime.AutoType;
}
else
{
if(this.TashaRuntime.VehicleTypes != null)
{
foreach(var v in this.TashaRuntime.VehicleTypes)
{
if(v.VehicleName == this.VehicleTypeName)
{
this.AutoType = v;
break;
}
}
}
}
if(AutoType == null)
{
error = "We were unable to find an vehicle type to use for '" + this.ModeName + "'!";
return false;
}
networks = this.TashaRuntime.NetworkData;
}
if(String.IsNullOrWhiteSpace(this.NetworkType))
{
error = "There was no network type selected for the " + (String.IsNullOrWhiteSpace(this.ModeName) ? "Auto" : this.ModeName) + " mode!";
return false;
}
if(networks == null)
{
error = "There was no Auto Network loaded for the Auto Mode!";
return false;
}
bool found = false;
foreach(var network in networks)
{
if(network.NetworkType == this.NetworkType)
{
this.AutoData = network;
found = true;
break;
}
}
if(!found)
{
error = "In '" + Name + "' we were unable to find the network data with the name \"" + this.NetworkType + "\" in this Model System!";
return false;
}
return true;
}
/// <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);
}
private TashaVehicle(IVehicleType type)
{
VehicleType = type;
}
/// <summary>
/// Returns a list of Timespans and the associated number of vehicles in that time span
/// </summary>
/// <param name="h"></param>
/// <param name="vehicleType"></param>
/// <param name="aux"></param>
/// <returns></returns>
private static Dictionary <TashaTimeSpan, int> FindVehicleAvailabilitesHelper(ITashaHousehold h, IVehicleType vehicleType, bool aux)
{
Dictionary <TashaTimeSpan, int> availabilities = new Dictionary <TashaTimeSpan, int>();
List <ITripChain> allTripChains;
if (aux)
{
allTripChains = h.AllTripChainsWithAuxThatUseVehicle(vehicleType);
}
else
{
allTripChains = h.AllTripChainsThatUseVehicle(vehicleType);
}
int vehiclesAvailable = 0;
var vehicles = h.Vehicles;
for (int i = 0; i < vehicles.Length; i++)
{
if (vehicles[i].VehicleType == vehicleType)
{
vehiclesAvailable++;
}
}
return(FindVehicleAvailabilites(allTripChains, vehiclesAvailable));
}
/// <summary>
/// This is called before the start method as a way to pre-check that all of the parameters that are selected
/// are in fact valid for this module.
/// </summary>
/// <param name="error">A string that should be assigned a detailed error</param>
/// <returns>If the validation was successful or if there was a problem</returns>
public bool RuntimeValidation(ref string error)
{
this.AutoType = this.TashaRuntime.AutoType;
return(true);
}
private TashaVehicle(IVehicleType type)
{
this.VehicleType = type;
}
private TashaVehicle(IVehicleType type)
{
this.VehicleType = type;
}
/// <summary>
/// This is called before the start method as a way to pre-check that all of the parameters that are selected
/// are in fact valid for this module.
/// </summary>
/// <param name="error">A string that should be assigned a detailed error</param>
/// <returns>If the validation was successful or if there was a problem</returns>
public bool RuntimeValidation(ref string error)
{
// if our deep ancestor is in fact a tasha runtime
this.TashaRuntime = this.Root as ITashaRuntime;
IList <INetworkData> networks;
if (this.TashaRuntime == null)
{
// check for a 4Step model system template
var tdm = this.Root as ITravelDemandModel;
// if it isn't report the error
if (tdm == null)
{
error = "The Tasha.Modes.Auto Module only works with ITashaRuntime's and ITravelDemandModel's!";
return(false);
}
networks = tdm.NetworkData;
}
else
{
if (String.IsNullOrWhiteSpace(this.VehicleTypeName))
{
this.AutoType = this.TashaRuntime.AutoType;
}
else
{
if (this.TashaRuntime.VehicleTypes != null)
{
foreach (var v in this.TashaRuntime.VehicleTypes)
{
if (v.VehicleName == this.VehicleTypeName)
{
this.AutoType = v;
break;
}
}
}
}
if (AutoType == null)
{
error = "We were unable to find an vehicle type to use for '" + this.ModeName + "'!";
return(false);
}
networks = this.TashaRuntime.NetworkData;
}
if (String.IsNullOrWhiteSpace(this.NetworkType))
{
error = "There was no network type selected for the " + (String.IsNullOrWhiteSpace(this.ModeName) ? "Auto" : this.ModeName) + " mode!";
return(false);
}
if (networks == null)
{
error = "There was no Auto Network loaded for the Auto Mode!";
return(false);
}
bool found = false;
foreach (var network in networks)
{
if (network.NetworkType == this.NetworkType)
{
this.AutoData = network;
found = true;
break;
}
}
if (!found)
{
error = "In '" + Name + "' we were unable to find the network data with the name \"" + this.NetworkType + "\" in this Model System!";
return(false);
}
return(true);
}
public static TashaVehicle MakeVehicle(IVehicleType type)
{
return(new TashaVehicle(type));
}
/// <summary>
/// Assigns the best mode to each trip in the trip chain for use in pass 3. (Conflict Vers.)
/// </summary>
/// <param name="household">Household to work on</param>
/// <param name="bestAssignment">The current (after pass 2) best vehicle assignment</param>
private void AssignBestMode(ITashaHousehold household, IVehicleType[] bestAssignment)
{
int i = 0;
foreach ( var person in household.Persons )
{
foreach ( var tripChain in person.TripChains )
{
ModeSet[] sets = (ModeSet[])tripChain["BestForVehicle"];
ModeSet set = sets[this.VehicleTypes.IndexOf( bestAssignment[i++] ) + 1];
if ( set != null )
{
var numberOfTrips = tripChain.Trips.Count;
for ( int j = 0; j < numberOfTrips; j++ )
{
tripChain.Trips[j].Mode = set.ChosenMode[j];
}
}
}
}
}
private RentalReceipt RentItem_CheckArguments(RentalRequest rentalRequest, IVehicleType vehicleType)
{
if (vehicleType == null)
{
return new RentalReceipt()
{
Status = ERentalRequestStatus.NotOk,
Message = string.Format("The vehicle type {0} does not exist.", rentalRequest.VehicleTypeName)
};
}
if (string.IsNullOrEmpty(rentalRequest.RegNo))
{
return new RentalReceipt()
{
Status = ERentalRequestStatus.NotOk,
Message = "RegNo can not be empty."
};
}
if (string.IsNullOrEmpty(rentalRequest.CustomerInfo.PersonNummer))
{
return new RentalReceipt()
{
Status = ERentalRequestStatus.NotOk,
Message = "PersonNummer can not be empty."
};
}
if (rentalRequest.CurrentMilageKm < 0)
{
return new RentalReceipt()
{
Status = ERentalRequestStatus.NotOk,
Message = "Milage can not be < 0 km."
};
}
if (_rentalsRepository.VehicleIsOutForRent(rentalRequest.RegNo))
{
return new RentalReceipt()
{
Status = ERentalRequestStatus.NotOk,
Message = string.Format("Vehicle with RegNo {0} can not be rented as it is already out for rent.", rentalRequest.RegNo)
};
}
return new RentalReceipt() { Status = ERentalRequestStatus.Ok };
}