/// <summary> /// generate data packet from this vechile to the TargetVehicle. /// </summary> /// <param name="DestinationVehicle"></param> public void GeneratePacket(VehicleUi DestinationVehicle) { Dispatcher.Invoke((Action) delegate { Packet packet = new Packet(); packet.Type = PacketType.Data; PublicStatistics.GeneratedPacketsCount += 1; packet.PID = PublicStatistics.GeneratedPacketsCount; packet.PacketLength = PublicParamerters.DataPacketLength; packet.TravelledRoadSegmentString += CurrentLane.MyRoadSegment.RID; // add the first rs. packet.VehiclesString += VID; // start by current sender. packet.SRID = CurrentLane.MyRoadSegment.RID; // set source and distination: packet.SourceVehicle = this; packet.DestinationVehicle = DestinationVehicle; packet.Direction = DestinationVehicle.CurrentLane.LaneDirection; packet.CurrentRoadSegment = CurrentLane.MyRoadSegment; // the segment of the vechile. packet.EuclideanDistance = Computations.Distance(InstanceLocation, DestinationVehicle.InstanceLocation); // the intial distance packet.RoutingDistance = packet.EuclideanDistance; packet.SVID = VID; packet.DVID = DestinationVehicle.VID; this.SetNotationSign(NotationsSign.HasPacket); DestinationVehicle.SetNotationSign(NotationsSign.Destination); DestinationVehicle.WaitingPacketsIDsList.Add(packet.PID); // flage // start count the delay. PacketQueue.Enqueue(packet); // add the packet to the queue. PacketQueueTimer.Interval = TimeSpan.FromSeconds(PublicParamerters.PacketQueueTimerInterval); // retry after... PacketQueueTimer.Start(); // start the timer. }); }
/// <summary> /// Perpendicular distance distribution ψ ̃_(i,j) allocates higher probability for the junctions that are closer to the central line l_(s,b)(i.e., a virtual line linking the source junction v_s and the destination v_b). See Fig.2. The perpendicular distance ψ_j from the node 〖 v〗_j to the line l_(s,b) is defined by Eq. (18). For the source junction〖 v〗_i, we define the normalized perpendicular-distance random variable ψ ̅_i=(ψ ̅_(i,1),ψ ̅_(i,3),…ψ ̅_(i,b_i ) ) by Eq. (19). Furthermore, we define the perpendicular-distance probability distribution, denoted by ψ ̃_i=(ψ ̃_(i,1),ψ ̃_(i,2)…ψ ̃_(i,b_i ) ), by Eq. (20). /// </summary> /// <param name="j"></param> /// <param name="s"></param> /// <param name="b"></param> /// <returns></returns> public double Perpendiculardistance(Point pj, Point psource, Point pdistanction) { double past = Math.Abs(((pdistanction.Y - psource.Y) * pj.X) - ((pdistanction.X - psource.X) * pj.Y) + (pdistanction.X * psource.Y) - (pdistanction.Y * psource.X)); double sbDis = Computations.Distance(psource, pdistanction); double perDis = past / sbDis; // dist: if there is a mistake, then we should consider the normalization. double pr = Math.Exp(-perDis); return(pr); }
/// <summary> /// x=√((x ̌_j-x ̌_i )^2+(y ̌_j-y ̌_i )^2 )⁄δ /// </summary> /// <param name="i"></param> /// <param name="j"></param> /// <param name="comrange"></param> /// <returns></returns> public static double TransmissionDistance(Point i, Point j, double comrange) { double dis = Computations.Distance(i, j); if (dis <= comrange) { return(dis / comrange); } else { return(1); } }
/// <summary> /// get the junction when the packet is justc generated. /// </summary> /// <returns></returns> public Junction GetIntializedJunction(Packet packet) { Junction desveheadingJunct = packet.DestinationJunction; double disToStartJun = Computations.Distance(desveheadingJunct.CenterLocation, StartJunction.CenterLocation); double disToEndJun = Computations.Distance(desveheadingJunct.CenterLocation, EndJunction.CenterLocation); if (disToStartJun > disToEndJun) { return(EndJunction); } else { return(StartJunction); } }
/// <summary> /// is in the front /// </summary> /// <param name="i"></param> /// <param name="j"></param> /// <param name="d">destination</param> /// <returns></returns> public static double MovingDirection(Point i, Point j, Point d) { double axb = ((j.X - i.X) * (d.X - i.X)) + ((j.Y - i.Y) * (d.Y - i.Y)); double disMul = Computations.Distance(i, d) * Computations.Distance(i, j); double angale = Math.Acos(axb / disMul); double norAngle = angale / Math.PI; if (norAngle <= 0.5) { return(norAngle); } else { return(1); } }
/// <summary> /// d should be the heading distance of v. /// </summary> /// <param name="i"></param> /// <param name="j"></param> /// <param name="d"></param> /// <returns></returns> private static double AngleDotProdection(Point i, Point j, Point d) { double axb = ((j.X - i.X) * (d.X - i.X)) + ((j.Y - i.Y) * (d.Y - i.Y)); double disMul = Computations.Distance(i, d) * Computations.Distance(i, j); double angale = Math.Acos(axb / disMul); double norAngle = angale / Math.PI; if (norAngle <= 0.5) { return(norAngle); } else { return(1); // behind. } }
/// <summary> /// Direction Angle: The direction angle θ_(i,j)between the junction v_i and the potential forwarder v_j towards the destination junction v_b is modeled as a dot production of two vectors a ⃗.c ⃗, such that a ⃗=(x_j-x_i,y_j-y_i ) and c ⃗=(x_b-x_i,y_b-y_i ) and normalized to π by Eq. (16). The normalized-direction θ ̅_i=(θ ̅_(i,1),θ ̅_(i,2),…θ ̅_(i,b_i )) are injected to the mass function Eq. (17) to obtain the random variable (θ_i ) ̃=(θ ̃_(i,1),θ ̃_(i,2)…θ ̃_(i,b_i ) ). Direction distribution assigns higher probability for the normalized angles 0≤θ ̅_(i,j)≤1/2 that ensure higher routing progress. /// </summary> /// <param name="isender"></param> /// <param name="jcandidate"></param> /// <param name="bDestination"></param> /// <returns></returns> public double AngleDotProdection(Point i, Point j, Point d) { double axb = (j.X - i.X) * (d.X - i.X) + (j.Y - i.Y) * (d.Y - i.Y); double disMul = Computations.Distance(i, d) * Computations.Distance(i, j); double angale = Math.Acos(axb / disMul); double norAngle = angale / Math.PI; if (norAngle <= 0.5) { return(Math.Pow(((1 - (norAngle * Math.Exp(norAngle))) / (1 + (norAngle * Math.Exp(norAngle)))), 1)); // heigher pri } else { return(Math.Pow(((1 - (norAngle * Math.Exp(norAngle))) / (1 + (norAngle * Math.Exp(norAngle)))), 3)); // smaller pri } }
/// <summary> /// forward the packet to the NEXT /// </summary> /// <param name="packet"></param> /// <param name="next"></param> public void RelayPacket(Packet packet, VehicleUi next) { Dispatcher.Invoke((Action) delegate { packet.PathWaitingTimes += packet.HopWaitingTimes; // save the path waiting time and clear the hop. packet.HopWaitingTimes = 0; // re-intilize the hop-waiting. packet.PropagationAndTransmissionDelay += DelayModel.Delay(this, next); packet.HopsVehicles += 1; packet.RoutingDistance += Computations.Distance(InstanceLocation, next.InstanceLocation); packet.VehiclesString += "-" + next.VID; next.RecievePacket(packet); PacketQueueTimer.Interval = TimeSpan.FromSeconds(PublicParamerters.PacketQueueTimerInterval); // retry after... next.SetNotationSign(NotationsSign.HasPacket); SetNotationSign(NotationsSign.HasNoPacket); }); }
public VehicleUi GetDestinationWithinAdistance(VehicleUi src, double dis) { foreach (VehicleUi des in MyVehicles) { double accualdistance = Computations.Distance(src.InstanceLocation, des.InstanceLocation); double thesould = 2 * Math.Sqrt(dis); double uper_tollerance = dis + thesould; double lower_tollerance = dis - thesould; if (accualdistance >= lower_tollerance && accualdistance <= uper_tollerance) { return(des); } } return(null); }
/// <summary> /// the instance location of the the three vechiles. sender , next hop and the destination. /// </summary> /// <param name="i"></param> /// <param name="j"></param> /// <param name="d"></param> /// <returns></returns> private double MovingDirectionDis(Point i, Point j, Point d) { double axb = (j.X - i.X) * (d.X - i.X) + (j.Y - i.Y) * (d.Y - i.Y); double disMul = Computations.Distance(i, d) * Computations.Distance(i, j); double angale = Math.Acos(axb / disMul); double norAngle = angale / Math.PI; if (norAngle <= 0.5) { // smaller angle means closer to the destination. double bast = norAngle * Math.Exp(norAngle); double mak = 1 + (norAngle * Math.Exp(norAngle)); double mikdar = bast / mak; double re = Math.Pow(1 - mikdar, Settings.Default.IntraVehiForwardDirectionPar); // smaller IntraVehiForwardDirectionPar value means heigher pri for the forward dir return(re); } else { return(Math.Pow(((1 - (norAngle * Math.Exp(norAngle))) / (1 + (norAngle * Math.Exp(norAngle)))), Settings.Default.IntraVehiBackwardDirectionPar)); // heigher IntraVehiBackwardDirectionPar smaller prioiry for the node which not in the direction. } }
/// <summary> /// Givvs heigher priorit to the shortest. /// Road Segment Length: This distribution allocates higher probability to the longer segment. Longer segments are more preferable to avoid frequent segment switching that leads to delay the packet. For the source junction〖 v〗_i, we define the normalized segment length random variable L ̅_i=(L ̅_(i,1),L ̅_(i,3),…L ̅_(i,b_i ) ) by Eq. (21). Furthermore, we define the segment length probability distribution, denoted by L ̃_i=(L ̃_(i,1),L ̃_(i,2)…L ̃_(i,b_i ) ), by the mass function as formulated in Eq. (22). /// </summary> /// <param name="i"></param> /// <param name="j"></param> /// <returns></returns> public static double Length(Point i, Point j) { return(1 - (1 / Math.Log10(Computations.Distance(i, j)))); }
/// <summary> /// Road Segment Length: This distribution allocates higher probability to the longer segment. Longer segments are more preferable to avoid frequent segment switching that leads to delay the packet. For the source junction〖 v〗_i, we define the normalized segment length random variable L ̅_i=(L ̅_(i,1),L ̅_(i,3),…L ̅_(i,b_i ) ) by Eq. (21). Furthermore, we define the segment length probability distribution, denoted by L ̃_i=(L ̃_(i,1),L ̃_(i,2)…L ̃_(i,b_i ) ), by the mass function as formulated in Eq. (22). /// </summary> /// <param name="i"></param> /// <param name="j"></param> /// <returns></returns> public double Length(Point i, Point j) { double len = Computations.Distance(i, j); return(1 - Math.Sqrt(Math.Exp(-len))); }
/// <summary> /// isRouted= true when both the sender and the dest vechiles are in the same segment. /// </summary> /// <param name="i"></param> /// <param name="MyroadSegment"></param> /// <returns></returns> public CandidateVehicle GetCandidateVehicleUis(VehicleUi i, List <VehicleUi> NodesList, VehicleUi desVehicle, bool isRouted) { string protocol = Settings.Default.RoutingProtocolString; List <CandidateVehicle> candidates = new List <CandidateVehicle>(); List <CandidateVehicle> neighbors = new List <CandidateVehicle>(); double sum = 0; if (NodesList.Count > 0) { foreach (VehicleUi j in NodesList) { if (isRouted) { switch (protocol) { case "VEFR": { // des and sender vehicles both are in the same raod segment. CandidateVehicle jcan = new CandidateVehicle(); jcan.SVID = i.VID; jcan.SelectedVehicle = j; jcan.RVSInput = new RVSInput(); if (Settings.Default.SaveVehiclesCrisp) { jcan.RVSInput.ID = PublicParamerters.sessionID; jcan.RVSInput.DesVehlocation = desVehicle.InstanceLocation; jcan.RVSInput.CurrentVehlocation = i.InstanceLocation; jcan.RVSInput.CandidateVehlocation = j.InstanceLocation; jcan.RVSInput.CurrentVehSpeedInKMH = i.GetSpeedInKMH; jcan.RVSInput.CandidateVehSpeedInKMH = j.GetSpeedInKMH; PublicParamerters.RVSInputList.Add(jcan.RVSInput); // print.. this can be removed } jcan.RVSInput.MovingDirectionCrisp = Crisps.MovingDirection(i.InstanceLocation, j.InstanceLocation, desVehicle.InstanceLocation); jcan.RVSInput.SpeedDifferenceCrisp = Crisps.SpeedDifference(i.GetSpeedInKMH, j.GetSpeedInKMH, Settings.Default.MaxSpeed); // make sure of this i.GetSpeedInKMH jcan.RVSInput.TransmissionDistanceCrisp = Crisps.TransmissionDistance(i.InstanceLocation, j.InstanceLocation, Settings.Default.CommunicationRange); jcan.Priority = jcan.RVSInput.Priority; sum += jcan.Priority; neighbors.Add(jcan); if (j == desVehicle) { return(jcan); } } break; case "HERO": { // des and sender vehicles both are in the same raod segment. CandidateVehicle jcan = new CandidateVehicle(); jcan.SVID = i.VID; jcan.SelectedVehicle = j; jcan.BufferSizeDistribution = BufferSizeDistribution(j.PacketQueue.Count, PublicParamerters.BufferSize); jcan.SignalFadingDistribution = SignalFadingDistribution(Computations.Distance(i.InstanceLocation, j.InstanceLocation), Settings.Default.CommunicationRange); jcan.SpeedDifferenceDistribution = SpeedDifferenceDistribution(i.GetSpeedInKMH, j.GetSpeedInKMH, roadSegment.MaxAllowedSpeed); jcan.MovingDirection = MovingDirectionDis(i.InstanceLocation, j.InstanceLocation, desVehicle.InstanceLocation); sum += jcan.HeursticFunction; neighbors.Add(jcan); if (j == desVehicle) { return(jcan); } } break; } } else { // not in the same segment: switch (protocol) { case "VEFR": { CandidateVehicle jcan = new CandidateVehicle(); jcan.SVID = i.VID; jcan.SelectedVehicle = j; jcan.RVSInput = new RVSInput(); if (Settings.Default.SaveVehiclesCrisp) { jcan.RVSInput.ID = PublicParamerters.sessionID; jcan.RVSInput.DesVehlocation = desVehicle.InstanceLocation; jcan.RVSInput.CurrentVehlocation = i.InstanceLocation; jcan.RVSInput.CandidateVehlocation = j.InstanceLocation; jcan.RVSInput.CurrentVehSpeedInKMH = i.GetSpeedInKMH; jcan.RVSInput.CandidateVehSpeedInKMH = j.GetSpeedInKMH; PublicParamerters.RVSInputList.Add(jcan.RVSInput); // print.. this can be removed } jcan.RVSInput.MovingDirectionCrisp = Crisps.MovingDirection(i.InstanceLocation, j.InstanceLocation, desVehicle.EndJunction.CenterLocation); // make sure of this. // { jcan.RVSInput.SpeedDifferenceCrisp = Crisps.SpeedDifference(i.GetSpeedInKMH, j.GetSpeedInKMH, Settings.Default.MaxSpeed); // make sure of this i.GetSpeedInKMH jcan.RVSInput.TransmissionDistanceCrisp = Crisps.TransmissionDistance(i.InstanceLocation, j.InstanceLocation, Settings.Default.CommunicationRange); jcan.Priority = jcan.RVSInput.Priority; sum += jcan.RVSInput.Priority; neighbors.Add(jcan); } break; case "HERO": { // not in the same segment: CandidateVehicle jcan = new CandidateVehicle(); jcan.SVID = i.VID; jcan.SelectedVehicle = j; jcan.BufferSizeDistribution = BufferSizeDistribution(j.PacketQueue.Count, PublicParamerters.BufferSize); jcan.SignalFadingDistribution = SignalFadingDistribution(Computations.Distance(i.InstanceLocation, j.InstanceLocation), Settings.Default.CommunicationRange); jcan.SpeedDifferenceDistribution = SpeedDifferenceDistribution(i.GetSpeedInKMH, j.GetSpeedInKMH, roadSegment.MaxAllowedSpeed); jcan.MovingDirection = MovingDirectionDis(i.InstanceLocation, j.InstanceLocation, desVehicle.EndJunction.CenterLocation); sum += jcan.HeursticFunction; neighbors.Add(jcan); } break; } } } switch (protocol) { case "VEFR": { if (neighbors.Count > 0) { // get max: CandidateVehicle max = neighbors[0]; if (max != null) { for (int j = 1; j < neighbors.Count; j++) { if (neighbors[j].Priority > max.Priority) { max = neighbors[j]; } } return(max); } } } break; case "HERO": { if (neighbors.Count > 0) { double average = (1 / Convert.ToDouble((neighbors.Count))); double Priority_threshould = average; foreach (CandidateVehicle jcan in neighbors) { double x = jcan.HeursticFunction / sum; jcan.Priority = x; if (jcan.Priority >= Priority_threshould) { candidates.Add(jcan); } } // get max: if (candidates.Count == 0) { return(null); } else if (candidates.Count == 1) { return(candidates[0]); } else { // get max: CandidateVehicle max = candidates[0]; if (max != null) { for (int j = 1; j < candidates.Count; j++) { if (candidates[j].Priority > max.Priority) { max = candidates[j]; } } return(max); } } } } break; } } return(null); }