예제 #1
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="FromSensor"></param>
        /// <param name="ToSensor"></param>
        /// <param name="datap"></param>
        public void ReceiveData(Sensor FromSensor, Sensor ToSensor, Datapacket datap)
        {
            if (ToSensor != null || FromSensor != null)
            {
                if (ToSensor.ID != FromSensor.ID)
                {
                    if (ToSensor.ResidualEnergy > 0)
                    {
                        SensorRoutingLog log = new SensorRoutingLog();
                        log.IsReceive            = true;
                        log.NodeID               = this.ID;
                        log.Operation            = "From:" + FromSensor.ID;
                        log.Time                 = DateTime.Now;
                        log.Distance_M           = Operations.DistanceBetweenTwoSensors(ToSensor, FromSensor);
                        log.UsedEnergy_Nanojoule = EnergyModel.Receive(RoutingDataLength);
                        log.PID = datap.PacektSequentID;
                        // set the remain battery Energy:
                        if (ToSensor.ID != PublicParamerters.SinkNode.ID)
                        {
                            double remainEnergy = ResidualEnergy - log.UsedEnergy_Joule;
                            ToSensor.ResidualEnergy       = remainEnergy;
                            log.RemaimBatteryEnergy_Joule = ResidualEnergy;
                        }

                        // routing distance:
                        datap.Path             += ">" + ToSensor.ID;
                        datap.RoutingDistance  += log.Distance_M;
                        datap.Hops             += 1;
                        datap.UsedEnergy_Joule += log.UsedEnergy_Joule;
                        datap.Delay            += DelayModel.DelayModel.Delay(FromSensor, ToSensor);

                        // random:
                        if (datap.IsRandomControls)
                        {
                            // forward: with random random controls:
                            // calculate adil relatives:
                            Sensor RelayNode = ToSensor;
                            DistributionsComputations    relatives      = new DistributionsComputations();
                            List <double>                Controls       = RandomControls.Generate4Controls();
                            List <RoutingRandomVariable> RelativityRows = relatives.ComputeDistributions(datap.SourceNode, PublicParamerters.SinkNode, RelayNode, Controls[0], Controls[1], Controls[2], Controls[3]);
                            SeletNextHopRandomlly        randomGenrator = new SeletNextHopRandomlly();
                            RoutingRandomVariable        nextHop        = randomGenrator.SelectNextHop(RelativityRows);
                            if (nextHop != null) // not the sink
                            {
                                //: historial record:
                                if (Settings.Default.KeepLogs)
                                {
                                    // log.ForwardingRandomNumber = datap.ForwardingRandomNumber;
                                    ToSensor.Logs.Add(log);                            // add the log
                                    HistoricalRelativityRows.AddRange(RelativityRows); // add the log
                                }
                                // forward:
                                Datapacket forwardPacket;
                                if (RelativityRows.Count > 0)
                                {
                                    Sensor NextHopNode = nextHop.NextHopNode;
                                    forwardPacket = new Datapacket(RelayNode, NextHopNode);
                                    forwardPacket.ForwardingRandomNumber = randomGenrator.RandomeNumber;
                                    forwardPacket.SourceNodeID           = datap.SourceNodeID;
                                    forwardPacket.Distance                  = datap.Distance;
                                    forwardPacket.RoutingDistance           = datap.RoutingDistance;
                                    forwardPacket.Path                      = datap.Path;
                                    forwardPacket.Hops                      = datap.Hops;
                                    forwardPacket.UsedEnergy_Joule          = datap.UsedEnergy_Joule;
                                    forwardPacket.Delay                     = datap.Delay;
                                    forwardPacket.SourceNode                = datap.SourceNode;
                                    forwardPacket.IsRandomControls          = true;
                                    forwardPacket.RoutingZoneWidthCnt       = datap.RoutingZoneWidthCnt;
                                    forwardPacket.EnergyDistCnt             = Controls[0];
                                    forwardPacket.TransDistanceDistCnt      = Controls[1];
                                    forwardPacket.DirectionDistCnt          = Controls[2];
                                    forwardPacket.PrepDistanceDistCnt       = Controls[3];
                                    forwardPacket.RoutingProbabilityForPath = datap.RoutingProbabilityForPath * nextHop.RoutingVariableProb;
                                    forwardPacket.PacektSequentID           = datap.PacektSequentID;
                                    RelayNode.SendData(RelayNode, NextHopNode, forwardPacket);
                                }
                            }
                            else // this sink:
                            {
                                if (RelayNode.ID == PublicParamerters.SinkNode.ID)
                                {
                                    RelayNode.PacketsList.Add(datap);
                                }
                            }
                        }
                        else
                        {
                            // forward: without random controls:
                            // calculate adil relatives:
                            Sensor RelayNode = ToSensor;
                            DistributionsComputations    relatives      = new DistributionsComputations();
                            List <RoutingRandomVariable> RelativityRows = relatives.ComputeDistributions(datap.SourceNode, PublicParamerters.SinkNode, RelayNode, Settings.Default.EnergyDistCnt, Settings.Default.TransDistanceDistCnt, Settings.Default.DirectionDistCnt, Settings.Default.PrepDistanceDistCnt);
                            SeletNextHopRandomlly        randomGenrator = new SeletNextHopRandomlly();
                            RoutingRandomVariable        nextHop        = randomGenrator.SelectNextHop(RelativityRows);
                            if (nextHop != null) // not the sink
                            {
                                //: historial record:
                                if (Settings.Default.KeepLogs)
                                {
                                    // log.ForwardingRandomNumber = datap.ForwardingRandomNumber;
                                    ToSensor.Logs.Add(log);                            // add the log
                                    HistoricalRelativityRows.AddRange(RelativityRows); // add the log
                                }
                                // forward:
                                Datapacket forwardPacket;
                                if (RelativityRows.Count > 0)
                                {
                                    Sensor NextHopNode = nextHop.NextHopNode;
                                    forwardPacket = new Datapacket(RelayNode, NextHopNode);
                                    forwardPacket.ForwardingRandomNumber = randomGenrator.RandomeNumber;
                                    forwardPacket.SourceNodeID           = datap.SourceNodeID;
                                    forwardPacket.Distance                  = datap.Distance;
                                    forwardPacket.RoutingDistance           = datap.RoutingDistance;
                                    forwardPacket.Path                      = datap.Path;
                                    forwardPacket.Hops                      = datap.Hops;
                                    forwardPacket.UsedEnergy_Joule          = datap.UsedEnergy_Joule;
                                    forwardPacket.Delay                     = datap.Delay;
                                    forwardPacket.SourceNode                = datap.SourceNode;
                                    forwardPacket.RoutingZoneWidthCnt       = datap.RoutingZoneWidthCnt;
                                    forwardPacket.IsRandomControls          = false;
                                    forwardPacket.PrepDistanceDistCnt       = datap.PrepDistanceDistCnt;
                                    forwardPacket.TransDistanceDistCnt      = datap.TransDistanceDistCnt;
                                    forwardPacket.EnergyDistCnt             = datap.EnergyDistCnt;
                                    forwardPacket.DirectionDistCnt          = datap.DirectionDistCnt;
                                    forwardPacket.RoutingProbabilityForPath = datap.RoutingProbabilityForPath * nextHop.RoutingVariableProb;
                                    forwardPacket.PacektSequentID           = datap.PacektSequentID;
                                    RelayNode.SendData(RelayNode, NextHopNode, forwardPacket);
                                }
                            }
                            else // this sink:
                            {
                                if (RelayNode.ID == PublicParamerters.SinkNode.ID)
                                {
                                    RelayNode.PacketsList.Add(datap);
                                }
                            }
                        }
                    }
                    else
                    {
                        this.Ellipse_Communication_range.Fill = Brushes.Brown;// die out node
                        // MessageBox.Show("DeadNODE!");
                    }
                }
            }
        }
예제 #2
0
        /// <summary>
        /// change the Hij
        /// </summary>
        public List <Experment> DoExperment()
        {
            List <Experment> re     = new List <ui.Experment>();
            Sensor           source = _mianWinsow.myNetWork[Convert.ToInt16(comb_source_node.Text)];
            Sensor           sink   = _mianWinsow.myNetWork[Convert.ToInt16(comb_sink_node.Text)];

            int expermentsNumber = Convert.ToInt16(com_numberof_exp.Text);

            for (int i = 0; i < expermentsNumber; i++)
            {
                // random:
                if (check_random.IsChecked == true)
                {
                    double PowerHijSteps     = Convert.ToDouble(com_prependicular.Text) + (i * Convert.ToDouble(com_prependicular_steps.Text));
                    double PowerNijSteps     = Convert.ToDouble(com_transmision_distance.Text) + (i * Convert.ToDouble(com_transmision_distance_steps.Text));
                    double PowerRjSteps      = Convert.ToDouble(com_energy.Text) + (i * Convert.ToDouble(com_energy_steps.Text));
                    double PowerThetaijSteps = Convert.ToDouble(com_direction.Text) + (i * Convert.ToDouble(com_direction_steps.Text));

                    Settings.Default.KeepLogs             = false;// don't keep logs for nodes, to save momery.
                    Settings.Default.PrepDistanceDistCnt  = PowerHijSteps;
                    Settings.Default.TransDistanceDistCnt = PowerNijSteps;
                    Settings.Default.EnergyDistCnt        = PowerRjSteps;
                    Settings.Default.DirectionDistCnt     = PowerThetaijSteps;


                    // start: send data:
                    Sensor        sourceNode = _mianWinsow.myNetWork[Convert.ToInt16(comb_source_node.Text)];
                    List <double> Controls   = RandomControls.Generate4Controls();
                    sourceNode.GeneratePacketAndSent(Convert.ToInt16(comb_number_of_packets.Text));
                }
                else
                {
                    double PowerHijSteps     = Convert.ToDouble(com_prependicular.Text) + (i * Convert.ToDouble(com_prependicular_steps.Text));
                    double PowerNijSteps     = Convert.ToDouble(com_transmision_distance.Text) + (i * Convert.ToDouble(com_transmision_distance_steps.Text));
                    double PowerRjSteps      = Convert.ToDouble(com_energy.Text) + (i * Convert.ToDouble(com_energy_steps.Text));
                    double PowerThetaijSteps = Convert.ToDouble(com_direction.Text) + (i * Convert.ToDouble(com_direction_steps.Text));

                    Settings.Default.KeepLogs             = false;// don't keep logs for nodes, to save momery.
                    Settings.Default.PrepDistanceDistCnt  = PowerHijSteps;
                    Settings.Default.TransDistanceDistCnt = PowerNijSteps;
                    Settings.Default.EnergyDistCnt        = PowerRjSteps;
                    Settings.Default.DirectionDistCnt     = PowerThetaijSteps;


                    // start: send data:
                    Sensor sourceNode = _mianWinsow.myNetWork[Convert.ToInt16(comb_source_node.Text)];
                    sourceNode.GeneratePacketAndSent(Convert.ToInt16(comb_number_of_packets.Text));
                }


                // get the distrubtions:
                List <KeyValuePair <int, double> > dis = Distrubtions.FindDistrubtionsForHops();
                ExpermentResults result = Distrubtions.GetEnergyDelayForAnExperment();

                Experment xp = new Experment();
                xp.IsRandomControl      = (bool)check_random.IsChecked;
                xp.NumberofExperments   = Convert.ToDouble(com_numberof_exp.Text);
                xp.NumberofPackets      = Convert.ToDouble(comb_number_of_packets.Text);
                xp.PrepDistanceDistCnt  = Settings.Default.PrepDistanceDistCnt;
                xp.TransDistanceDistCnt = Settings.Default.TransDistanceDistCnt;
                xp.EnergyDistCnt        = Settings.Default.EnergyDistCnt;
                xp.DirectionDistCnt     = Settings.Default.DirectionDistCnt;
                xp.SinkID   = Convert.ToInt16(comb_sink_node.Text);
                xp.SourceID = Convert.ToInt16(comb_source_node.Text);
                xp.HopsDistributions.AddRange(dis);
                xp.ExpId = i + 1;

                // delay and hops
                xp.EnergyConsumed  = new KeyValuePair <int, double>(xp.ExpId, (result.EnergyConsumtion / xp.NumberofPackets));
                xp.Delay           = new KeyValuePair <int, double>(xp.ExpId, (result.Delay / xp.NumberofPackets));
                xp.Hops            = new KeyValuePair <int, double>(xp.ExpId, result.Hops / xp.NumberofPackets);
                xp.RoutingDistance = new KeyValuePair <int, double>(xp.ExpId, result.RoutingDistance / xp.NumberofPackets);

                //: energy effecien
                xp.AverageTransDistrancePerHop = new KeyValuePair <int, double>(xp.ExpId, result.AverageTransDistrancePerHop / xp.NumberofPackets);
                xp.TransDistanceEfficiency     = new KeyValuePair <int, double>(xp.ExpId, result.TransDistanceEfficiency / xp.NumberofPackets);
                xp.RoutingEfficiency           = new KeyValuePair <int, double>(xp.ExpId, result.RoutingEfficiency / xp.NumberofPackets);
                xp.RoutingDistanceEffiecncy    = new KeyValuePair <int, double>(xp.ExpId, result.RoutingDistanceEfficiency / xp.NumberofPackets);

                // blancing: averags. don't divide by pkg number.
                xp.PathsSpread  = new KeyValuePair <int, double>(xp.ExpId, result.PathsSpread);
                xp.HopsPerRelay = new KeyValuePair <int, double>(xp.ExpId, result.HopsPerRelay);
                xp.RelaysCount  = new KeyValuePair <int, double>(xp.ExpId, result.RelaysCount);

                re.Add(xp);

                // clear.
                sink.PacketsList.Clear();
                source.NumberofPacketsGeneratedByMe = 0;

                // rechange sensors: reintialized the batteries of the nodes.
                ReChargeTheNodes();
            }

            return(re);
        }
예제 #3
0
        /// <summary>
        ///  select this node as a source and let it
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        public void btn_send_packet_MouseDown(object sender, MouseButtonEventArgs e)
        {
            Label lbl_title = sender as Label;

            switch (lbl_title.Name)
            {
            case "btn_send_1_packet":
            {
                GeneratePacketAndSent(false, Settings.Default.EnergyDistCnt, Settings.Default.TransDistanceDistCnt, Settings.Default.DirectionDistCnt, Settings.Default.PrepDistanceDistCnt);
                break;
            }

            case "btn_send_10_packet":
            {
                for (int j = 1; j <= 10; j++)
                {
                    GeneratePacketAndSent(false, Settings.Default.EnergyDistCnt, Settings.Default.TransDistanceDistCnt, Settings.Default.DirectionDistCnt, Settings.Default.PrepDistanceDistCnt);
                }
                break;
            }

            case "btn_send_100_packet":
            {
                for (int j = 1; j <= 100; j++)
                {
                    GeneratePacketAndSent(false, Settings.Default.EnergyDistCnt, Settings.Default.TransDistanceDistCnt, Settings.Default.DirectionDistCnt, Settings.Default.PrepDistanceDistCnt);
                }
                break;
            }

            case "btn_send_300_packet":
            {
                for (int j = 1; j <= 300; j++)
                {
                    GeneratePacketAndSent(false, Settings.Default.EnergyDistCnt, Settings.Default.TransDistanceDistCnt, Settings.Default.DirectionDistCnt, Settings.Default.PrepDistanceDistCnt);
                }
                break;
            }

            case "btn_send_1000_packet":
            {
                for (int j = 1; j <= 1000; j++)
                {
                    GeneratePacketAndSent(false, Settings.Default.EnergyDistCnt, Settings.Default.TransDistanceDistCnt, Settings.Default.DirectionDistCnt, Settings.Default.PrepDistanceDistCnt);
                }
                break;
            }

            case "btn_send_5000_packet":
            {
                for (int j = 1; j <= 5000; j++)
                {
                    GeneratePacketAndSent(false, Settings.Default.EnergyDistCnt, Settings.Default.TransDistanceDistCnt, Settings.Default.DirectionDistCnt, Settings.Default.PrepDistanceDistCnt);
                }
                break;
            }

            case "_rbtn_send_1_packet":
            {
                List <double> Controls = RandomControls.Generate4Controls();
                GeneratePacketAndSent(true, Controls[0], Controls[1], Controls[2], Controls[3]);

                break;
            }

            case "_rbtn_send_10_packet":
            {
                for (int j = 1; j <= 10; j++)
                {
                    List <double> Controls = RandomControls.Generate4Controls();
                    GeneratePacketAndSent(true, Controls[0], Controls[1], Controls[2], Controls[3]);
                }
                break;
            }

            case "_rbtn_send_100_packet":
            {
                for (int j = 1; j <= 100; j++)
                {
                    List <double> Controls = RandomControls.Generate4Controls();
                    GeneratePacketAndSent(true, Controls[0], Controls[1], Controls[2], Controls[3]);
                }
                break;
            }

            case "_rbtn_send_300_packet":
            {
                for (int j = 1; j <= 300; j++)
                {
                    List <double> Controls = RandomControls.Generate4Controls();
                    GeneratePacketAndSent(true, Controls[0], Controls[1], Controls[2], Controls[3]);
                }
                break;
            }

            case "_rbtn_send_1000_packet":
            {
                for (int j = 1; j <= 1000; j++)
                {
                    List <double> Controls = RandomControls.Generate4Controls();
                    GeneratePacketAndSent(true, Controls[0], Controls[1], Controls[2], Controls[3]);
                }
                break;
            }
            }
        }