Beispiel #1
0
        /// <summary>
        /// Refreshes the searching scout's positions
        /// </summary>
        private void RefreshSearch()
        {
            activityGraphics.Clear(Color.Transparent);
            activityGraphics.Flush();

            updateEquilibriumEquations();

            /* if (humanIntervention is TaskDistribution)
             * { */
            ReadOnlyDictionary <Bee.State, int> distribution = Swarm.GetTaskDistribution();
            List <string> stateNames = new List <string>();

            foreach (Bee.State s in distribution.Keys)
            {
                stateNames.Add(s.ToString());
            }
            this.taskDistribution.Series[0].Points.DataBindXY(stateNames, distribution.Values);

            /*}
             * else*/
            if (humanIntervention != null)
            {
                List <Shape> shapes = humanIntervention.GetShapes();
                foreach (Shape shape in shapes)
                {
                    shape.Draw(activityGraphics);
                }
            }

            PaintSites();
            PaintBees();

            activityPicture.Refresh(); // show our results
        }
Beispiel #2
0
        /// <summary>
        /// Updates the variables that determine the equillibria
        /// </summary>
        private void updateEquilibriumEquations()
        {
            int    R, O, E, A, D;
            double rDot, oDot, eDot, aDot, dDot;

            R = O = E = A = D = 0;
            ReadOnlyDictionary <Bee.State, int> taskDistribution = Swarm.GetTaskDistribution();

            if (taskDistribution.ContainsKey(Bee.State.RESTING))
            {
                R = taskDistribution[Bee.State.RESTING];
            }
            if (taskDistribution.ContainsKey(Bee.State.OBSERVING))
            {
                O = taskDistribution[Bee.State.OBSERVING];
            }
            if (taskDistribution.ContainsKey(Bee.State.EXPLORING))
            {
                E = taskDistribution[Bee.State.EXPLORING];
            }
            if (taskDistribution.ContainsKey(Bee.State.ASSESSING))
            {
                A = taskDistribution[Bee.State.ASSESSING];
            }
            if (taskDistribution.ContainsKey(Bee.State.DANCING))
            {
                D = taskDistribution[Bee.State.DANCING];
            }

            ReadOnlyDictionary <double, int> danceDistrbution = DanceFloor.GetDanceDistribution();

            double vnD         = 0;
            double siteQuality = 0;

            if (danceDistrbution.Keys.Count != 0)
            {
                siteQuality = danceDistrbution.Keys.ToArray()[0];
            }

            foreach (double quality in danceDistrbution.Keys)
            {
                vnD += ((1 - quality) * (0.666 / siteQuality) * (D));
            }

            double pD = (D / (D + 0.323));
            double qD = 1 - pD;

            // (2.1) Governing system of equations
            rDot = -(0.1 * R) + vnD;

            oDot = (0.1 * R) - (0.125 * O) + (0.033 * E);

            eDot = ((qD * 0.125 * O) - (0.033 * E));

            if (siteQuality != 0)
            {
                aDot = ((pD * 0.125 * O) - (0.05 * A) + (0.005 * (0.066 / siteQuality) * D));

                dDot = ((0.05 * A) - ((0.066 / siteQuality) * D));
            }
            else
            {
                aDot = dDot = 0;
            }

            Rdot.Text = rDot.ToString();
            Odot.Text = oDot.ToString();
            Edot.Text = eDot.ToString();
            Adot.Text = aDot.ToString();
            Ddot.Text = dDot.ToString();
        }