예제 #1
0
        public static double HIntegralLinear(int n, BoundaryElement elem, InternalPoint iPoint, 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 = iPoint.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);
        }
예제 #2
0
        public static bool Parallelism(BoundaryElement elem1, BoundaryElement elem2) // Funkcja sprawdzająca równoległość elementów
        {
            // elem1 - element pierwszy
            // elem2 - element drugi
            double[] U = { (elem1.XK[0] - elem1.XP[0]), (elem1.XK[1] - elem1.XP[1]) };
            double[] V = { (elem2.XK[0] - elem2.XP[0]), (elem2.XK[1] - elem2.XP[1]) };
            double   J = U[0] * V[1] - U[1] * V[0];

            if (J == 0)
            {
                return(true);
            }
            else
            {
                return(false);
            }
        }
예제 #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);
        }
예제 #4
0
        public static double HIntegralConstant(int n, BoundaryElement elem, InternalPoint iPoint) // 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 = iPoint.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);
        }
예제 #5
0
 public BoundaryNode(BoundaryElement elem, double[] nodeCoordinate, int nType, int ID)   // Konstruktor do tworzenia węzłów brzegowych
 {
     nodeID          = ID;
     nodeType        = nType;
     this.elemID     = elem.ElemID;
     this.boundaryID = elem.BoundaryID;
     this.whichBC    = elem.BC;
     this.node       = nodeCoordinate;
     if (whichBC == "Dirichlet")
     {
         t = elem.T;
     }
     if (whichBC == "Neumann")
     {
         q = elem.Q;
     }
     if (whichBC == "Robin")
     {
         a = elem.A; tot = elem.Tot;
     }
 }
예제 #6
0
 public void Add(BoundaryElement element)    // Dodaj element
 {
     List.Add(element);
 }
예제 #7
0
        public static double GIntegralParabolic(int n, BoundaryElement elem, InternalPoint iPoint, 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 = iPoint.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);
        }