//---------------------------------------------------------------------

        public static bool Algorithm(ISpecies species,
                                     ActiveSite site)
        {
            if (species.EffectiveSeedDist == EffectiveSeedDist.Universal)
            {
                return(UniversalDispersal.Algorithm(species, site));
            }

            if (!Reproduction.SufficientLight(species, site))
            {
                if (isDebugEnabled)
                {
                    log.DebugFormat("site {0}: {1} not seeded: insufficient light",
                                    site.Location, species.Name);
                }
                return(false);
            }

            if (!Reproduction.Establish(species, site))
            {
                if (isDebugEnabled)
                {
                    log.DebugFormat("site {0}: {1} not seeded: cannot establish",
                                    site.Location, species.Name);
                }
                return(false);
            }

            if (Reproduction.MaturePresent(species, site))
            {
                if (isDebugEnabled)
                {
                    log.DebugFormat("site {0}: {1} seeded on site",
                                    site.Location, species.Name);
                }
                return(true);
            }

            if (isDebugEnabled)
            {
                log.DebugFormat("site {0}: search neighbors for {1}",
                                site.Location, species.Name);
            }

            int row = (int)site.Location.Row;
            int col = (int)site.Location.Column;

            int cellDiam = (int)Model.Core.CellLength;
            int EffD     = species.EffectiveSeedDist;
            int MaxD     = species.MaxSeedDist;

            double ratio = 0.95;//the portion of the probability in the effective distance
            //lambda1 parameterized for effective distance
            double lambda1 = Math.Log(1 - ratio) / EffD;
            //lambda2 parameterized for maximum distance
            double lambda2 = Math.Log(0.01) / MaxD;

            double lowBound = 0, upBound = 0;
            //bool suitableDist=false;//flag to trigger if seed (plural) can get to a site based on distance probability
            double distanceProb = 0.0;
            int    pixRange     = Math.Max((int)((float)MaxD / (float)cellDiam), 1);
            int    maxrow       = (int)Math.Min(row + pixRange, Model.Core.Landscape.Rows);
            int    minrow       = Math.Max(row - pixRange, 1);

            for (int i = minrow; i <= maxrow; i++)
            {
                int x1, x2;
                //float b = 5.0;
                findX1X2(out x1, out x2, col, row, i, pixRange);
                for (int j = x1; j <= x2; j++)
                {
                    Location loc = new Location((uint)i, (uint)j);
                    if (Model.Core.Landscape.GetSite(loc, ref neighbor) && neighbor.IsActive)
                    {
                        if (Reproduction.MaturePresent(species, neighbor))
                        {
                            float distance = (float)Math.Sqrt((float)((row - i) * (row - i) + (col - j) * (col - j))) * cellDiam;  //Pythag

                            //set lower boundary to the theoretical (straight-line) edge of parent cell
                            lowBound = distance - cellDiam;
                            if (lowBound < 0)
                            {
                                lowBound = 0;
                            }

                            //set upper boundary to the outer theoretical boundary of the cell
                            upBound = distance;

                            if (cellDiam <= EffD)
                            {     //Draw probabilities from either EffD or MaxD curves
                                if (distance <= (float)EffD)
                                { //BCW May 04
                                    distanceProb = Math.Exp(lambda1 * lowBound) - Math.Exp(lambda1 * upBound);
                                }
                                else
                                {//BCW May 04
                                    distanceProb = (1 - ratio) * Math.Exp(lambda2 * (lowBound - EffD)) - (1 - ratio) * Math.Exp(lambda2 * (upBound - EffD));
                                }
                            }
                            else
                            {
                                if (distance <= cellDiam)
                                {//Draw probabilities from both EffD and MaxD curves
                                    distanceProb = Math.Exp(lambda1 * lowBound) - (1 - ratio) * Math.Exp(lambda2 * (upBound - EffD));
                                }
                                else
                                {
                                    distanceProb = (1 - ratio) * Math.Exp(lambda2 * (lowBound - EffD)) - (1 - ratio) * Math.Exp(lambda2 * (upBound - EffD));
                                }
                            }
                            if (distanceProb > Landis.Util.Random.GenerateUniform())// && frand() < l->probRepro(speciesNum))  Modified BCW May '04
                            {
                                if (isDebugEnabled)
                                {
                                    log.DebugFormat("\t{0} yes", loc);
                                }
                                //  success = sites(row,col)->addNewCohort(s, sa, 10);
                                return(true);
                            }
                            if (isDebugEnabled)
                            {
                                log.DebugFormat("\t{0} -", loc);
                            }
                        }
                        else
                        {
                            if (isDebugEnabled)
                            {
                                log.DebugFormat("\t{0} not mature", loc);
                            }
                        }
                    } // if neighor is active
                }     // for each column, j, of current row in neighborhood
            }         // for each row, i, in the neighborhood

            //  Search failed.
            if (isDebugEnabled)
            {
                log.Debug("\tsearch failed");
            }
            return(false);
        }
Esempio n. 2
0
        //---------------------------------------------------------------------

        public static bool Algorithm(ISpecies species,
                                     ActiveSite site)
        {
            if (species.EffectiveSeedDist == EffectiveSeedDist.Universal)
            {
                return(UniversalDispersal.Algorithm(species, site));
            }

            if (!Reproduction.SufficientLight(species, site))
            {
                if (isDebugEnabled)
                {
                    log.DebugFormat("site {0}: {1} not seeded: insufficient light",
                                    site.Location, species.Name);
                }
                return(false);
            }

            if (!Reproduction.Establish(species, site))
            {
                if (isDebugEnabled)
                {
                    log.DebugFormat("site {0}: {1} not seeded: cannot establish",
                                    site.Location, species.Name);
                }
                return(false);
            }

            if (Reproduction.MaturePresent(species, site))
            {
                if (isDebugEnabled)
                {
                    log.DebugFormat("site {0}: {1} seeded on site",
                                    site.Location, species.Name);
                }
                return(true);
            }

            if (isDebugEnabled)
            {
                log.DebugFormat("site {0}: search neighbors for {1}",
                                site.Location, species.Name);
            }

            //UI.WriteLine("   Ward seed disersal.  Spp={0}, site={1},{2}.", species.Name, site.Location.Row, site.Location.Column);
            foreach (RelativeLocationWeighted reloc in Seeding.MaxSeedQuarterNeighborhood)
            {
                double distance = reloc.Weight;
                int    rRow     = (int)reloc.Location.Row;
                int    rCol     = (int)reloc.Location.Column;

                double EffD = (double)species.EffectiveSeedDist;
                double MaxD = (double)species.MaxSeedDist;

                if (distance > MaxD + ((double)Model.Core.CellLength / 2.0 * 1.414))
                {
                    return(false);  //Check no further
                }
                double dispersalProb = GetDispersalProbability(EffD, MaxD, distance);
                //UI.WriteLine("      DispersalProb={0}, EffD={1}, MaxD={2}, distance={3}.", dispersalProb, EffD, MaxD, distance);

                //First check the Southeast quadrant:
                if (dispersalProb > Landis.Util.Random.GenerateUniform())
                {
                    Site neighbor = site.GetNeighbor(reloc.Location);
                    if (neighbor != null && neighbor.IsActive)
                    {
                        if (Reproduction.MaturePresent(species, neighbor))
                        {
                            return(true);
                        }
                    }
                }

                //Next, check all other quadrants:
                if (dispersalProb > Landis.Util.Random.GenerateUniform())
                {
                    Site neighbor = site.GetNeighbor(new RelativeLocation(rRow * -1, rCol));
                    if (rCol == 0)
                    {
                        neighbor = site.GetNeighbor(new RelativeLocation(0, rRow));
                    }
                    if (neighbor != null && neighbor.IsActive)
                    {
                        if (Reproduction.MaturePresent(species, neighbor))
                        {
                            return(true);
                        }
                    }
                }

                if (dispersalProb > Landis.Util.Random.GenerateUniform())
                {
                    Site neighbor = site.GetNeighbor(new RelativeLocation(rRow * -1, rCol * -1));
                    if (neighbor != null && neighbor.IsActive)
                    {
                        if (Reproduction.MaturePresent(species, neighbor))
                        {
                            return(true);
                        }
                    }
                }

                if (dispersalProb > Landis.Util.Random.GenerateUniform())
                {
                    Site neighbor = site.GetNeighbor(new RelativeLocation(rRow, rCol * -1));
                    if (rCol == 0)
                    {
                        neighbor = site.GetNeighbor(new RelativeLocation(0, rRow * -1));
                    }
                    if (neighbor != null && neighbor.IsActive)
                    {
                        if (Reproduction.MaturePresent(species, neighbor))
                        {
                            return(true);
                        }
                    }
                }
            }  // end foreach relativelocation

            return(false);
        }