Ejemplo n.º 1
0
        public static double HIntegralLinear(int n, BoundaryElement elem, BoundaryNode node, string pk) // Oblicza całkę H z daszkiem
        {
            //  n - ilość punktów Gaussa
            //  elem - element brzegowy
            //  ksi - współrzędna punktu obserwacji (punktu w którym przyłożono punktowe źródło ciepła)
            //  lam - współczynnik przewodzenia ciepła
            //  pk - Gp czy Gk
            double H = 0.0;

            double[] l = new double[2]; // tablica z długościami elementu względem x1 oraz x2
            l[0] = elem.XK[0] - elem.XP[0];
            l[1] = elem.XK[1] - elem.XP[1];

            double[] ksi = new double[2];   // Współrzędne punktu obserwacji (punktu w którym przyłożono punktowe źródło ciepła)
            ksi = node.Coordinates;

            double[] xp = new double[2]; // współrzędna początku elementu brzegowego
            xp = elem.XP;
            double[] xk = new double[2]; // współrzędna końca elementu brzegowego
            xk = elem.XK;

            if ((ksi[0] != xp[0] || ksi[1] != xp[1]) && (ksi[0] != xk[0] || ksi[1] != xk[1]))
            {
                double function = 0.0;           // Zmienna pomocnicza
                double a = 0.0, b = 0.0;         // Zmienna pomocnicza
                double naw = 0.0;                // Zmienna pomocnicza

                double[,] GP = GauusianPoint(n); // Tablica z wagami i odciętymi pkt. Gaussa

                for (int i = 0; i < n; i++)
                {
                    a = ((xp[0] + xk[0]) / 2) + (l[0] / 2) * GP[0, i] - ksi[0];
                    b = ((xp[1] + xk[1]) / 2) + (l[1] / 2) * GP[0, i] - ksi[1];
                    if (pk == "p")
                    {
                        naw = 1 - GP[0, i];
                    }
                    else
                    {
                        naw = 1 + GP[0, i];
                    }
                    function = naw * ((a * l[1] - b * l[0]) / (Math.Pow(a, 2) + Math.Pow(b, 2)));
                    H       += function * GP[1, i];
                }
                H *= (1 / (8 * Math.PI));
            }
            else
            {
                if (ksi[0] == xp[0] && ksi[1] == xp[1])
                {
                    H = 0.0;
                }
                if (ksi[0] == xk[0] && ksi[1] == xk[1])
                {
                    H = 0.0;
                }
            }

            return(H);
        }
Ejemplo n.º 2
0
        public BoundaryNodeList(InternalPointList ipList)   // Konstruktor dla punktów wewnętrznych
        {
            int ctr = ipList.Count;

            nList = new BoundaryNode[ctr];

            ctr = 0;
            foreach (InternalPoint ip in ipList)
            {
                nList[ctr] = new BoundaryNode(ip.Coordinates, 4, ctr++);
            }
        }
Ejemplo n.º 3
0
        public static double GIntegralConstant(int n, BoundaryElement elem, BoundaryNode node, double lam) // Oblicza całkę G
        {
            //  n - ilość punktów Gaussa
            //  elem - element brzegowy po który odbywa się całkowanie
            //  node - pkt obserwacji
            //  lam - współczynnik przewodzenia ciepła
            double G = 0.0;

            double[] l = new double[2]; // tablica z długościami elementu względem x1 oraz x2
            l[0] = elem.XK[0] - elem.XP[0];
            l[1] = elem.XK[1] - elem.XP[1];
            double d = Math.Sqrt(Math.Pow(l[0], 2) + Math.Pow(l[1], 2)); // Długość elementu

            double function = 0.0;                                       // Zmienna pomocnicza
            double a = 0.0, b = 0.0;                                     // Zmienna pomocnicza

            double[] ksi = new double[2];                                // Współrzędne punktu obserwacji (punktu w którym przyłożono punktowe źródło ciepła)
            ksi = node.Coordinates;

            double[] x = new double[2]; // współrzędna środka elementu brzegowego
            x[0] = elem.Node[0][0];
            x[1] = elem.Node[0][1];

            double[,] GP = GauusianPoint(n);      // Tablica z wagami i odciętymi pkt. Gaussa

            if (ksi[0] == x[0] && ksi[1] == x[1]) // Jeżeli i = j
            {
                G = (d / (2 * Math.PI * lam)) * (1 + Math.Log(2 / d, Math.E));
            }
            else // Jeżeli i jest różne od j
            {
                for (int i = 0; i < n; i++)
                {
                    a        = Math.Pow(x[0] + (l[0] / 2) * GP[0, i] - ksi[0], 2);
                    b        = Math.Pow(x[1] + (l[1] / 2) * GP[0, i] - ksi[1], 2);
                    function = Math.Log((1 / Math.Sqrt(a + b)), Math.E);
                    G       += function * GP[1, i];
                }

                G *= d / (4 * Math.PI * lam);
            }

            return(G);
        }
Ejemplo n.º 4
0
        public static double HIntegralConstant(int n, BoundaryElement elem, BoundaryNode node) // Oblicza całkę H z daszkiem
        {
            //  n - ilość punktów Gaussa
            //  elem - element brzegowy
            //  node - współrzędna punktu obserwacji (punktu w którym przyłożono punktowe źródło ciepła)
            double H = 0.0;

            double function = 0.0;        // Zmienna pomocnicza
            double a = 0.0, b = 0.0;      // Zmienna pomocnicza

            double[] ksi = new double[2]; // Współrzędne punktu obserwacji (punktu w którym przyłożono punktowe źródło ciepła)
            ksi = node.Coordinates;

            double[] l = new double[2]; // tablica z długościami elementu względem x1 oraz x2
            l[0] = elem.XK[0] - elem.XP[0];
            l[1] = elem.XK[1] - elem.XP[1];

            // Tuataj należy zmienić pierwszy indeks przy Node, aby wybierał inne wezły z elementu
            double[] x = new double[2]; // współrzędna środka elementu brzegowego
            x[0] = elem.Node[0][0];
            x[1] = elem.Node[0][1];

            double[,] GP = GauusianPoint(n);    // Tablica z wagami i odciętymi pkt. Gaussa

            if (ksi[0] == x[0] && ksi[1] == x[1])
            {
                H = 0.0;
            }
            else
            {
                for (int i = 0; i < n; i++)
                {
                    a        = x[0] + (l[0] / 2) * GP[0, i] - ksi[0];
                    b        = x[1] + (l[1] / 2) * GP[0, i] - ksi[1];
                    function = (a * l[1] - b * l[0]) / (Math.Pow(a, 2) + Math.Pow(b, 2));
                    H       += function * GP[1, i];
                }
                H *= 1 / (4 * Math.PI);
            }

            return(H);
        }
Ejemplo n.º 5
0
        public BoundaryNodeList(BoundaryList boundaryList)   // Konstruktor
        {
            switch (BoundaryElement.ElemType)
            {
            case "Constant":
            {
                int ctr = 0;
                foreach (Boundary boundary in boundaryList)
                {
                    ctr += boundary.Count;
                }

                nList = new BoundaryNode[ctr];

                ctr = 0;
                foreach (Boundary boundary in boundaryList)
                {
                    foreach (BoundaryElement bElement in boundary)
                    {
                        nList[ctr] = new BoundaryNode(bElement, bElement.Node[0], 1, ctr++);
                    }
                }
                break;
            }

            case "Linear":
            {
                int R = 0;
                foreach (Boundary boundary in boundaryList)
                {
                    if ((!AuxiliaryFunctions.Parallelism(boundary[0], boundary[boundary.Count - 1])) &&
                        (boundary[0].BC != boundary[boundary.Count - 1].BC))
                    {
                        R += 2;
                    }
                    else
                    {
                        R++;
                    }
                    for (int i = 1; i < boundary.Count; i++)
                    {
                        if ((!AuxiliaryFunctions.Parallelism(boundary[i], boundary[i - 1])) && (boundary[i].BC != boundary[i - 1].BC))
                        {
                            R += 2;
                        }
                        else
                        {
                            R++;
                        }
                    }
                }

                nList = new BoundaryNode[R];
                int ctr = 0;
                foreach (Boundary boundary in boundaryList)
                {
                    bool isFirstDouble = false;
                    if ((!AuxiliaryFunctions.Parallelism(boundary[0], boundary[boundary.Count - 1])) &&
                        (boundary[0].BC != boundary[boundary.Count - 1].BC))
                    {
                        nList[ctr]    = new BoundaryNode(boundary[0], boundary[0].XP, 2, ctr);
                        isFirstDouble = true;
                    }
                    else
                    {
                        nList[ctr] = new BoundaryNode(boundary[0], boundary[0].XP, 1, ctr);
                    }
                    ctr++;
                    for (int i = 1; i < boundary.Count; i++)
                    {
                        if ((!AuxiliaryFunctions.Parallelism(boundary[i], boundary[i - 1])) && (boundary[i].BC != boundary[i - 1].BC))
                        {
                            nList[ctr] = new BoundaryNode(boundary[i - 1], boundary[i - 1].XK, 2, ctr);
                            ctr++;
                            nList[ctr] = new BoundaryNode(boundary[i], boundary[i].XP, 2, ctr);
                        }
                        else
                        {
                            nList[ctr] = new BoundaryNode(boundary[i], boundary[i].XP, 1, ctr);
                        }
                        ctr++;
                    }
                    if (isFirstDouble)
                    {
                        nList[ctr++] = new BoundaryNode(boundary[boundary.Count - 1], boundary[boundary.Count - 1].XK, 2, ctr - 1);
                    }
                }
                break;
            }

            case "Parabolic":
            {
                int R = 0;
                foreach (Boundary boundary in boundaryList)
                {
                    if ((!AuxiliaryFunctions.Parallelism(boundary[0], boundary[boundary.Count - 1])) &&
                        (boundary[0].BC != boundary[boundary.Count - 1].BC))
                    {
                        R += 2;
                    }
                    else
                    {
                        R++;
                    }
                    R++;
                    for (int i = 1; i < boundary.Count; i++)
                    {
                        if ((!AuxiliaryFunctions.Parallelism(boundary[i], boundary[i - 1])) && (boundary[i].BC != boundary[i - 1].BC))
                        {
                            R += 2;
                        }
                        else
                        {
                            R++;
                        }
                        R++;
                    }
                }

                nList = new BoundaryNode[R];

                int ctr = 0;
                foreach (Boundary boundary in boundaryList)
                {
                    bool isFirstDouble = false;
                    if ((!AuxiliaryFunctions.Parallelism(boundary[0], boundary[boundary.Count - 1])) &&
                        (boundary[0].BC != boundary[boundary.Count - 1].BC))
                    {
                        nList[ctr]    = new BoundaryNode(boundary[0], boundary[0].XP, 2, ctr);
                        isFirstDouble = true;
                    }
                    else
                    {
                        nList[ctr] = new BoundaryNode(boundary[0], boundary[0].XP, 1, ctr);
                    }
                    ctr++;
                    nList[ctr] = new BoundaryNode(boundary[0], boundary[0].Node[1], 3, ctr);
                    ctr++;
                    for (int i = 1; i < boundary.Count; i++)
                    {
                        if ((!AuxiliaryFunctions.Parallelism(boundary[i], boundary[i - 1])) && (boundary[i].BC != boundary[i - 1].BC))
                        {
                            nList[ctr] = new BoundaryNode(boundary[i - 1], boundary[i - 1].XK, 2, ctr);
                            ctr++;
                            nList[ctr] = new BoundaryNode(boundary[i], boundary[i].XP, 2, ctr);
                        }
                        else
                        {
                            nList[ctr] = new BoundaryNode(boundary[i], boundary[i].XP, 1, ctr);
                        }
                        ctr++;
                        nList[ctr] = new BoundaryNode(boundary[i], boundary[i].Node[1], 3, ctr);
                        ctr++;
                    }
                    if (isFirstDouble)
                    {
                        nList[ctr++] = new BoundaryNode(boundary[boundary.Count - 1], boundary[boundary.Count - 1].XK, 2, ctr - 1);
                    }
                }
                break;
            }

            default:
                throw new System.Exception("Niepoprawny rodzaj elementu w konstruktorze NodeList!!!");
            }
        }
Ejemplo n.º 6
0
 public BoundaryNodeList(BoundaryNode node)  // Konstruktor do tworzenia listy jednoelementowej
 {
     nList    = new BoundaryNode[1];
     nList[0] = node;
 }
Ejemplo n.º 7
0
        public static double GIntegralParabolic(int n, BoundaryElement elem, BoundaryNode node, double lam, string psk) // Oblicza całkę G
        {
            //  n - ilość punktów Gaussa
            //  elem - element brzegowy po który odbywa się całkowanie
            //  elemWithKsi - element zawierający pkt obserwacji
            //  lam - współczynnik przewodzenia ciepła
            //  pk - Gp, Gs, czy Gk
            double G = 0.0;

            double[] l = new double[2]; // tablica z długościami elementu względem x1 oraz x2
            l[0] = elem.XK[0] - elem.XP[0];
            l[1] = elem.XK[1] - elem.XP[1];
            double d = Math.Sqrt(Math.Pow(l[0], 2) + Math.Pow(l[1], 2)); // Długość elementu

            double[] ksi = new double[2];                                // Współrzędne punktu obserwacji (punktu w którym przyłożono punktowe źródło ciepła)
            ksi = node.Coordinates;

            double[] xp = new double[2]; // współrzędna początku elementu brzegowego
            xp = elem.XP;
            double[] xs = new double[2]; // współrzędna środka elementu brzegowego
            xs = elem.Node[1];
            double[] xk = new double[2]; // współrzędna końca elementu brzegowego
            xk = elem.XK;

            if ((ksi[0] != xp[0] || ksi[1] != xp[1]) && (ksi[0] != xs[0] || ksi[1] != xs[1]) && (ksi[0] != xk[0] || ksi[1] != xk[1]))
            {
                double function = 0.0;           // Zmienna pomocnicza
                double a = 0.0, b = 0.0;         // Zmienna pomocnicza
                double naw = 0.0;                // Zmienna pomocnicza
                double con = 0.0;                // Zmienna pomocnicza

                double[,] GP = GauusianPoint(n); // Tablica z wagami i odciętymi pkt. Gaussa

                for (int i = 0; i < n; i++)
                {
                    a = Math.Pow(((xp[0] + xk[0]) / 2) + (l[0] / 2) * GP[0, i] - ksi[0], 2);
                    b = Math.Pow(((xp[1] + xk[1]) / 2) + (l[1] / 2) * GP[0, i] - ksi[1], 2);
                    if (psk == "p")
                    {
                        naw = GP[0, i] * (GP[0, i] - 1);
                        con = d / (8 * Math.PI * lam);
                    }
                    if (psk == "s")
                    {
                        naw = (1 + GP[0, i]) * (1 - GP[0, i]);
                        con = d / (4 * Math.PI * lam);
                    }
                    if (psk == "k")
                    {
                        naw = GP[0, i] * (1 + GP[0, i]);
                        con = d / (8 * Math.PI * lam);
                    }
                    function = naw * Math.Log((1 / Math.Sqrt(a + b)), Math.E);
                    G       += function * GP[1, i];
                }

                G *= con;
            }
            else
            {
                if (ksi[0] == xp[0] && ksi[1] == xp[1])
                {
                    if (psk == "p")
                    {
                        G = ((d * (17 - 6 * Math.Log(d, Math.E))) / (72 * Math.PI * lam));
                    }
                    if (psk == "s")
                    {
                        G = ((d * (5 - 6 * Math.Log(d, Math.E))) / (18 * Math.PI * lam));
                    }
                    if (psk == "k")
                    {
                        G = ((d * (-1 - 6 * Math.Log(d, Math.E))) / (72 * Math.PI * lam));
                    }
                }
                if (ksi[0] == xs[0] && ksi[1] == xs[1])
                {
                    if (psk == "p")
                    {
                        G = ((d * (1 + 3 * Math.Log(2, Math.E) - 3 * Math.Log(d, Math.E))) / (36 * Math.PI * lam));
                    }
                    if (psk == "s")
                    {
                        G = ((d * (4 + 3 * Math.Log(2, Math.E) - 3 * Math.Log(d, Math.E))) / (9 * Math.PI * lam));
                    }
                    if (psk == "k")
                    {
                        G = ((d * (1 + 3 * Math.Log(2, Math.E) - 3 * Math.Log(d, Math.E))) / (36 * Math.PI * lam));
                    }
                }
                if (ksi[0] == xk[0] && ksi[1] == xk[1])
                {
                    if (psk == "p")
                    {
                        G = ((d * (-1 - 6 * Math.Log(d, Math.E))) / (72 * Math.PI * lam));
                    }
                    if (psk == "s")
                    {
                        G = ((d * (5 - 6 * Math.Log(d, Math.E))) / (18 * Math.PI * lam));
                    }
                    if (psk == "k")
                    {
                        G = ((d * (17 - 6 * Math.Log(d, Math.E))) / (72 * Math.PI * lam));
                    }
                }
            }

            return(G);
        }