Пример #1
0
        public void Monte_start(ref Graphics R_g, double kT, int warBrz, int sasiedztwo, int promien, int iter, int wyswietlanie)
        {
            int M_size   = x * y;
            int M_x      = 0;
            int M_y      = 0;
            int kolor_id = 0;

            double randomNumber;
            double delta_energy;
            double Prawd;
            int    random_color;

            MapaSasiadow        mapa_oryg    = new MapaSasiadow();
            MapaSasiadow        mapa_temp    = new MapaSasiadow();
            RandomGenerator     randomCords  = new RandomGenerator();
            List <List <Cell> > R_grid_kopia = new List <List <Cell> >();

            for (int k = 0; k < x; k++)
            {
                R_grid_kopia.Add(new List <Cell>());
                for (int j = 0; j < y; j++)
                {
                    R_grid_kopia[k].Add(new Cell());
                }
            }


            for (int iter_start = 0; iter_start < iter; iter_start++)
            {
                randomCords.Create(x, y);
                for (int k = 0; k < x; k++)
                {
                    for (int j = 0; j < y; j++)
                    {
                        R_grid_kopia[k][j].Copy(grid[k][j]);
                    }
                }
                for (int i = 0; i < M_size; i++)
                {
                    randomCords.Get_random(ref M_x, ref M_y);
                    kolor_id = grid[M_x][M_y].Get_kolor_id();

                    // z promieniem
                    Monte_cacl(ref R_grid_kopia, ref M_x, ref M_y, ref sasiedztwo, ref promien, ref warBrz, ref kolor_id, ref mapa_oryg);

                    random_color = mapa_oryg.GetRandomColor();
                    Monte_cacl(ref R_grid_kopia, ref M_x, ref M_y, ref sasiedztwo, ref promien, ref warBrz, ref random_color, ref mapa_temp);

                    randomNumber = random.NextDouble();
                    delta_energy = mapa_temp.GetEnergy() - mapa_oryg.GetEnergy();
                    Prawd        = Math.Exp(-delta_energy / kT);

                    if (delta_energy <= 0 || (delta_energy > 0 && Prawd <= randomNumber))
                    {
                        grid[M_x][M_y].Set_state(true);
                        grid[M_x][M_y].Set_color(random_color);
                        if (wyswietlanie == 0)
                        {
                            grid[M_x][M_y].Draw(R_g, M_x * size + 1, M_y * size + 1, size - 1, border);
                        }

                        energyGrid[M_x][M_y] = mapa_temp.GetEnergy();
                    }
                    else
                    {
                        energyGrid[M_x][M_y] = mapa_oryg.GetEnergy();
                    }


                    mapa_oryg.Clear();
                    mapa_temp.Clear();
                }
                randomCords.Clear();
                if (wyswietlanie == 1)
                {
                    Draw_energy(ref R_g);
                }
            }
        }
Пример #2
0
        void NowaEnergia(int sasiedztwo, int promien, int warBrz)
        {
            MapaSasiadow mapa = new MapaSasiadow();

            int    pentagonalne_losowe;
            int    heksagonalne_losowe;
            int    X_od = -1, Y_od = -1, X_do = 1, Y_do = 1, srodekX = 0, srodekY = 0;
            double dyslok_komorki = 0;

            for (int i = 0; i < x; i++)
            {
                for (int j = 0; j < y; j++)
                {
                    dyslok_komorki      = grid[i][j].Get_dyslokacje();
                    pentagonalne_losowe = random.Next(0, 4);
                    heksagonalne_losowe = 0;
                    if (sasiedztwo == 5)
                    {
                        heksagonalne_losowe = random.Next(1, 3);
                    }

                    // z promieniem
                    X_od = -1; Y_od = -1; X_do = 1; Y_do = 1; srodekX = 0; srodekY = 0;
                    if (sasiedztwo == 6)
                    {
                        srodekX = i * size + 1 + size / 2 + grid[i][j].Get_przesuniecie_x() * size / 4;
                        srodekY = i * size + 1 + size / 2 + grid[i][j].Get_przesuniecie_y() * size / 4;
                        X_od    = -x;
                        X_do    = x;
                        Y_od    = -y;
                        Y_do    = y;
                    }


                    for (int ci = X_od; ci <= X_do; ci++)
                    {
                        for (int cj = Y_od; cj <= Y_do; cj++)
                        {
                            if (cj == 0 && ci == 0)
                            {
                                continue;
                            }
                            //Von neuman
                            else if (sasiedztwo == 0 && (ci == -1 && cj == -1 || ci == 1 && cj == -1 || ci == -1 && cj == 1 || ci == 1 && cj == 1))
                            {
                                continue;
                            }
                            //Pentagonalne ignorujemy prawe
                            else if (sasiedztwo == 2 && pentagonalne_losowe == 0 && (ci == 1 && cj == -1 || ci == 1 && cj == 0 || ci == 1 && cj == 1))
                            {
                                continue;
                            }
                            //Pentagonalne ignorujemy lewe
                            else if (sasiedztwo == 2 && pentagonalne_losowe == 1 && (ci == -1 && cj == -1 || ci == -1 && cj == 0 || ci == -1 && cj == 1))
                            {
                                continue;
                            }
                            //Pentagonalne ignorujemy gora
                            else if (sasiedztwo == 2 && pentagonalne_losowe == 2 && (ci == -1 && cj == -1 || ci == 0 && cj == -1 || ci == 1 && cj == -1))
                            {
                                continue;
                            }
                            //Pentagonalne ignorujemy dol
                            else if (sasiedztwo == 2 && pentagonalne_losowe == 3 && (ci == -1 && cj == 1 || ci == 0 && cj == 1 || ci == 1 && cj == 1))
                            {
                                continue;
                            }
                            //Heksagonalne lewe
                            else if ((heksagonalne_losowe == 1 || sasiedztwo == 3) && (ci == -1 && cj == -1 || ci == 1 && cj == 1))
                            {
                                continue;
                            }
                            //Heksagonalne prawe
                            else if ((heksagonalne_losowe == 2 || sasiedztwo == 4) && (ci == 1 && cj == -1 || ci == -1 && cj == 1))
                            {
                                continue;
                            }
                            else
                            {
                                double pkt_promien     = 0;
                                double promien_kwadrat = 0;
                                if (sasiedztwo == 6)
                                {
                                    pkt_promien     = Math.Pow((srodekX - ((i + ci) * size + 1 + size / 2 + grid[Modulo(i + ci, x)][Modulo(j + cj, y)].Get_przesuniecie_x() * size / 4)), 2.0) + Math.Pow((srodekY - ((j + cj) * size + 1 + size / 2 + grid[Modulo(i + ci, x)][Modulo(j + cj, y)].Get_przesuniecie_y() * size / 4)), 2.0);
                                    promien_kwadrat = Math.Pow(promien, 2.0);
                                }
                                switch (warBrz)
                                {
                                case 0:     //periodyczne
                                    if (sasiedztwo != 6 && grid[Modulo(i + ci, x)][Modulo(j + cj, y)].Get_state_b())
                                    {
                                        mapa.Add(grid[Modulo(i + ci, x)][Modulo(j + cj, y)].Get_kolor_id(), grid[i][j].Get_kolor_id());
                                    }
                                    else if (pkt_promien <= promien_kwadrat && grid[Modulo(i + ci, x)][Modulo(j + cj, y)].Get_state_b())
                                    {
                                        mapa.Add(grid[Modulo(i + ci, x)][Modulo(j + cj, y)].Get_kolor_id(), grid[i][j].Get_kolor_id());
                                    }
                                    break;

                                case 1:     // pochlaniajace
                                    if (sasiedztwo != 6 && (i + ci < x && i + ci >= 0 && j + cj < y && j + cj >= 0 && grid[i + ci][j + cj].Get_state_b()))
                                    {
                                        mapa.Add(grid[i + ci][j + cj].Get_kolor_id(), grid[i][j].Get_kolor_id());
                                    }
                                    else if ((i + ci < x && i + ci >= 0 && j + cj < y && j + cj >= 0) && pkt_promien <= promien_kwadrat && grid[i + ci][j + cj].Get_state_b())
                                    {
                                        mapa.Add(grid[i + ci][j + cj].Get_kolor_id(), grid[i][j].Get_kolor_id());
                                    }
                                    break;
                                }
                            }
                        }
                    }
                    energyGrid[i][j] = mapa.GetEnergy();

                    mapa.Clear();
                }
            }
        }