Пример #1
0
        //Расчёт ближнего поля, возбуждаемого токами на апертуре
        unsafe public static NearFieldC SurfaceCurToGeometryCpp(Aperture app, Radome geom, double freq, float dim, int proc)
        {
            int ApSize = app.ApertureCurrent.Count;

            double[] ApX = new double[ApSize];
            double[] ApY = new double[ApSize];
            double[] ApZ = new double[ApSize];
            double[] ApS = new double[ApSize];

            for (int i = 0; i < ApSize; i++)
            {
                ApX[i] = app.ApertureCurrent[i].P.X;
                ApY[i] = app.ApertureCurrent[i].P.Y;
                ApZ[i] = app.ApertureCurrent[i].P.Z;
                ApS[i] = app.ApertureCurrent[i].S;
            }


            Complex[] Ix = new Complex[ApSize];
            Complex[] Iy = new Complex[ApSize];
            Complex[] Iz = new Complex[ApSize];

            Complex[] Mx = new Complex[ApSize];
            Complex[] My = new Complex[ApSize];
            Complex[] Mz = new Complex[ApSize];

            for (int j = 0; j < ApSize; j++)
            {
                Ix[j] = app.ApertureCurrent[j].I.X;
                Iy[j] = app.ApertureCurrent[j].I.Y;
                Iz[j] = app.ApertureCurrent[j].I.Z;

                Mx[j] = app.ApertureCurrent[j].M.X;
                My[j] = app.ApertureCurrent[j].M.Y;
                Mz[j] = app.ApertureCurrent[j].M.Z;
            }

            int GeoSize = geom.CountElements;

            double[] GeoX = new double[GeoSize];
            double[] GeoY = new double[GeoSize];
            double[] GeoZ = new double[GeoSize];

            int h = 0;

            for (int r = 0; r < geom.Count; r++)
            {
                RadomeElement finalGeom = geom[r];

                for (int k = 0; k < finalGeom.Count; k++)
                {
                    GeoX[h] = finalGeom[k].Center.X;
                    GeoY[h] = finalGeom[k].Center.Y;
                    GeoZ[h] = finalGeom[k].Center.Z;
                    h++;
                }
            }



            CComplex *sol = SurfaceCurrentToGeometry(ApX, ApY, ApZ, ApS, Ix, Iy, Iz, Mx, My, Mz, GeoX, GeoY, GeoZ, freq, ApSize, GeoSize, ref proc);

            NearFieldC ans = new NearFieldC(GeoSize);

            for (int i = 0; i < GeoSize; i++)
            {
                ans[i].E     = new CVector(new Complex(sol[i * 6 + 0].re, sol[i * 6 + 0].im), new Complex(sol[i * 6 + 1].re, sol[i * 6 + 1].im), new Complex(sol[i * 6 + 2].re, sol[i * 6 + 2].im));
                ans[i].H     = new CVector(new Complex(sol[i * 6 + 3].re, sol[i * 6 + 3].im), new Complex(sol[i * 6 + 4].re, sol[i * 6 + 4].im), new Complex(sol[i * 6 + 5].re, sol[i * 6 + 5].im));
                ans[i].Place = new Point3D(GeoX[i], GeoY[i], GeoZ[i]);
            }

            return(ans);
        }
Пример #2
0
        public static NearFieldC InducedNearFieldCpp(Current reflactedCurrents, Radome radUnion, double freq, Direction inside, int proc)
        {
            double  pi    = CV.pi;
            Complex imOne = new Complex(0, 1);

            double  Omega  = CV.Omega;
            double  K_0    = CV.K_0;
            double  K2     = CV.K2;
            Complex iOmega = CV.iOmega;
            Complex Ekoeff = CV.Ekoeff;

            Complex Z0m          = CV.Z0m;
            Complex Y0e          = CV.Y0e;
            double  magCoeff     = 1.07d;
            double  cutoff_angle = CV.cutoff_angle;

            int radomeUnionSize = radUnion.CountElements;

            double[] Nx = new double[radomeUnionSize];
            double[] Ny = new double[radomeUnionSize];
            double[] Nz = new double[radomeUnionSize];

            Complex[] Ix = new Complex[radomeUnionSize];
            Complex[] Iy = new Complex[radomeUnionSize];
            Complex[] Iz = new Complex[radomeUnionSize];

            Complex[] Mx = new Complex[radomeUnionSize];
            Complex[] My = new Complex[radomeUnionSize];
            Complex[] Mz = new Complex[radomeUnionSize];

            double[] Area = new double[radomeUnionSize];

            double[] pXO = new double[radomeUnionSize];
            double[] pYO = new double[radomeUnionSize];
            double[] pZO = new double[radomeUnionSize];

            double[] pXC = new double[radomeUnionSize];
            double[] pYC = new double[radomeUnionSize];
            double[] pZC = new double[radomeUnionSize];

            double[] pX1 = new double[radomeUnionSize];
            double[] pY1 = new double[radomeUnionSize];
            double[] pZ1 = new double[radomeUnionSize];

            double[] pX2 = new double[radomeUnionSize];
            double[] pY2 = new double[radomeUnionSize];
            double[] pZ2 = new double[radomeUnionSize];

            double[] pX3 = new double[radomeUnionSize];
            double[] pY3 = new double[radomeUnionSize];
            double[] pZ3 = new double[radomeUnionSize];

            int h = 0;

            for (int w = 0; w < radUnion.Count; w++)
            {
                RadomeElement rad = radUnion[w];
                for (int i = 0; i < rad.Count; i++)
                {
                    Nx[h] = (-1) * rad[i].Norma.X;
                    Ny[h] = (-1) * rad[i].Norma.Y;
                    Nz[h] = (-1) * rad[i].Norma.Z;

                    Ix[h] = reflactedCurrents[h].I.X;
                    Iy[h] = reflactedCurrents[h].I.Y;
                    Iz[h] = reflactedCurrents[h].I.Z;

                    Mx[h] = reflactedCurrents[h].M.X;
                    My[h] = reflactedCurrents[h].M.Y;
                    Mz[h] = reflactedCurrents[h].M.Z;

                    Area[h] = rad[i].Area;

                    pXC[h] = rad[i].Center.X;
                    pYC[h] = rad[i].Center.Y;
                    pZC[h] = rad[i].Center.Z;

                    pXO[h] = magCoeff * rad[i].Center.X;
                    pYO[h] = magCoeff * rad[i].Center.Y;
                    pZO[h] = magCoeff * rad[i].Center.Z;

                    pX1[h] = rad[i].Triangle.V1.X;
                    pY1[h] = rad[i].Triangle.V1.Y;
                    pZ1[h] = rad[i].Triangle.V1.Z;

                    pX2[h] = rad[i].Triangle.V2.X;
                    pY2[h] = rad[i].Triangle.V2.Y;
                    pZ2[h] = rad[i].Triangle.V2.Z;

                    pX3[h] = rad[i].Triangle.V3.X;
                    pY3[h] = rad[i].Triangle.V3.Y;
                    pZ3[h] = rad[i].Triangle.V3.Z;
                    h++;
                }
            }

            NearFieldC reflectedNearField = new NearFieldC(radomeUnionSize);

            ///

            CComplex *sol = InducedNF(Ix, Iy, Iz, Mx, My, Mz, Nx, Ny, Nz, Area, radomeUnionSize, pXO, pYO, pZO, pXC, pYC, pZC, pX1, pY1, pZ1, pX2, pY2, pZ2, pX3, pY3, pZ3, freq, ref proc);

            for (int i = 0; i < radomeUnionSize; i++)
            {
                reflectedNearField[i].E     = new CVector(new Complex(sol[i * 6 + 0].re, sol[i * 6 + 0].im), new Complex(sol[i * 6 + 1].re, sol[i * 6 + 1].im), new Complex(sol[i * 6 + 2].re, sol[i * 6 + 2].im));
                reflectedNearField[i].H     = new CVector(new Complex(sol[i * 6 + 3].re, sol[i * 6 + 3].im), new Complex(sol[i * 6 + 4].re, sol[i * 6 + 4].im), new Complex(sol[i * 6 + 5].re, sol[i * 6 + 5].im));
                reflectedNearField[i].Place = new Point3D(pXC[i], pYC[i], pZC[i]);
            }

            return(reflectedNearField);
        }
Пример #3
0
        unsafe public static NearFieldC ReflactedNearFieldCpp(Radome radUnion, NearFieldC incidentField, double freq, int proc)
        {
            int radomeUnionSize = radUnion.CountElements;

            double[] Nx = new double[radomeUnionSize];
            double[] Ny = new double[radomeUnionSize];
            double[] Nz = new double[radomeUnionSize];

            Complex[] incEx = new Complex[radomeUnionSize];
            Complex[] incEy = new Complex[radomeUnionSize];
            Complex[] incEz = new Complex[radomeUnionSize];

            Complex[] incHx = new Complex[radomeUnionSize];
            Complex[] incHy = new Complex[radomeUnionSize];
            Complex[] incHz = new Complex[radomeUnionSize];

            int[] stenkaIndexer = new int[radomeUnionSize];

            int layersSummary = 0;

            for (int i = 0; i < radUnion.Count; i++)
            {
                layersSummary += radUnion[i].Structure.Count;
            }

            Complex[] eps_a    = new Complex[layersSummary];
            Complex[] mu_a     = new Complex[layersSummary];
            double[]  tickness = new double[layersSummary];

            //указывает сколько слоёв в каждом элементе обтекателя
            int[]    layersCount = new int[radUnion.Count];
            double[] gtickness   = new double[radUnion.Count];

            int s = 0;

            for (int i = 0; i < radUnion.Count; i++)
            {
                layersCount[i] = radUnion[i].Structure.Count;
                gtickness[i]   = radUnion[i].Structure.GeneralThickness;
                for (int r = 0; r < radUnion[i].Structure.Count; r++)
                {
                    eps_a[s]    = radUnion[i].Structure[r].Ea;
                    mu_a[s]     = radUnion[i].Structure[r].Mua;
                    tickness[s] = radUnion[i].Structure[r].Tickness;
                    s++;
                }
            }

            double[] px = new double[radomeUnionSize];
            double[] py = new double[radomeUnionSize];
            double[] pz = new double[radomeUnionSize];
            int      h  = 0;

            for (int w = 0; w < radUnion.Count; w++)
            {
                RadomeElement rad = radUnion[w];
                for (int i = 0; i < rad.Count; i++)
                {
                    Nx[h] = (-1) * rad[i].Norma.X;
                    Ny[h] = (-1) * rad[i].Norma.Y;
                    Nz[h] = (-1) * rad[i].Norma.Z;

                    incEx[h] = incidentField[h].E.X;
                    incEy[h] = incidentField[h].E.Y;
                    incEz[h] = incidentField[h].E.Z;

                    incHx[h] = incidentField[h].H.X;
                    incHy[h] = incidentField[h].H.Y;
                    incHz[h] = incidentField[h].H.Z;

                    px[h] = rad[i].Center.X;
                    py[h] = rad[i].Center.Y;
                    pz[h] = rad[i].Center.Z;

                    stenkaIndexer[h] = w;
                    h++;
                }
            }

            int        numberElements     = incidentField.Count;
            NearFieldC reflectedNearField = new NearFieldC(numberElements);

            CComplex *sol = ReflactedFromRadomeNF(incEx, incEy, incEz, incHx, incHy, incHz,
                                                  Nx, Ny, Nz, px, py, pz,
                                                  eps_a, mu_a, tickness, gtickness, layersCount, stenkaIndexer,
                                                  numberElements, freq, ref proc);


            for (int i = 0; i < numberElements; i++)
            {
                reflectedNearField[i].E     = new CVector(new Complex(sol[i * 6 + 0].re, sol[i * 6 + 0].im), new Complex(sol[i * 6 + 1].re, sol[i * 6 + 1].im), new Complex(sol[i * 6 + 2].re, sol[i * 6 + 2].im));
                reflectedNearField[i].H     = new CVector(new Complex(sol[i * 6 + 3].re, sol[i * 6 + 3].im), new Complex(sol[i * 6 + 4].re, sol[i * 6 + 4].im), new Complex(sol[i * 6 + 5].re, sol[i * 6 + 5].im));
                reflectedNearField[i].Place = new Point3D(px[i], py[i], pz[i]);
            }
            return(reflectedNearField);
        }