public void CheckThatSpeedIsNotZeroAndDensityIsDecreasingIfTrafficLightIsGreenTest()
{
double density = 0.1;
double speed = 10;
var trafficFlow = new TrafficFlow {
TrafficDensity = density, TrafficSpeed = speed
};
trafficFlow.Path.Add(new Location(1, 0));
trafficFlow.Path.Add(new Location(1, 1));
trafficFlow.Path.Add(new Location(1, 2));
_trafficManager.AddTrafficFlow(trafficFlow);
_trafficManager.CalculateTrafficData();
var crossroad = (ICrossroad)_map.GetElement(1, 1);
_trafficManager.CalculateTrafficData(60);
Assert.AreEqual(0.0, crossroad.LeftToRightTrafficData.TrafficSpeed, Epsilon);
Assert.AreEqual(0.2666, crossroad.LeftToRightTrafficData.TrafficDensity, Epsilon);
_trafficManager.CalculateTrafficData(60);
Assert.AreEqual(0.0, crossroad.LeftToRightTrafficData.TrafficSpeed, Epsilon);
Assert.AreEqual(0.4333, crossroad.LeftToRightTrafficData.TrafficDensity, Epsilon);
crossroad.LeftToRightTrafficLight.SetTrafficLightState(TrafficLightState.Green);
_trafficManager.CalculateTrafficData(60);
Assert.AreEqual(speed, crossroad.LeftToRightTrafficData.TrafficSpeed, Epsilon);
Assert.AreEqual(0.2666, crossroad.LeftToRightTrafficData.TrafficDensity, Epsilon);
}
public void DensityCannotBeMoreThanOneTest()
{
double density1 = 0.9;
double speed1 = 10;
var trafficFlow1 = new TrafficFlow {
TrafficDensity = density1, TrafficSpeed = speed1
};
trafficFlow1.Path.Add(new Location(1, 0));
trafficFlow1.Path.Add(new Location(1, 1));
trafficFlow1.Path.Add(new Location(1, 2));
_trafficManager.AddTrafficFlow(trafficFlow1);
double density2 = 0.2;
double speed2 = 12;
var trafficFlow2 = new TrafficFlow {
TrafficDensity = density2, TrafficSpeed = speed2
};
trafficFlow2.Path.Add(new Location(2, 0));
trafficFlow2.Path.Add(new Location(1, 0));
trafficFlow2.Path.Add(new Location(1, 1));
trafficFlow2.Path.Add(new Location(1, 2));
_trafficManager.AddTrafficFlow(trafficFlow2);
_trafficManager.CalculateTrafficData();
var crossroad = (ICrossroad)_map.GetElement(1, 1);
Assert.AreEqual(1.0, crossroad.LeftToRightTrafficData.TrafficDensity, Epsilon);
}
public void DesnsityCannotBeDecreasedMoreThanCurrentTest()
{
double density = 0.1;
double speed = 10;
var trafficFlow = new TrafficFlow {
TrafficDensity = density, TrafficSpeed = speed
};
trafficFlow.Path.Add(new Location(1, 0));
trafficFlow.Path.Add(new Location(1, 1));
trafficFlow.Path.Add(new Location(1, 2));
_trafficManager.AddTrafficFlow(trafficFlow);
_trafficManager.CalculateTrafficData();
var crossroad = (ICrossroad)_map.GetElement(1, 1);
_trafficManager.CalculateTrafficData(60);
Assert.AreEqual(0.0, crossroad.LeftToRightTrafficData.TrafficSpeed, Epsilon);
Assert.AreEqual(0.2666, crossroad.LeftToRightTrafficData.TrafficDensity, Epsilon);
crossroad.LeftToRightTrafficLight.SetTrafficLightState(TrafficLightState.Green);
_trafficManager.CalculateTrafficData(60);
Assert.AreEqual(speed, crossroad.LeftToRightTrafficData.TrafficSpeed, Epsilon);
Assert.AreEqual(density, crossroad.LeftToRightTrafficData.TrafficDensity, Epsilon);
_trafficManager.CalculateTrafficData(60);
Assert.AreEqual(speed, crossroad.LeftToRightTrafficData.TrafficSpeed, Epsilon);
Assert.AreEqual(density, crossroad.LeftToRightTrafficData.TrafficDensity, Epsilon);
}
private static byte GetPacketTypeCode(IPAddress src, IPAddress dst, TrafficFlow flow)
{
byte flag = 0;
if (flow == TrafficFlow.Inbound)
{
flag |= Constants.InboundPacket;
}
else if (flow == TrafficFlow.Outbound)
{
flag |= Constants.OutboundPacket;
}
else
{
throw new InvalidOperationException("Invalid flow " + flow);
}
if (src.AddressFamily == AddressFamily.InterNetworkV6)
{
flag |= Constants.IPv6_Src;
}
if (dst.AddressFamily == AddressFamily.InterNetworkV6)
{
flag |= Constants.IPv6_Dst;
}
return(flag);
}
public void RedGreenSwitchTest()
{
double density = 1;
double speed = 10;
var trafficFlow = new TrafficFlow {
TrafficDensity = density, TrafficSpeed = speed
};
trafficFlow.Path.Add(new Location(1, 0));
trafficFlow.Path.Add(new Location(1, 1));
trafficFlow.Path.Add(new Location(1, 2));
trafficFlow.Path.Add(new Location(1, 3));
trafficFlow.Path.Add(new Location(1, 4));
_trafficManager.AddTrafficFlow(trafficFlow);
_trafficManager.CalculateTrafficData();
var crossroad = (ICrossroad)_map.GetElement(1, 3);
Assert.AreEqual(0, crossroad.LeftToRightTrafficData.TrafficDensity, Epsilon);
Assert.AreEqual(0, crossroad.LeftToRightTrafficData.TrafficSpeed, Epsilon);
var crossroadToSwitch = (ICrossroad)_map.GetElement(1, 1);
crossroadToSwitch.LeftToRightTrafficLight.SetTrafficLightState(TrafficLightState.Green);
_trafficManager.CalculateTrafficData();
Assert.AreEqual(density, crossroad.LeftToRightTrafficData.TrafficDensity, Epsilon);
Assert.AreEqual(speed, crossroad.LeftToRightTrafficData.TrafficSpeed, Epsilon);
}
private void extractTrafficDataFromSiteMeasurements(SiteMeasurements measurementsForSite)
{
String siteGUID = measurementsForSite.measurementSiteReference.id;
log.Info("TMU site ID: " + siteGUID);
log.Info("Number of measurements for TMU site: " + measurementsForSite.measuredValue.Length);
// There can be a number of measured values reported for the site
foreach (_SiteMeasurementsIndexMeasuredValue measuredValue in measurementsForSite.measuredValue)
{
MeasuredValue mv = measuredValue.measuredValue;
BasicData basicData = mv.basicData;
// The index number of the site measurement is important - as this
// relates the data
// to the NTIS reference model, which adds context to the value
// (e.g. lane information,
// or vehicle characteristics)
int index = measuredValue.index;
// Determine what class (type) of traffic data is contained in the
// basic data
if (basicData.GetType() == typeof(TrafficFlow))
{
TrafficFlow flow = (TrafficFlow)basicData;
log.Info("[Measurement Index : " + index + "] Vehicle Flow Rate: " + flow.vehicleFlow.vehicleFlowRate);
if (flow.vehicleFlow.dataError)
{
MultilingualStringValue[] errorReason = flow.vehicleFlow.reasonForDataError.values;
foreach (MultilingualStringValue value in errorReason)
{
log.Info(" Data in error. Reason: \"" + value.Value + "\"");
}
}
}
else if (basicData.GetType() == typeof(TrafficSpeed))
{
TrafficSpeed speed = (TrafficSpeed)basicData;
log.Info("[Measurement Index : " + index + "] Average Speed: " + speed.averageVehicleSpeed.speed);
}
else if (basicData.GetType() == typeof(TrafficHeadway))
{
TrafficHeadway headway = (TrafficHeadway)basicData;
log.Info("[Measurement Index : " + index + "] Average Headway: " + headway.averageTimeHeadway.duration);
}
else if (basicData.GetType() == typeof(TrafficConcentration))
{
TrafficConcentration concentration = (TrafficConcentration)basicData;
log.Info("[Measurement Index : " + index + "] Traffic Occupancy (%): " + concentration.occupancy.percentage);
}
else
{
log.Error("Unexpected traffic data type contained in publication: " + basicData.GetType().Name.ToString());
}
}
}
public void CalculateTrafficDataAddsDifferentTrafficFlows()
{
double density1 = 0.1;
double speed1 = 10;
var trafficFlow1 = new TrafficFlow {
TrafficDensity = density1, TrafficSpeed = speed1
};
trafficFlow1.Path.Add(new Location(1, 0));
trafficFlow1.Path.Add(new Location(1, 1));
trafficFlow1.Path.Add(new Location(1, 2));
_trafficManager.AddTrafficFlow(trafficFlow1);
double density2 = 0.2;
double speed2 = 12;
var trafficFlow2 = new TrafficFlow {
TrafficDensity = density2, TrafficSpeed = speed2
};
trafficFlow2.Path.Add(new Location(2, 0));
trafficFlow2.Path.Add(new Location(1, 0));
trafficFlow2.Path.Add(new Location(1, 1));
trafficFlow2.Path.Add(new Location(1, 2));
_trafficManager.AddTrafficFlow(trafficFlow2);
_trafficManager.CalculateTrafficData();
var crossroad = (ICrossroad)_map.GetElement(1, 1);
Assert.AreEqual(0, crossroad.LeftToUpTrafficData.TrafficDensity, Epsilon);
Assert.AreEqual(0, crossroad.LeftToUpTrafficData.TrafficSpeed, Epsilon);
Assert.AreEqual(density1 + density2, crossroad.LeftToRightTrafficData.TrafficDensity, Epsilon);
Assert.AreEqual((speed1 + speed2) / 2, crossroad.LeftToRightTrafficData.TrafficSpeed, Epsilon);
Assert.AreEqual(0, crossroad.LeftToDownTrafficData.TrafficDensity, Epsilon);
Assert.AreEqual(0, crossroad.LeftToDownTrafficData.TrafficSpeed, Epsilon);
Assert.AreEqual(0, crossroad.UpToLeftTrafficData.TrafficDensity, Epsilon);
Assert.AreEqual(0, crossroad.UpToLeftTrafficData.TrafficSpeed, Epsilon);
Assert.AreEqual(0, crossroad.UpToDownTrafficData.TrafficDensity, Epsilon);
Assert.AreEqual(0, crossroad.UpToDownTrafficData.TrafficSpeed, Epsilon);
Assert.AreEqual(0, crossroad.UpToRightTrafficData.TrafficDensity, Epsilon);
Assert.AreEqual(0, crossroad.UpToRightTrafficData.TrafficSpeed, Epsilon);
Assert.AreEqual(0, crossroad.RightToUpTrafficData.TrafficDensity, Epsilon);
Assert.AreEqual(0, crossroad.RightToUpTrafficData.TrafficSpeed, Epsilon);
Assert.AreEqual(0, crossroad.RightToLeftTrafficData.TrafficDensity, Epsilon);
Assert.AreEqual(0, crossroad.RightToLeftTrafficData.TrafficSpeed, Epsilon);
Assert.AreEqual(0, crossroad.RightToDownTrafficData.TrafficDensity, Epsilon);
Assert.AreEqual(0, crossroad.RightToDownTrafficData.TrafficSpeed, Epsilon);
Assert.AreEqual(0, crossroad.DownToLeftTrafficData.TrafficDensity, Epsilon);
Assert.AreEqual(0, crossroad.DownToLeftTrafficData.TrafficSpeed, Epsilon);
Assert.AreEqual(0, crossroad.DownToUpTrafficData.TrafficDensity, Epsilon);
Assert.AreEqual(0, crossroad.DownToUpTrafficData.TrafficSpeed, Epsilon);
Assert.AreEqual(0, crossroad.DownToRightTrafficData.TrafficDensity, Epsilon);
Assert.AreEqual(0, crossroad.DownToRightTrafficData.TrafficSpeed, Epsilon);
}
internal static void SetUpModelSettings(TrafficFlow trafficFlow)
{
TrafficFlow = trafficFlow;
Fuels = new List <FuelModel>();
// test
//Fuels.Add(new FuelModel(1, "АИ-92", 42.9));
// /test
}
private void processSituation(ElaboratedData elaboratedData, DateTime publicationTime, DateTime timeDefault)
{
LocationByReference locationByReference = null;
BasicData basicData = elaboratedData.basicData;
if (basicData.GetType() == typeof(TrafficHeadway))
{
TrafficHeadway data = (TrafficHeadway)basicData;
locationByReference = (LocationByReference)data.pertinentLocation;
}
else if (basicData.GetType() == typeof(TrafficFlow))
{
TrafficFlow data = (TrafficFlow)basicData;
locationByReference = (LocationByReference)data.pertinentLocation;
}
else if (basicData.GetType() == typeof(TrafficConcentration))
{
TrafficConcentration data = (TrafficConcentration)basicData;
locationByReference = (LocationByReference)data.pertinentLocation;
}
else if (basicData.GetType() == typeof(TrafficSpeed))
{
TrafficSpeed data = (TrafficSpeed)basicData;
locationByReference = (LocationByReference)data.pertinentLocation;
}
else if (basicData.GetType() == typeof(TravelTimeData))
{
TravelTimeData data = (TravelTimeData)basicData;
locationByReference = (LocationByReference)data.pertinentLocation;
}
else
{
logWrapper.Warning("basicData instance of -" + basicData.GetType().ToString());
}
String linkIdentifier = null;
if (locationByReference != null)
{
linkIdentifier = basicData.GetType().ToString() + locationByReference.predefinedLocationReference.id;
if (logWrapper.isTrace())
{
logWrapper.Trace("Processing Fused Sensor Only Identifier(" + linkIdentifier + ")");
}
FusedSensorOnlyData fusedSensorOnlyData = new FusedSensorOnlyData(linkIdentifier, publicationTime, timeDefault, elaboratedData);
fusedSensorOnlyDataStore.updateData(fusedSensorOnlyData);
}
else
{
logWrapper.Error("Failed to Process elaboratedData, " + elaboratedData.ToString());
}
}
public void AverageSpeedTest()
{
double density1 = 0.1;
double speed1 = 10;
var trafficFlow1 = new TrafficFlow {
TrafficDensity = density1, TrafficSpeed = speed1
};
trafficFlow1.Path.Add(new Location(0, 1));
trafficFlow1.Path.Add(new Location(1, 1));
trafficFlow1.Path.Add(new Location(1, 2));
trafficFlow1.Path.Add(new Location(1, 3));
trafficFlow1.Path.Add(new Location(1, 4));
_trafficManager.AddTrafficFlow(trafficFlow1);
double density2 = 0.2;
double speed2 = 11;
var trafficFlow2 = new TrafficFlow {
TrafficDensity = density2, TrafficSpeed = speed2
};
trafficFlow2.Path.Add(new Location(1, 0));
trafficFlow2.Path.Add(new Location(1, 1));
trafficFlow2.Path.Add(new Location(1, 2));
trafficFlow2.Path.Add(new Location(1, 3));
trafficFlow2.Path.Add(new Location(1, 4));
_trafficManager.AddTrafficFlow(trafficFlow2);
double density3 = 0.3;
double speed3 = 11;
var trafficFlow3 = new TrafficFlow {
TrafficDensity = density3, TrafficSpeed = speed3
};
trafficFlow3.Path.Add(new Location(2, 1));
trafficFlow3.Path.Add(new Location(1, 1));
trafficFlow3.Path.Add(new Location(1, 2));
trafficFlow3.Path.Add(new Location(1, 3));
trafficFlow3.Path.Add(new Location(1, 4));
_trafficManager.AddTrafficFlow(trafficFlow3);
var crossroad = (ICrossroad)_map.GetElement(1, 1);
crossroad.UpToRightTrafficLight.SetTrafficLightState(TrafficLightState.Green);
crossroad.LeftToRightTrafficLight.SetTrafficLightState(TrafficLightState.Red);
crossroad.DownToRightTrafficLight.SetTrafficLightState(TrafficLightState.Green);
_trafficManager.CalculateTrafficData();
var crossroadToCheck = (ICrossroad)_map.GetElement(1, 3);
Assert.AreEqual(density1 + density3, crossroadToCheck.LeftToRightTrafficData.TrafficDensity, Epsilon);
Assert.AreEqual((speed1 + speed3) / 2, crossroadToCheck.LeftToRightTrafficData.TrafficSpeed, Epsilon);
Assert.AreEqual(2, crossroadToCheck.LeftToRightTrafficData.NofPassingTrafficFlows, Epsilon);
}
internal static MappedTopology MapTopology(ModelingForm modelingForm,
Topology.Topology topology, TrafficFlow trafficFlow)
{
_modelingForm = modelingForm;
_topology = topology;
ModelSettings.SetUpModelSettings(trafficFlow);
_mappedTopology = new MappedTopology();
ElementPictureBoxProducer.SetUpElementPictureBoxProducer(modelingForm, _mappedTopology);
SetupPlaygroundPanel();
SetupServiceArea();
DestinationPointsDefiner.DefineElementsPoints(_mappedTopology);
return(_mappedTopology);
}
public void CalculateTrafficDataSetsInputTrafficParameters()
{
double density = 1;
double speed = 10;
var trafficFlow = new TrafficFlow {
TrafficDensity = density, TrafficSpeed = speed
};
trafficFlow.Path.Add(new Location(1, 0));
trafficFlow.Path.Add(new Location(1, 1));
trafficFlow.Path.Add(new Location(1, 2));
_trafficManager.AddTrafficFlow(trafficFlow);
_trafficManager.CalculateTrafficData();
var crossroad = (ICrossroad)_map.GetElement(1, 1);
Assert.AreEqual(0, crossroad.LeftToUpTrafficData.TrafficDensity, Epsilon);
Assert.AreEqual(0, crossroad.LeftToUpTrafficData.TrafficSpeed, Epsilon);
Assert.AreEqual(density, crossroad.LeftToRightTrafficData.TrafficDensity, Epsilon);
Assert.AreEqual(speed, crossroad.LeftToRightTrafficData.TrafficSpeed, Epsilon);
Assert.AreEqual(0, crossroad.LeftToDownTrafficData.TrafficDensity, Epsilon);
Assert.AreEqual(0, crossroad.LeftToDownTrafficData.TrafficSpeed, Epsilon);
Assert.AreEqual(0, crossroad.UpToLeftTrafficData.TrafficDensity, Epsilon);
Assert.AreEqual(0, crossroad.UpToLeftTrafficData.TrafficSpeed, Epsilon);
Assert.AreEqual(0, crossroad.UpToDownTrafficData.TrafficDensity, Epsilon);
Assert.AreEqual(0, crossroad.UpToDownTrafficData.TrafficSpeed, Epsilon);
Assert.AreEqual(0, crossroad.UpToRightTrafficData.TrafficDensity, Epsilon);
Assert.AreEqual(0, crossroad.UpToRightTrafficData.TrafficSpeed, Epsilon);
Assert.AreEqual(0, crossroad.RightToUpTrafficData.TrafficDensity, Epsilon);
Assert.AreEqual(0, crossroad.RightToUpTrafficData.TrafficSpeed, Epsilon);
Assert.AreEqual(0, crossroad.RightToLeftTrafficData.TrafficDensity, Epsilon);
Assert.AreEqual(0, crossroad.RightToLeftTrafficData.TrafficSpeed, Epsilon);
Assert.AreEqual(0, crossroad.RightToDownTrafficData.TrafficDensity, Epsilon);
Assert.AreEqual(0, crossroad.RightToDownTrafficData.TrafficSpeed, Epsilon);
Assert.AreEqual(0, crossroad.DownToLeftTrafficData.TrafficDensity, Epsilon);
Assert.AreEqual(0, crossroad.DownToLeftTrafficData.TrafficSpeed, Epsilon);
Assert.AreEqual(0, crossroad.DownToUpTrafficData.TrafficDensity, Epsilon);
Assert.AreEqual(0, crossroad.DownToUpTrafficData.TrafficSpeed, Epsilon);
Assert.AreEqual(0, crossroad.DownToRightTrafficData.TrafficDensity, Epsilon);
Assert.AreEqual(0, crossroad.DownToRightTrafficData.TrafficSpeed, Epsilon);
}
private void extractTrafficDataFromElaboratedData(ElaboratedData dataItem)
{
// Location is always specified as LocationByReference (referenced to a
// single Network Link)
LocationByReference location = (LocationByReference)dataItem.basicData.pertinentLocation;
log.Info("Data for Network Link: " + location.predefinedLocationReference.id);
BasicData basicData = dataItem.basicData;
// Determine what class (type) of traffic data is contained in the basic
// data
if (basicData.GetType() == typeof(TrafficSpeed))
{
TrafficSpeed speed = (TrafficSpeed)basicData;
log.Info("Average Speed: " + speed.averageVehicleSpeed.speed);
}
else if (basicData.GetType() == typeof(TravelTimeData))
{
TravelTimeData travelTimeData = (TravelTimeData)basicData;
log.Info("Travel Time: " + travelTimeData.travelTime.duration);
log.Info("Free Flow Travel Time: " + travelTimeData.freeFlowTravelTime.duration);
log.Info("Normally Expected Travel Time: " + travelTimeData.normallyExpectedTravelTime.duration);
}
else if (basicData.GetType() == typeof(TrafficFlow))
{
TrafficFlow flow = (TrafficFlow)basicData;
log.Info("Traffic Flow: " + flow.vehicleFlow.vehicleFlowRate);
}
else if (basicData.GetType() == typeof(TrafficConcentration))
{
TrafficConcentration concentration = (TrafficConcentration)basicData;
log.Info("Occupancy (%age): " + concentration.occupancy.percentage);
}
else if (basicData.GetType() == typeof(TrafficHeadway))
{
TrafficHeadway headway = (TrafficHeadway)basicData;
log.Info("Headway: " + headway.averageTimeHeadway.duration);
}
else
{
log.Error("Unexpected traffic data type contained in publication: " + dataItem.GetType().ToString());
}
}
private void btnOpenModeling_Click(object sender, EventArgs e)
{
if (rbRandomFlow.Checked == true)
{
try
{
switch (cbChooseDistributionLaw.SelectedIndex)
{
case (int)DistributionLaws.UniformDistribution:
randNumGenerator = new UniformDistribution((double)nudUniformDistParamA.Value, (double)nudUniformDistParamB.Value);
break;
case (int)DistributionLaws.NormalDistribution:
randNumGenerator = new NormalDistribution((double)nudNormalDistrExpectedValue.Value, (double)nudNormalDistrVariance.Value);
break;
case (int)DistributionLaws.ExponentialDistribution:
randNumGenerator = new ExponentialDistribution((double)nudExponentialDistrLambda.Value);
break;
default:
break;
}
}
catch (Exception exc)
{
MessageBox.Show(exc.Message);
return;
}
}
else
{
randNumGenerator = new DeterminedDistribution((double)nudDeterminedFlow.Value);
}
TrafficFlow trafficFlow = new TrafficFlow(randNumGenerator, (double)nudProbabilityOfStoppingAtGasStation.Value);
ModelingForm modeling = new ModelingForm(topology, trafficFlow);
modeling.Show();
Dispose();
Close();
}
public void CalculateNofPassedCarsTest()
{
double density = 1;
double speed = 10;
var trafficFlow = new TrafficFlow {
TrafficDensity = density, TrafficSpeed = speed
};
trafficFlow.Path.Add(new Location(1, 0));
trafficFlow.Path.Add(new Location(1, 1));
trafficFlow.Path.Add(new Location(1, 2));
_trafficManager.AddTrafficFlow(trafficFlow);
var crossroad = (ICrossroad)_map.GetElement(1, 1);
crossroad.LeftToRightTrafficLight.SetTrafficLightState(TrafficLightState.Green);
_trafficManager.CalculateTrafficData();
_trafficManager.CalculateNofPassedCars(60);
Assert.AreEqual(41.6666, crossroad.LeftToRightNofPassedCars, Epsilon);
}
public ModelingForm(Topology.Topology topology, TrafficFlow trafficFlow)
{
InitializeComponent();
RemoveUnusedControls();
DefineProperties();
LocateFormElements();
SetUpModelingTimeManager(timerModeling);
ElementSizeDefiner.TopologyCellSize = 50;
ClickEventProvider.SetUpClickEventProvider(this);
pictureBoxPauseAndPlay.MouseClick += ClickEventProvider.PictureBoxPauseAndPlay_Click;
_mappedTopology = TopologyMapper.MapTopology(this, topology, trafficFlow);
ModelingProcessor.SetUpModelingProcessor(this, _mappedTopology);
// not implemented
labelTotalTime.Hide();
labelTotalTimeValue.Hide();
// /not implemented
}
public void Step60SecondsTest()
{
var map = new Map.Infrastructure.Map(1, 3);
map.AddElement(0, 0, new Road());
map.AddElement(0, 1, new Crossroad());
map.AddElement(0, 2, new Road());
map.SetConnected(0, 0, 0, 1);
map.SetConnected(0, 1, 0, 2);
var trafficFlow = new TrafficFlow();
trafficFlow.TrafficDensity = 0.1;
trafficFlow.TrafficSpeed = 10;
trafficFlow.Path.Add(new Location(0, 0));
trafficFlow.Path.Add(new Location(0, 1));
trafficFlow.Path.Add(new Location(0, 2));
var trafficManager = new TrafficManager(map);
trafficManager.AddTrafficFlow(trafficFlow);
var engine = new SimulatorEngine(trafficManager);
var crossroad = (ICrossroad)map.GetElement(0, 1);
Assert.AreEqual(crossroad.LeftToRightTrafficLight.State, TrafficLightState.Red);
Assert.AreEqual(crossroad.LeftToRightTrafficData.TrafficDensity, trafficFlow.TrafficDensity, Epsilon);
Assert.AreEqual(crossroad.LeftToRightTrafficData.TrafficSpeed, trafficFlow.TrafficSpeed, Epsilon);
engine.Step(60);
Assert.AreEqual(TrafficLightState.Green, crossroad.LeftToRightTrafficLight.State);
engine.Step(60);
Assert.AreEqual(TrafficLightState.Green, crossroad.LeftToRightTrafficLight.State);
}
public void CalculateTrafficDataDoNotAddIfRedTrafficLight()
{
double density1 = 0.2;
double speed1 = 3;
var trafficFlow1 = new TrafficFlow {
TrafficDensity = density1, TrafficSpeed = speed1
};
trafficFlow1.Path.Add(new Location(1, 0));
trafficFlow1.Path.Add(new Location(1, 1));
trafficFlow1.Path.Add(new Location(1, 2));
trafficFlow1.Path.Add(new Location(1, 3));
trafficFlow1.Path.Add(new Location(1, 4));
_trafficManager.AddTrafficFlow(trafficFlow1);
double density2 = 0.4;
double speed2 = 7;
var trafficFlow2 = new TrafficFlow {
TrafficDensity = density2, TrafficSpeed = speed2
};
trafficFlow2.Path.Add(new Location(1, 2));
trafficFlow2.Path.Add(new Location(1, 3));
trafficFlow2.Path.Add(new Location(1, 4));
_trafficManager.AddTrafficFlow(trafficFlow2);
var crossroad1 = (ICrossroad)_map.GetElement(1, 1);
var crossroad2 = (ICrossroad)_map.GetElement(1, 3);
_trafficManager.CalculateTrafficData();
Assert.AreEqual(density1, crossroad1.LeftToRightTrafficData.TrafficDensity, Epsilon);
Assert.AreEqual(speed1, crossroad1.LeftToRightTrafficData.TrafficSpeed, Epsilon);
Assert.AreEqual(density2, crossroad2.LeftToRightTrafficData.TrafficDensity, Epsilon);
Assert.AreEqual(speed2, crossroad2.LeftToRightTrafficData.TrafficSpeed, Epsilon);
}
public void CheckIncreaseDecreaseDensityWitchTrafficFlowChangeTest()
{
double density1 = 0.1;
double speed1 = 5;
var trafficFlow1 = new TrafficFlow {
TrafficDensity = density1, TrafficSpeed = speed1
};
trafficFlow1.Path.Add(new Location(0, 1));
trafficFlow1.Path.Add(new Location(1, 1));
trafficFlow1.Path.Add(new Location(1, 2));
trafficFlow1.Path.Add(new Location(1, 3));
trafficFlow1.Path.Add(new Location(1, 4));
_trafficManager.AddTrafficFlow(trafficFlow1);
double density2 = 0.2;
double speed2 = 10;
var trafficFlow2 = new TrafficFlow {
TrafficDensity = density2, TrafficSpeed = speed2
};
trafficFlow2.Path.Add(new Location(1, 0));
trafficFlow2.Path.Add(new Location(1, 1));
trafficFlow2.Path.Add(new Location(1, 2));
trafficFlow2.Path.Add(new Location(1, 3));
trafficFlow2.Path.Add(new Location(1, 4));
_trafficManager.AddTrafficFlow(trafficFlow2);
var crossroadToSwitch = (ICrossroad)_map.GetElement(1, 1);
crossroadToSwitch.UpToRightTrafficLight.SetTrafficLightState(TrafficLightState.Green);
crossroadToSwitch.LeftToRightTrafficLight.SetTrafficLightState(TrafficLightState.Green);
_trafficManager.CalculateTrafficData();
var crossroad = (ICrossroad)_map.GetElement(1, 3);
_trafficManager.CalculateTrafficData(30);
_trafficManager.CalculateTrafficData(30);
Assert.AreEqual(0.0, crossroad.LeftToRightTrafficData.TrafficSpeed, Epsilon);
Assert.AreEqual(0.675, crossroad.LeftToRightTrafficData.TrafficDensity, Epsilon);
crossroadToSwitch.UpToRightTrafficLight.SetTrafficLightState(TrafficLightState.Red);
_trafficManager.CalculateTrafficData(30);
Assert.AreEqual(0.0, crossroad.LeftToRightTrafficData.TrafficSpeed, Epsilon);
Assert.AreEqual(0.8416, crossroad.LeftToRightTrafficData.TrafficDensity, Epsilon);
crossroad.LeftToRightTrafficLight.SetTrafficLightState(TrafficLightState.Green);
_trafficManager.CalculateTrafficData(30);
Assert.AreEqual(speed2, crossroad.LeftToRightTrafficData.TrafficSpeed, Epsilon);
Assert.AreEqual(0.675, crossroad.LeftToRightTrafficData.TrafficDensity, Epsilon);
_trafficManager.CalculateTrafficData(120);
Assert.AreEqual(speed2, crossroad.LeftToRightTrafficData.TrafficSpeed, Epsilon);
Assert.AreEqual(density2, crossroad.LeftToRightTrafficData.TrafficDensity, Epsilon);
}
public static void Should_ReturnTrafficFlowFromString(string trafficFlowType)
{
var trafficFlow = TrafficFlow.FromString(trafficFlowType);
Assert.Equal(trafficFlowType, trafficFlow.ToString());
}
public static void Should_ReturnDefaultTrafficFlow_IfStringDoesNotMatch()
{
var trafficFlowType = "obviouslyNotAValidOne";
var trafficFlow = TrafficFlow.FromString(trafficFlowType);
Assert.Equal(default, trafficFlow);
public void step60OnceMore()
{
/* Initialize next map
*
* | | |
* -+-+-+-
* || | ||
* -+-+-+-
* | | |
*/
var map = new Map.Infrastructure.Map(5, 7);
map.AddElement(0, 1, new Road());
map.AddElement(0, 3, new Road());
map.AddElement(0, 5, new Road());
map.AddElement(1, 0, new Turn());
map.AddElement(1, 1, new Crossroad());
map.AddElement(1, 2, new Road());
map.AddElement(1, 3, new Crossroad());
map.AddElement(1, 4, new Road());
map.AddElement(1, 5, new Crossroad());
map.AddElement(1, 6, new Turn());
map.AddElement(2, 0, new Road());
map.AddElement(2, 1, new Road());
map.AddElement(2, 3, new Road());
map.AddElement(2, 5, new Road());
map.AddElement(2, 6, new Road());
map.AddElement(3, 0, new Turn());
map.AddElement(3, 1, new Crossroad());
map.AddElement(3, 2, new Road());
map.AddElement(3, 3, new Crossroad());
map.AddElement(3, 4, new Road());
map.AddElement(3, 5, new Crossroad());
map.AddElement(3, 6, new Turn());
map.AddElement(4, 1, new Road());
map.AddElement(4, 3, new Road());
map.AddElement(4, 5, new Road());
map.SetConnected(0, 1, 1, 1);
map.SetConnected(0, 3, 1, 3);
map.SetConnected(0, 5, 1, 5);
map.SetConnected(1, 0, 1, 1);
map.SetConnected(1, 0, 2, 0);
map.SetConnected(1, 1, 1, 0);
map.SetConnected(1, 1, 2, 1);
map.SetConnected(1, 1, 1, 2);
map.SetConnected(1, 2, 1, 3);
map.SetConnected(1, 3, 2, 3);
map.SetConnected(1, 3, 1, 4);
map.SetConnected(1, 4, 1, 5);
map.SetConnected(1, 5, 2, 5);
map.SetConnected(1, 5, 1, 6);
map.SetConnected(1, 6, 2, 6);
map.SetConnected(2, 0, 3, 0);
map.SetConnected(2, 1, 3, 1);
map.SetConnected(2, 3, 3, 3);
map.SetConnected(2, 3, 3, 3);
map.SetConnected(2, 5, 3, 5);
map.SetConnected(2, 6, 3, 6);
map.SetConnected(3, 0, 3, 1);
map.SetConnected(3, 1, 4, 1);
map.SetConnected(3, 1, 3, 2);
map.SetConnected(3, 2, 3, 3);
map.SetConnected(3, 3, 4, 3);
map.SetConnected(3, 3, 3, 4);
map.SetConnected(3, 4, 3, 5);
map.SetConnected(3, 5, 4, 5);
map.SetConnected(3, 5, 3, 6);
var trafficFlow = new TrafficFlow();
trafficFlow.TrafficDensity = 0.1;
trafficFlow.TrafficSpeed = 60;
trafficFlow.Path.Add(new Location(0, 1));
trafficFlow.Path.Add(new Location(1, 1));
trafficFlow.Path.Add(new Location(2, 1));
trafficFlow.Path.Add(new Location(3, 1));
trafficFlow.Path.Add(new Location(3, 2));
trafficFlow.Path.Add(new Location(3, 3));
trafficFlow.Path.Add(new Location(3, 4));
var trafficFlow1 = new TrafficFlow();
trafficFlow1.TrafficDensity = 0.6;
trafficFlow1.TrafficSpeed = 30;
trafficFlow1.Path.Add(new Location(0, 1));
trafficFlow1.Path.Add(new Location(1, 1));
trafficFlow1.Path.Add(new Location(1, 2));
trafficFlow1.Path.Add(new Location(1, 3));
trafficFlow1.Path.Add(new Location(2, 3));
trafficFlow1.Path.Add(new Location(3, 3));
trafficFlow1.Path.Add(new Location(3, 4));
var trafficManager = new TrafficManager(map);
trafficManager.AddTrafficFlow(trafficFlow);
trafficManager.AddTrafficFlow(trafficFlow1);
var engine = new SimulatorEngine(trafficManager);
var crossroad = (ICrossroad)map.GetElement(1, 1);
Assert.AreEqual(crossroad.UpToDownTrafficLight.State, TrafficLightState.Red);
Assert.AreEqual(crossroad.UpToRightTrafficLight.State, TrafficLightState.Red);
engine.Step(60);
engine.Step(60);
engine.Step(60);
engine.Step(60);
Assert.AreEqual(TrafficLightState.Green, crossroad.UpToDownTrafficLight.State);
Assert.AreEqual(TrafficLightState.Green, crossroad.UpToRightTrafficLight.State);
engine.Step(60);
Assert.AreEqual(TrafficLightState.Green, crossroad.UpToDownTrafficLight.State);
Assert.AreEqual(TrafficLightState.Green, crossroad.UpToRightTrafficLight.State);
}
public void CheckAllLinesAndRecalculate()
{
double leftToUpDensity = 0.1;
double leftToUpSpeed = 2;
var leftToUpTrafficFlow = new TrafficFlow {
TrafficDensity = leftToUpDensity, TrafficSpeed = leftToUpSpeed
};
leftToUpTrafficFlow.Path.Add(new Location(1, 0));
leftToUpTrafficFlow.Path.Add(new Location(1, 1));
leftToUpTrafficFlow.Path.Add(new Location(0, 1));
_trafficManager.AddTrafficFlow(leftToUpTrafficFlow);
double leftToRightDensity = 0.3;
double leftToRightSpeed = 4;
var leftToRightTrafficFlow = new TrafficFlow
{
TrafficDensity = leftToRightDensity,
TrafficSpeed = leftToRightSpeed
};
leftToRightTrafficFlow.Path.Add(new Location(1, 0));
leftToRightTrafficFlow.Path.Add(new Location(1, 1));
leftToRightTrafficFlow.Path.Add(new Location(1, 2));
_trafficManager.AddTrafficFlow(leftToRightTrafficFlow);
double leftToDownDensity = 0.5;
double leftToDownSpeed = 6;
var leftToDownTrafficFlow = new TrafficFlow
{
TrafficDensity = leftToDownDensity,
TrafficSpeed = leftToDownSpeed
};
leftToDownTrafficFlow.Path.Add(new Location(1, 0));
leftToDownTrafficFlow.Path.Add(new Location(1, 1));
leftToDownTrafficFlow.Path.Add(new Location(2, 1));
_trafficManager.AddTrafficFlow(leftToDownTrafficFlow);
double rightToDownDensity = 0.7;
double rightToDownSpeed = 8;
var rightToDownTrafficFlow = new TrafficFlow
{
TrafficDensity = rightToDownDensity,
TrafficSpeed = rightToDownSpeed
};
rightToDownTrafficFlow.Path.Add(new Location(1, 2));
rightToDownTrafficFlow.Path.Add(new Location(1, 1));
rightToDownTrafficFlow.Path.Add(new Location(2, 1));
_trafficManager.AddTrafficFlow(rightToDownTrafficFlow);
double rightToLeftDensity = 0.9;
double rightToLeftSpeed = 10;
var rightToLeftTrafficFlow = new TrafficFlow
{
TrafficDensity = rightToLeftDensity,
TrafficSpeed = rightToLeftSpeed
};
rightToLeftTrafficFlow.Path.Add(new Location(1, 2));
rightToLeftTrafficFlow.Path.Add(new Location(1, 1));
rightToLeftTrafficFlow.Path.Add(new Location(1, 0));
_trafficManager.AddTrafficFlow(rightToLeftTrafficFlow);
double rightToUpDensity = 0.11;
double rightToUpSpeed = 12;
var rightToUpTrafficFlow = new TrafficFlow
{
TrafficDensity = rightToUpDensity,
TrafficSpeed = rightToUpSpeed
};
rightToUpTrafficFlow.Path.Add(new Location(1, 2));
rightToUpTrafficFlow.Path.Add(new Location(1, 1));
rightToUpTrafficFlow.Path.Add(new Location(0, 1));
_trafficManager.AddTrafficFlow(rightToUpTrafficFlow);
double upToLeftDensity = 0.13;
double upToLeftSpeed = 14;
var upToLeftTrafficFlow = new TrafficFlow {
TrafficDensity = upToLeftDensity, TrafficSpeed = upToLeftSpeed
};
upToLeftTrafficFlow.Path.Add(new Location(0, 1));
upToLeftTrafficFlow.Path.Add(new Location(1, 1));
upToLeftTrafficFlow.Path.Add(new Location(1, 0));
_trafficManager.AddTrafficFlow(upToLeftTrafficFlow);
double upToDownDensity = 0.15;
double upToDownSpeed = 16;
var upToDownTrafficFlow = new TrafficFlow {
TrafficDensity = upToDownDensity, TrafficSpeed = upToDownSpeed
};
upToDownTrafficFlow.Path.Add(new Location(0, 1));
upToDownTrafficFlow.Path.Add(new Location(1, 1));
upToDownTrafficFlow.Path.Add(new Location(2, 1));
_trafficManager.AddTrafficFlow(upToDownTrafficFlow);
double upToRightDensity = 0.17;
double upToRightSpeed = 18;
var upToRightTrafficFlow = new TrafficFlow
{
TrafficDensity = upToRightDensity,
TrafficSpeed = upToRightSpeed
};
upToRightTrafficFlow.Path.Add(new Location(0, 1));
upToRightTrafficFlow.Path.Add(new Location(1, 1));
upToRightTrafficFlow.Path.Add(new Location(1, 2));
_trafficManager.AddTrafficFlow(upToRightTrafficFlow);
double downToLeftDensity = 0.19;
double downToLeftSpeed = 20;
var downToLeftTrafficFlow = new TrafficFlow
{
TrafficDensity = downToLeftDensity,
TrafficSpeed = downToLeftSpeed
};
downToLeftTrafficFlow.Path.Add(new Location(2, 1));
downToLeftTrafficFlow.Path.Add(new Location(1, 1));
downToLeftTrafficFlow.Path.Add(new Location(1, 0));
_trafficManager.AddTrafficFlow(downToLeftTrafficFlow);
double downToUpDensity = 0.21;
double downToUpSpeed = 22;
var downToUpTrafficFlow = new TrafficFlow {
TrafficDensity = downToUpDensity, TrafficSpeed = downToUpSpeed
};
downToUpTrafficFlow.Path.Add(new Location(2, 1));
downToUpTrafficFlow.Path.Add(new Location(1, 1));
downToUpTrafficFlow.Path.Add(new Location(0, 1));
_trafficManager.AddTrafficFlow(downToUpTrafficFlow);
double downToRightDensity = 0.23;
double downToRightSpeed = 24;
var downToRightTrafficFlow = new TrafficFlow
{
TrafficDensity = downToRightDensity,
TrafficSpeed = downToRightSpeed
};
downToRightTrafficFlow.Path.Add(new Location(2, 1));
downToRightTrafficFlow.Path.Add(new Location(1, 1));
downToRightTrafficFlow.Path.Add(new Location(1, 2));
_trafficManager.AddTrafficFlow(downToRightTrafficFlow);
var crossroad = (ICrossroad)_map.GetElement(1, 1);
_trafficManager.CalculateTrafficData();
Assert.AreEqual(leftToUpDensity, crossroad.LeftToUpTrafficData.TrafficDensity, Epsilon);
Assert.AreEqual(leftToUpSpeed, crossroad.LeftToUpTrafficData.TrafficSpeed, Epsilon);
Assert.AreEqual(leftToRightDensity, crossroad.LeftToRightTrafficData.TrafficDensity, Epsilon);
Assert.AreEqual(leftToRightSpeed, crossroad.LeftToRightTrafficData.TrafficSpeed, Epsilon);
Assert.AreEqual(leftToDownDensity, crossroad.LeftToDownTrafficData.TrafficDensity, Epsilon);
Assert.AreEqual(leftToDownSpeed, crossroad.LeftToDownTrafficData.TrafficSpeed, Epsilon);
Assert.AreEqual(rightToDownDensity, crossroad.RightToDownTrafficData.TrafficDensity, Epsilon);
Assert.AreEqual(rightToDownSpeed, crossroad.RightToDownTrafficData.TrafficSpeed, Epsilon);
Assert.AreEqual(rightToLeftDensity, crossroad.RightToLeftTrafficData.TrafficDensity, Epsilon);
Assert.AreEqual(rightToLeftSpeed, crossroad.RightToLeftTrafficData.TrafficSpeed, Epsilon);
Assert.AreEqual(rightToUpDensity, crossroad.RightToUpTrafficData.TrafficDensity, Epsilon);
Assert.AreEqual(rightToUpSpeed, crossroad.RightToUpTrafficData.TrafficSpeed, Epsilon);
Assert.AreEqual(upToLeftDensity, crossroad.UpToLeftTrafficData.TrafficDensity, Epsilon);
Assert.AreEqual(upToLeftSpeed, crossroad.UpToLeftTrafficData.TrafficSpeed, Epsilon);
Assert.AreEqual(upToDownDensity, crossroad.UpToDownTrafficData.TrafficDensity, Epsilon);
Assert.AreEqual(upToDownSpeed, crossroad.UpToDownTrafficData.TrafficSpeed, Epsilon);
Assert.AreEqual(upToRightDensity, crossroad.UpToRightTrafficData.TrafficDensity, Epsilon);
Assert.AreEqual(upToRightSpeed, crossroad.UpToRightTrafficData.TrafficSpeed, Epsilon);
Assert.AreEqual(downToLeftDensity, crossroad.DownToLeftTrafficData.TrafficDensity, Epsilon);
Assert.AreEqual(downToLeftSpeed, crossroad.DownToLeftTrafficData.TrafficSpeed, Epsilon);
Assert.AreEqual(downToUpDensity, crossroad.DownToUpTrafficData.TrafficDensity, Epsilon);
Assert.AreEqual(downToUpSpeed, crossroad.DownToUpTrafficData.TrafficSpeed, Epsilon);
Assert.AreEqual(downToRightDensity, crossroad.DownToRightTrafficData.TrafficDensity, Epsilon);
Assert.AreEqual(downToRightSpeed, crossroad.DownToRightTrafficData.TrafficSpeed, Epsilon);
_trafficManager.CalculateTrafficData();
Assert.AreEqual(leftToUpDensity, crossroad.LeftToUpTrafficData.TrafficDensity, Epsilon);
Assert.AreEqual(leftToUpSpeed, crossroad.LeftToUpTrafficData.TrafficSpeed, Epsilon);
Assert.AreEqual(leftToRightDensity, crossroad.LeftToRightTrafficData.TrafficDensity, Epsilon);
Assert.AreEqual(leftToRightSpeed, crossroad.LeftToRightTrafficData.TrafficSpeed, Epsilon);
Assert.AreEqual(leftToDownDensity, crossroad.LeftToDownTrafficData.TrafficDensity, Epsilon);
Assert.AreEqual(leftToDownSpeed, crossroad.LeftToDownTrafficData.TrafficSpeed, Epsilon);
Assert.AreEqual(rightToDownDensity, crossroad.RightToDownTrafficData.TrafficDensity, Epsilon);
Assert.AreEqual(rightToDownSpeed, crossroad.RightToDownTrafficData.TrafficSpeed, Epsilon);
Assert.AreEqual(rightToLeftDensity, crossroad.RightToLeftTrafficData.TrafficDensity, Epsilon);
Assert.AreEqual(rightToLeftSpeed, crossroad.RightToLeftTrafficData.TrafficSpeed, Epsilon);
Assert.AreEqual(rightToUpDensity, crossroad.RightToUpTrafficData.TrafficDensity, Epsilon);
Assert.AreEqual(rightToUpSpeed, crossroad.RightToUpTrafficData.TrafficSpeed, Epsilon);
Assert.AreEqual(upToLeftDensity, crossroad.UpToLeftTrafficData.TrafficDensity, Epsilon);
Assert.AreEqual(upToLeftSpeed, crossroad.UpToLeftTrafficData.TrafficSpeed, Epsilon);
Assert.AreEqual(upToDownDensity, crossroad.UpToDownTrafficData.TrafficDensity, Epsilon);
Assert.AreEqual(upToDownSpeed, crossroad.UpToDownTrafficData.TrafficSpeed, Epsilon);
Assert.AreEqual(upToRightDensity, crossroad.UpToRightTrafficData.TrafficDensity, Epsilon);
Assert.AreEqual(upToRightSpeed, crossroad.UpToRightTrafficData.TrafficSpeed, Epsilon);
Assert.AreEqual(downToLeftDensity, crossroad.DownToLeftTrafficData.TrafficDensity, Epsilon);
Assert.AreEqual(downToLeftSpeed, crossroad.DownToLeftTrafficData.TrafficSpeed, Epsilon);
Assert.AreEqual(downToUpDensity, crossroad.DownToUpTrafficData.TrafficDensity, Epsilon);
Assert.AreEqual(downToUpSpeed, crossroad.DownToUpTrafficData.TrafficSpeed, Epsilon);
Assert.AreEqual(downToRightDensity, crossroad.DownToRightTrafficData.TrafficDensity, Epsilon);
Assert.AreEqual(downToRightSpeed, crossroad.DownToRightTrafficData.TrafficSpeed, Epsilon);
}
