Beispiel #1
0
        /// <summary>
        /// Связывание мицелл в ядре
        /// </summary>
        public static List <int[]> BoundMiccelCore(int aLength, int bLength, int amount,
                                                   double radius, double[,] miccel)
        {
            var bonds         = new List <int[]>();
            var bondsInMiccel = new List <int[]>();
            var intermedBonds = new List <int[]>();

            int maxBonds = 4;

            // Запись первоначальных связей
            for (int i = 0; i < miccel.GetLength(0); i++)
            {
                int first  = i + 1;
                int second = i + 2;

                if (((i + 1) % (aLength + bLength)) != 0)
                {
                    intermedBonds.Add(new int[] { first, second });
                }
            }


            int allChains = FilmFormer.GetAllChainsInFilm(aLength + bLength, miccel);


            // Идем по каждой цепи
            for (int k = 0; k < allChains; k++)
            {
                // Идем по каждому биду внутри цепи k, принадлежащей ядру
                for (int i = bLength - 1; i >= 0; i--)
                {
                    int beadbonds = 0;

                    int index = k * (aLength + bLength) + aLength + i;

                    int first = index + 1;


                    for (int j = 0; j < intermedBonds.Count; j++)
                    {
                        if (intermedBonds[j][0] == first || intermedBonds[j][1] == first)
                        {
                            beadbonds++;
                        }
                    }

                    if (beadbonds > 3)
                    {
                        continue;
                    }

                    // Смотрим остальные биды внутри ядра , не принадлежащие цепи k
                    for (int j = 0; j < miccel.GetLength(0); j++)
                    {
                        if (beadbonds > 3)
                        {
                            break;
                        }

                        if (j < k * (aLength + bLength) || j >= (k + 1) * (aLength + bLength))
                        {
                            if (miccel[j, 3] == 1.01)
                            {
                                double distance = Math.Sqrt(Math.Pow(miccel[index, 0] - miccel[j, 0], 2) +
                                                            Math.Pow(miccel[index, 1] - miccel[j, 1], 2) +
                                                            Math.Pow(miccel[index, 2] - miccel[j, 2], 2));

                                if (distance <= radius)
                                {
                                    int second = j + 1;

                                    int secondBonds = 0;

                                    bool hasElement = false;

                                    for (int l = 0; l < intermedBonds.Count; l++)
                                    {
                                        if (intermedBonds[l][0] == second ||
                                            intermedBonds[l][1] == second)
                                        {
                                            secondBonds++;
                                        }
                                    }

                                    //for (int l = 0; l < interBondsPerAtom.Count; l++)
                                    //{
                                    //    if (interBondsPerAtom[l][0] == j + 1)
                                    //    {
                                    //        hasElement = true;
                                    //        break;
                                    //    }
                                    //}

                                    if (!hasElement && secondBonds < maxBonds)
                                    {
                                        intermedBonds.Add(new int[] { first, second });
                                        beadbonds++;
                                    }
                                }
                            }
                        }
                    }
                }
            }

            // Сортировка
            for (int i = 0; i < miccel.GetLength(0); i++)
            {
                foreach (var c in intermedBonds)
                {
                    if (c[0] == i + 1)
                    {
                        bondsInMiccel.Add(c);
                    }
                }
            }

            // Запись
            for (int a = 0; a < amount; a++)
            {
                for (int i = 0; i < bondsInMiccel.Count; i++)
                {
                    bonds.Add(new int[] { bondsInMiccel[i][0] + a * miccel.GetLength(0),
                                          bondsInMiccel[i][1] + a * miccel.GetLength(0) });
                }
            }

            return(bonds);
        }
Beispiel #2
0
        public static List <MiccelData> ShiftAll(bool hasWalls, bool onlyPolymer, int density,
                                                 int xSize, int ySize, int zSize,
                                                 double xShift, double yShift, double zShift,
                                                 double[,] data)
        {
            var atoms = new List <MiccelData>();

            // 0 Этап - смещение (если есть) всех частиц по координате
            for (int i = 0; i < data.GetLength(0); i++)
            {
                data[i, 0] += xShift;
                if (data[i, 0] <= -xSize / 2.0)
                {
                    data[i, 0] = data[i, 0] + xSize;
                }
                if (data[i, 0] >= xSize / 2.0)
                {
                    data[i, 0] = data[i, 0] - xSize;
                }
            }

            for (int i = 0; i < data.GetLength(0); i++)
            {
                data[i, 1] += yShift;
                if (data[i, 1] <= -ySize / 2.0)
                {
                    data[i, 1] = data[i, 1] + ySize;
                }
                if (data[i, 1] >= ySize / 2.0)
                {
                    data[i, 1] = data[i, 1] - ySize;
                }
            }

            // 1 Этап - смещение по оси z с учетом наличия/отсутствия стенок
            double coef = 0;

            if (hasWalls)
            {
                double step = 1.0 / Math.Pow((double)density, 1.0 / 3.0);
                coef = 0.8 * step;
            }

            //1.5 Этап - определение типа координат
            bool onlyZPositive = true;

            for (int i = 0; i < data.GetLength(0); i++)
            {
                if (data[i, 2] < 0.0)
                {
                    onlyZPositive = false;
                    break;
                }
            }

            for (int i = 0; i < data.GetLength(0); i++)
            {
                if (onlyZPositive)
                {
                    data[i, 2] += zShift;
                    if (data[i, 2] <= coef)
                    {
                        data[i, 2] = data[i, 2] + zSize - 2 * coef;
                    }
                    if (data[i, 2] >= zSize - coef)
                    {
                        data[i, 2] = data[i, 2] - zSize + 2 * coef;
                    }
                }
                else
                {
                    data[i, 2] += (zShift - zSize / 2.0);
                    if (data[i, 2] <= -zSize / 2.0 + coef)
                    {
                        data[i, 2] = data[i, 2] + zSize - 2 * coef;
                    }
                    if (data[i, 2] >= zSize / 2.0 - coef)
                    {
                        data[i, 2] = data[i, 2] - zSize + 2 * coef;
                    }
                }
            }

            int maxcount = xSize * ySize * ySize * density;

            for (int i = 0; i < maxcount; i++)
            {
                if (onlyPolymer)
                {
                    if (data[i, 3].Equals(1.00) || data[i, 3].Equals(1.01) || data[i, 3].Equals(1.04))
                    {
                        atoms.Add(new MiccelData(data[i, 3], i + 1, data[i, 0], data[i, 1], data[i, 2]));
                    }
                }
                else
                {
                    atoms.Add(new MiccelData(data[i, 3], i + 1, data[i, 0], data[i, 1], data[i, 2]));
                }
            }

            if (hasWalls)
            {
                FilmFormer fFormer = new FilmFormer(xSize, ySize, zSize, density, data);

                fFormer.AddWalls(atoms);
            }

            return(atoms);
        }