public Dictionary <int, int> getColorsDictionary(Grain[,] grains, int x, int y, int left, int top, int botom, int right) { Grain[] neighborhood = new Grain[8]; neighborhood[0] = grains[left, top]; neighborhood[1] = grains[x, top]; neighborhood[2] = grains[right, top]; neighborhood[3] = grains[left, y]; neighborhood[4] = grains[right, y]; neighborhood[5] = grains[left, botom]; neighborhood[6] = grains[x, botom]; neighborhood[7] = grains[right, botom]; //wylicza sasiedztwo moora i zwraca slownik kolorow Dictionary <int, int> colors = new Dictionary <int, int>(); for (int i = 0; i < neighborhood.Length; i++) { if (neighborhood[i] != null && (neighborhood[i].stan == Grain.TYPE_GRAIN || neighborhood[i].stan == Grain.TYPE_OLD_GRAIN)) { int color = neighborhood[i].index; if (colors.ContainsKey(color)) { colors[color]++; } else { colors[color] = 1; } } } return(colors); }
public bool isBoundary(Grain[,] grains, int width, int height, int xpom, int ypom) { int gora = ypom - 1; int dol = ypom + 1; int prawy = xpom + 1; int lewy = xpom - 1; //perdiodyczny warunek brzegowy if (xpom == 0) { lewy = width - 1; } if (xpom == width - 1) { prawy = 0; } if (ypom == 0) { gora = height - 1; } if (ypom == height - 1) { dol = 0; } //liczy sasiedztwo po to zeby policzyc tablice kolorow //jesli sa w sasiedztwie dwa rozne kolory to jest granica return(this.getColorsDictionary(grains, xpom, ypom, lewy, gora, dol, prawy).Count >= 2); }
private void mc_proceedSingleCellMonteCarlo(Tuple <int, int> cell, Grain[,] space, bool recrystalization = false) { int x = cell.Item1; int y = cell.Item2; int dim = space.GetLength(0); double initial_energy = mc_getCellEnergy(x, y, space); var previous_ID = space[x, y].ID; mc_changeID(x, y, dim, space, recrystalization); double post_change_energy = mc_getCellEnergy(x, y, space); double energy_difference = post_change_energy - initial_energy; //Console.WriteLine("Energy difference = {0}", energy_difference); if (energy_difference < 0) { // Keep new state, update color space[x, y].color = grain_ID_Color_dict[space[x, y].ID]; var t = true; } else { // Revert change space[x, y].ID = previous_ID; } }
public static List <Grain> vonNeumannGrains(Grain[,] grains, int x, int y) { List <Grain> _Neighbours = new List <Grain>(); int x_l = -200; int x_p = -200; int y_d = -200; int y_g = -200; if (BOUNDARY_CONDITION == BoundaryCondition.Periodic) { x_l = x - 1 < 0 ? SIZE_X - 1 : x - 1; x_p = x + 1 >= SIZE_X ? 0 : x + 1; y_d = y + 1 >= SIZE_Y ? 0 : y + 1; y_g = y - 1 < 0 ? SIZE_Y - 1 : y - 1; } else { x_l = x - 1 < 0 ? x : x - 1; x_p = x + 1 >= SIZE_X ? x : x + 1; y_d = y + 1 >= SIZE_Y ? y : y + 1; y_g = y - 1 < 0 ? y : y - 1; } _Neighbours.Add(grains[y, x_l]); // s_l _Neighbours.Add(grains[y, x_p]); // s_p _Neighbours.Add(grains[y_d, x]); // s_d _Neighbours.Add(grains[y_g, x]); // s_g return(_Neighbours); }
public static bool isPointOnGrainBorder(Tuple <int, int> point, Grain[,] grain_structure) { HashSet <int> neighbors_IDs = new HashSet <int>(); for (int i = point.Item1 - 1; i <= point.Item1 + 1; ++i) { if (i < 0 || i > grain_structure.GetLength(0) - 1) { continue; } for (int j = point.Item2 - 1; j <= point.Item2 + 1; ++j) { if (j < 0 || j > grain_structure.GetLength(0) - 1) { continue; } neighbors_IDs.Add(grain_structure[i, j].ID); } } if (neighbors_IDs.Count > 1) { return(true); } return(false); }
private void Draw(Grain[,] grains, Grain[,] temp, int height) { Parallel.For(0, height, i => { for (int j = 0; j < WidthSize; j++) { if (grains[i, j] != temp[i, j]) { lock (lockBrush) { // using (Graphics graph = Graphics.FromImage(bmp)) { try { SolidBrush brush = brushes[grains[i, j].ID]; bmp.SetPixel(j, i, brush.Color); //graph.FillRectangle(brush, j, i, 1, 1); } catch (Exception error) { // graph.Dispose(); } } } } } }); paintArea.Invalidate(); }
private double mc_getCellEnergy(int x, int y, Grain[,] space, double Jgb = 1.0) { int dim = space.GetLength(0); int number_of_neighbors_with_different_ID = mc_getNumberOfNeighborsWithDifferentID(x, y, dim, space); double energy = Jgb * number_of_neighbors_with_different_ID; return(energy); }
public Grain[,] Simulation(Grain[,] grains, Graphics g) { bool[,] recrystalized = new bool[SIZE_Y, SIZE_X]; for (int y = 0; y < SIZE_Y; y++) { for (int x = 0; x < SIZE_X; x++) { recrystalized[y, x] = false; } } for (int y = 0; y < SIZE_Y; y++) { for (int x = 0; x < SIZE_X; x++) { List <Grain> neighbours = NeighbourhoodFactory.GetNeighboursGrains(grains, x, y); foreach (Grain neighbour in neighbours) { if (lastRecrystalized[neighbour.Y, neighbour.X]) { bool rescrystallize = true; foreach (Grain neighbour1 in neighbours) { if (!neighbour1.Recrystallized && neighbour1.Density >= grains[y, x].Density) { rescrystallize = false; break; } } if (rescrystallize && !grains[y, x].Recrystallized) { recrystalized[y, x] = true; grains[y, x].Density = 0; // grains[y, x].Recrystallized = true; grains[y, x].DisplayRecrystallized(g, Colors.GetRecrystallizationColor()); } break; } } } } for (int y = 0; y < SIZE_Y; y++) { for (int x = 0; x < SIZE_X; x++) { currentlyRecrystalized[y, x] = recrystalized[y, x] ? true: currentlyRecrystalized[y, x]; } } return(grains); }
public Algorithms(Grain[,] grains, Grain[,] temp, int ActualHeightOFLayers, NeighbourType type, BoundaryConditions bc, int LayerNumber) { this.grains = grains; this.temp = temp; this.ActualHeightOfLayers = ActualHeightOFLayers; this.type = type; ActualLayerNumber = LayerNumber; this.bc = bc; }
private List <Grain> TakeNeumannNeighbourhood(int i, int j, Grain[,] GrainsArray) { return(new List <Grain> { GrainsArray[i, j + 1], GrainsArray[i + 1, j], GrainsArray[i - 1, j], GrainsArray[i, j - 1], }); }
private void mc_changeID(int x, int y, int dim, Grain[,] space, bool recrystalization = false) { HashSet <int> possible_IDs = mc_getNeighborsIDs(x, y, dim, space, recrystalization); if (possible_IDs.Count > 0) { int new_ID = possible_IDs.ElementAt(rand.Next(possible_IDs.Count)); space[x, y].ID = new_ID; } }
private List <Grain> TakeFurtherMooreNeighbourhood(int i, int j, Grain[,] GrainsArray) { return(new List <Grain> { GrainsArray[i - 1, j - 1], GrainsArray[i - 1, j + 1], GrainsArray[i + 1, j - 1], GrainsArray[i + 1, j + 1] }); }
private void pictureBox1_Click(object sender, EventArgs e) { MouseEventArgs me = (MouseEventArgs)e; Point coordinates = me.Location; int x = coordinates.X / CELL_SIZE; int y = coordinates.Y / CELL_SIZE; if (x >= SIZE_X || y >= SIZE_Y) { return; } if (!isPlaying) { if (grainGrowth.Tab[y, x].State == 0) { grainGrowth.Tab[y, x].State = Colors.RandomColor(); grainGrowth.Tab[y, x].Display(g); } else { grainGrowth.Tab[y, x].State = 0; grainGrowth.Tab[y, x].Display(g); } } else { this.tab = new Grain[SIZE_Y, SIZE_X]; for (int i = 0; i < SIZE_Y; i++) { for (int j = 0; j < SIZE_X; j++) { this.tab[i, j] = grainGrowth.Tab[i, j].Copy(); } } if (grainGrowth.Tab[y, x].State == 0) { this.tab[y, x].State = Colors.RandomColor(); } else { this.tab[y, x].State = 0; } clickedButton = true; } grainGrowth.Tab[y, x].DisplayEnergy(g); pictureBox1.Image = simulationBitmap; }
private void initGrainStructure(out Grain[,] g_s, int dim) { g_s = new Grain[dim, dim]; for (int x = 0; x < dim; ++x) { for (int y = 0; y < dim; ++y) { g_s[x, y] = new Grain(0, 0, grain_ID_Color_dict[0]); } } }
public Recrystallization(Grain[,] grains) { for (int i = 0; i < SIZE_Y; i++) { for (int j = 0; j < SIZE_X; j++) { grains[i, j].Density = 0; grains[i, j].Recrystallized = false; } } Colors.InitializeRecrystallizationColrs(); ro = new List <double>(); sigma = new List <double>(); checkedRo = new List <double>(); checkedRoFromGrians = new List <double>(); currentlyRecrystalized = new bool[SIZE_Y, SIZE_X]; lastRecrystalized = new bool[SIZE_Y, SIZE_X]; time = 0; double _ro = (A / B) + (1 - (A / B)) * (Math.Exp(-B * time)); double _sigma = sigma0 + value * A0 * B0 * Math.Sqrt(_ro); criticallRo = criticallRo / (SIZE_X * SIZE_Y); Console.WriteLine("Critical " + criticallRo); ro.Add(_ro); sigma.Add(_sigma); checkedRo.Add(0); checkedRoFromGrians.Add(_ro); for (int i = 0; i < SIZE_Y; i++) { for (int j = 0; j < SIZE_X; j++) { currentlyRecrystalized[i, j] = false; lastRecrystalized[i, j] = false; List <int> neighbours = NeighbourhoodFactory.GetNeighboursMonteCarlo(grains, j, i); if (neighbours.Where(s => s != grains[i, j].State).ToList().Count > 0) { grains[i, j].OnBorder = true; } } } }
public void Resize() { this.previousGrains = new Grain[SIZE_Y, SIZE_X]; for (int i = 0; i < SIZE_Y; i++) { for (int j = 0; j < SIZE_X; j++) { this.previousGrains[i, j] = this.tab[i, j].Copy(); } } }
private int mooreMethod(Grain[,] grainCointainer, int i, int j) { int up, down, left, right; up = i - 1; down = i + 1; left = j - 1; right = j + 1; for (int k = 1; k < NucleonAmount + 1; k++) { total[k] = 0; if (grainCointainer[up, left].GrainId == k) { total[k]++; } if (grainCointainer[up, j].GrainId == k) { total[k]++; } if (grainCointainer[up, right].GrainId == k) { total[k]++; } if (grainCointainer[i, left].GrainId == k) { total[k]++; } if (grainCointainer[i, right].GrainId == k) { total[k]++; } if (grainCointainer[down, left].GrainId == k) { total[k]++; } if (grainCointainer[down, j].GrainId == k) { total[k]++; } if (grainCointainer[down, right].GrainId == k) { total[k]++; } if (total[k] > maximum) { maximum = total[k]; id = k; } } return(0); }
private List <Grain> TakeFurtherMooreNeighbourhood(int i, int j, Grain[,] structureArray) { var neighbourhood = new List <Grain> { structureArray[i - 1, j - 1], structureArray[i - 1, j + 1], structureArray[i + 1, j - 1], structureArray[i + 1, j + 1] }; return(neighbourhood); }
private List <Grain> TakeNeumannNeighbourhood(int i, int j, Grain[,] structureArray) { var neighbourhood = new List <Grain> { structureArray[i, j + 1], structureArray[i + 1, j], structureArray[i - 1, j], structureArray[i, j - 1], }; return(neighbourhood); }
private bool IsStateChangeAcceptable(Point point, Grain[,] structureArray, Grain newState) { var neighbourhood = StructureHelpers.TakeMooreNeighbourhood(point.X, point.Y, structureArray); int previousEnergy = neighbourhood.Where(g => (g.Id != 0 && g.Id != structureArray[point.X, point.Y].Id)).Count(); int newEnergy = neighbourhood.Where(g => (g.Id != 0 && g.Id != newState.Id)).Count(); if (newEnergy - previousEnergy <= 0) { return(true); } return(false); }
public void Simulate(Simulation grainGrowth, Graphics gB, Graphics g) { Grain[,] grains = grainGrowth.Tab; List <Grain> all = grains.OfType <Grain>().ToList(); while (all.Count > 0) { if (BREAK_SIMULATION) { BREAK_SIMULATION = false; break; } int index = random.Next(all.Count); Grain grain = all.ElementAt(index); all.RemoveAt(index); int stateBefore = grain.State; List <int> neighbours = NeighbourhoodFactory.GetNeighboursMonteCarlo(grains, grain.X, grain.Y); int energyBefore = CalculateEnergy(neighbours, stateBefore); grains[grain.Y, grain.X].Q = energyBefore; int stateAfter = (neighbours.ElementAt(random.Next(neighbours.Count))); int energyAfter = CalculateEnergy(neighbours, stateAfter); int deltaEnergy = energyAfter - energyBefore; if (deltaEnergy <= 0) { grains[grain.Y, grain.X].State = stateAfter; grain.Display(g, gB); grains[grain.Y, grain.X].Q = energyAfter; } else { float probability = (float)Math.Exp(-(deltaEnergy / this.KT)) * 100; float value = (float)random.NextDouble() * 100; if (value <= probability) { grains[grain.Y, grain.X].State = stateAfter; grain.Display(g, gB); grains[grain.Y, grain.X].Q = energyAfter; } } } }
internal void initialize(Grain[,] grains, int w, int h) { for (int i = 0; i < w; i++) { for (int j = 0; j < h; j++) { if (grains[i, j] != null) { grains[i, j].stan = Grain.TYPE_OLD_GRAIN; } } } }
public static void Import(int boardWidth, int boardHeight, Grain[,] grainsBoard) { using (System.IO.StreamWriter file = new System.IO.StreamWriter(@Path)) { for (int i = 0; i < boardWidth - 1; i++) { for (int j = 0; j < boardHeight - 1; j++) { file.WriteLine("{0} {1} {2} {3}", i, j, grainsBoard[i, j].Alive, ColorTranslator.ToHtml(grainsBoard[i, j].GetPenColor().Color)); } } } }
public Grain[] getNeighborhood(Grain[,] grains, int x, int y, int left, int top, int bottom, int right) { Grain[] neighborhood = new Grain[8]; neighborhood[0] = grains[left, top]; neighborhood[1] = grains[x, top]; neighborhood[2] = grains[right, top]; neighborhood[3] = grains[left, y]; neighborhood[4] = grains[right, y]; neighborhood[5] = grains[left, bottom]; neighborhood[6] = grains[x, bottom]; neighborhood[7] = grains[right, bottom]; return(neighborhood); }
public Simulation() { this.Tab = new Grain[SIZE_Y, SIZE_X]; this.previousGrains = new Grain[SIZE_Y, SIZE_X]; for (int i = 0; i < SIZE_Y; i++) { for (int j = 0; j < SIZE_X; j++) { this.Tab[i, j] = new Grain(j, i, 0); this.previousGrains[i, j] = this.Tab[i, j].Copy(); } } }
private bool HasAnyRecrystalizedNeighbour(int i, int j, Grain[,] structureArray) { var neighbourhood = StructureHelpers.TakeMooreNeighbourhood(i, j, structureArray); var recrystalizedNeighbour = neighbourhood.Where(g => (g.IsRecrystalized == true)).FirstOrDefault(); if (recrystalizedNeighbour != null) { return(true); } else { return(false); } }
public static void Replace(Grain[,] grainTable, Grain[,] tempGrainTable, int xNumOfCells, int yNumOfCells) { for (int i = 0; i < xNumOfCells; i++) { for (int j = 0; j < yNumOfCells; j++) { grainTable[i, j].Rect.Fill = tempGrainTable[i, j].Rect.Fill; grainTable[i, j].Rect.Stroke = tempGrainTable[i, j].Rect.Stroke; grainTable[i, j].Color = tempGrainTable[i, j].Color; grainTable[i, j].State = tempGrainTable[i, j].State; grainTable[i, j].id = tempGrainTable[i, j].id; } } }
private bool IsAnyInclusion(Grain[,] tab) { for (var x = 0; x < XSize; x++) { for (var y = 0; y < YSize; y++) { if (tab[x, y].Value == 2) { return(true); } } } return(false); }
public void createGrainArrays(int XSize, int YSize) { grainCointainer = new Grain[YSize, XSize]; grainCointainerSecond = new Grain[YSize, XSize]; for (int i = 0; i < YSize; i++) { for (int j = 0; j < XSize; j++) { grainCointainer[i, j] = new Grain(); grainCointainerSecond[i, j] = new Grain(); } } }
public static List <Grain> TakeMooreNeighbourhood(int i, int j, Grain[,] structureArray) { var neighbourhood = new List <Grain> { structureArray[i - 1, j], structureArray[i + 1, j], structureArray[i, j - 1], structureArray[i, j + 1], structureArray[i - 1, j - 1], structureArray[i - 1, j + 1], structureArray[i + 1, j - 1], structureArray[i + 1, j + 1] }; return(neighbourhood); }