Example #1
0
        public void ComputeVectorFields(int resolution, double KPM, double deltaK)
        {
            string statesFile = "VectorFields.mg";

            statesFile = Simulator.logDir + "/" + statesFile;
            FileStream fs = new FileStream(statesFile, FileMode.OpenOrCreate);
            List <PersistantVectorFields> vectorFields = new List <PersistantVectorFields>();

            CsvSerializer <PersistantVectorFields> serializer = new CsvSerializer <PersistantVectorFields>();

            serializer.Separator = ';';


            velocities      = new Vector[resolution, resolution, resolution];
            gradPHI         = new Vector[resolution, resolution, resolution];
            vPeronaMalik    = new double[resolution + 1, resolution + 1, resolution + 1];
            gradPeronaMalik = new Vector[resolution, resolution, resolution];

            int halfResolution = resolution / 2;

            int count = 0;

            for (int i = 0; i < resolution; i++)
            {
                for (int j = 0; j < resolution; j++)
                {
                    for (int k = 0; k < resolution; k++)
                    {
                        PersistantVectorFields pvf = new PersistantVectorFields();
                        pvf.I    = i; pvf.J = j; pvf.K = k;
                        pvf.X    = X[i, j, k];
                        pvf.vPHI = (float)vPHI[i, j, k];

                        gradPHI[i, j, k] = new Vector();
                        if (i == halfResolution)
                        {
                            gradPHI[i, j, k].x = 0;
                        }
                        else if (i < halfResolution)
                        {
                            gradPHI[i, j, k].x = (vPHI[i + 1, j, k] - vPHI[i, j, k]) / thau.x;
                        }
                        else
                        {
                            gradPHI[i, j, k].x = -(vPHI[i - 1, j, k] - vPHI[i, j, k]) / thau.x;
                        }
                        if (j == halfResolution)
                        {
                            gradPHI[i, j, k].y = 0;
                        }
                        else if (j < halfResolution)
                        {
                            gradPHI[i, j, k].y = (vPHI[i, j + 1, k] - vPHI[i, j, k]) / thau.y;
                        }
                        else
                        {
                            gradPHI[i, j, k].y = -(vPHI[i, j - 1, k] - vPHI[i, j, k]) / thau.y;
                        }
                        if (k == halfResolution)
                        {
                            gradPHI[i, j, k].z = 0;
                        }
                        else if (k < halfResolution)
                        {
                            gradPHI[i, j, k].z = (vPHI[i, j, k + 1] - vPHI[i, j, k]) / thau.z;
                        }
                        else
                        {
                            gradPHI[i, j, k].z = -(vPHI[i, j, k - 1] - vPHI[i, j, k]) / thau.z;
                        }

                        //gradPHI[i, j, k] = new Vector(
                        //    (vPHI[i + 1, j, k] - vPHI[i, j, k]) / thau.x,
                        //    (vPHI[i, j + 1, k] - vPHI[i, j, k]) / thau.y,
                        //    (vPHI[i, j, k + 1] - vPHI[i, j, k]) / thau.z
                        //);
                        pvf.gradPHI = gradPHI[i, j, k];

                        vPeronaMalik[i, j, k] = Helper.PeronaMalik(gradPHI[i, j, k].sqrNorm(), KPM);
                        pvf.vPeronaMalik      = (float)vPeronaMalik[i, j, k];
                        //Console.WriteLine(i +","+ j + "," + k + ":" + vPeronaMalik[i, j, k]);

                        vectorFields.Add(pvf);
                        count++;
                    }
                }
            }

            count = 0;
            for (int i = 0; i < resolution; i++)
            {
                for (int j = 0; j < resolution; j++)
                {
                    for (int k = 0; k < resolution; k++)
                    {
                        gradPeronaMalik[i, j, k] = new Vector();

                        if (i == halfResolution)
                        {
                            gradPeronaMalik[i, j, k].x = 0;
                        }
                        else if (i < halfResolution)
                        {
                            gradPeronaMalik[i, j, k].x = (vPeronaMalik[i + 1, j, k] - vPeronaMalik[i, j, k]) / thau.x;
                        }
                        else
                        {
                            gradPeronaMalik[i, j, k].x = -(vPeronaMalik[i - 1, j, k] - vPeronaMalik[i, j, k]) / thau.x;
                        }

                        if (j == halfResolution)
                        {
                            gradPeronaMalik[i, j, k].y = 0;
                        }
                        else if (j < halfResolution)
                        {
                            gradPeronaMalik[i, j, k].y = (vPeronaMalik[i, j + 1, k] - vPeronaMalik[i, j, k]) / thau.y;
                        }
                        else
                        {
                            gradPeronaMalik[i, j, k].y = -(vPeronaMalik[i, j - 1, k] - vPeronaMalik[i, j, k]) / thau.y;
                        }

                        if (k == halfResolution)
                        {
                            gradPeronaMalik[i, j, k].z = 0;
                        }
                        else if (k < halfResolution)
                        {
                            gradPeronaMalik[i, j, k].z = (vPeronaMalik[i, j, k + 1] - vPeronaMalik[i, j, k]) / thau.z;
                        }
                        else
                        {
                            gradPeronaMalik[i, j, k].z = -(vPeronaMalik[i, j, k - 1] - vPeronaMalik[i, j, k]) / thau.z;
                        }

                        //gradPeronaMalik[i, j, k] = new Vector(
                        //    (vPeronaMalik[i + 1, j, k] - vPeronaMalik[i, j, k]) / thau.x,
                        //    (vPeronaMalik[i, j + 1, k] - vPeronaMalik[i, j, k]) / thau.y,
                        //    (vPeronaMalik[i, j, k + 1] - vPeronaMalik[i, j, k]) / thau.z
                        //);

                        vectorFields[count].gradPeronaMalik = gradPeronaMalik[i, j, k];
                        count++;
                    }
                }
            }

            for (int i = 0; i < resolution; i++)
            {
                for (int j = 0; j < resolution; j++)
                {
                    for (int k = 0; k < resolution; k++)
                    {
                        velocities[i, j, k] = -gradPeronaMalik[i, j, k];
                    }
                }
            }

            serializer.Serialize(fs, vectorFields);
            fs.Close();
        }
Example #2
0
        public void ComputeVectorFields1(int resolution, double KPM, double deltaK)
        {
            string statesFile = "VectorFields.mg";

            statesFile = Simulator.logDir + "/" + statesFile;
            FileStream fs = new FileStream(statesFile, FileMode.OpenOrCreate);
            List <PersistantVectorFields> vectorFields = new List <PersistantVectorFields>();

            CsvSerializer <PersistantVectorFields> serializer = new CsvSerializer <PersistantVectorFields>();

            serializer.Separator = ';';


            velocities      = new Vector[resolution, resolution];
            gradPHI         = new Vector[resolution, resolution];
            vPeronaMalik    = new double[resolution + 1, resolution + 1];
            gradPeronaMalik = new Vector[resolution, resolution];

            int count = 0;

            for (int i = 0; i < resolution; i++)
            {
                for (int j = 0; j < resolution; j++)
                {
                    PersistantVectorFields pvf = new PersistantVectorFields();
                    pvf.I    = i; pvf.J = j;
                    pvf.X    = X[i, j];
                    pvf.vPHI = (float)vPHI[i, j];


                    gradPHI[i, j] = new Vector(
                        (vPHI[i + 1, j] - vPHI[i, j]) / thau.x,
                        (vPHI[i, j + 1] - vPHI[i, j]) / thau.y
                        );
                    pvf.gradPHI = gradPHI[i, j];

                    vPeronaMalik[resolution, j] = vPeronaMalik[1, j];
                    vPeronaMalik[i, resolution] = vPeronaMalik[i, 1];

                    vPeronaMalik[i, j] = Helper.PeronaMalik(gradPHI[i, j].sqrNorm(), KPM);
                    pvf.vPeronaMalik   = (float)vPeronaMalik[i, j];

                    vectorFields.Add(pvf);
                    count++;
                }
            }

            count = 0;
            for (int i = 0; i < resolution; i++)
            {
                for (int j = 0; j < resolution; j++)
                {
                    gradPeronaMalik[i, j] = new Vector(
                        (vPeronaMalik[i + 1, j] - vPeronaMalik[i, j]) / thau.x,
                        (vPeronaMalik[i, j + 1] - vPeronaMalik[i, j]) / thau.y
                        );

                    vectorFields[count].gradPeronaMalik = gradPeronaMalik[i, j];

                    gradPeronaMalik[resolution - 1, j] = -gradPeronaMalik[0, j];
                    gradPeronaMalik[i, resolution - 1] = -gradPeronaMalik[i, 0];

                    count++;
                }
            }

            for (int i = 0; i < resolution; i++)
            {
                for (int j = 0; j < resolution; j++)
                {
                    velocities[i, j] = -gradPeronaMalik[i, j];
                }
            }

            serializer.Serialize(fs, vectorFields);
            fs.Close();
        }