public CreateStenkaForm(Form1 parent, Stenka stenka)
{
InitializeComponent();
reducting = true;
parentForm = parent;
ShowCurrentStenkaParameters(stenka);
textBoxName.Text = stenka.Lable;
currentStenkaLable = stenka.Lable;
Show();
}
private void ShowCurrentStenkaParameters(Stenka s)
{
for (int i = 0; i < dataGridView1.RowCount; i++)
{
dataGridView1.Rows.RemoveAt(i);
}
for (int k = 0; k < s.Count; k++)
{
string eps1 = s[k].Permittivity.Real.ToString(Format1);
string eps2 = s[k].Permittivity.Imaginary.ToString(Format1);
string mu1 = s[k].Permeability.Real.ToString(Format1);
string mu2 = s[k].Permeability.Imaginary.ToString(Format1);
string t = (s[k].Tickness * 1e3).ToString(Format1);
dataGridView1.Rows.Add(dataGridView1.RowCount + 1, eps1, eps2, mu1, mu2, t);
}
}
public static Tuple <Complex, Complex, Complex, Complex> ReflectionCoefficientCalc2(Stenka st, double kappaTo2, double theta, double Omega, double K2, Complex Y0e, Complex Z0m)
{
Matrix <Complex> generalMatrixEtype = Matrix <Complex> .Build.Dense(2, 2, new Complex[] { 1, 0, 0, 1 });
Matrix <Complex> generalMatrixMtype = Matrix <Complex> .Build.Dense(2, 2, new Complex[] { 1, 0, 0, 1 });
Complex iomega = imOne * Omega;
int layerCount = st.Count;
for (int i = 0; i < layerCount; i++)
{
Complex Ea = st[i].Ea;
Complex Mua = st[i].Mua;
Complex Zm = iomega * Mua;
Complex Ye = iomega * Ea;
Complex a_e, b_e, c_e, d_e;
Complex a_m, b_m, c_m, d_m;
//
// определение волновое число в диэлектрике
//
Complex k_a = Omega * Complex.Sqrt(Mua * Ea);
//
// расчет гамма в диэлектрике и в свободном пространстве
//
Complex gamma = Complex.Sqrt(kappaTo2 - k_a * k_a);
//
// Волновое сопротивление в диэлектрике
//
Complex we = gamma / Ye;
Complex wm = Zm / gamma;
Complex gammaL = gamma * st[i].Tickness;
Complex sinhGT = Complex.Sinh(gammaL);
Complex coshGT = Complex.Cosh(gammaL);
a_e = coshGT;
a_m = coshGT;
b_e = we * sinhGT;
b_m = wm * sinhGT;
c_e = 1 / we * sinhGT;
c_m = 1 / wm * sinhGT;
d_e = coshGT;
d_m = coshGT;
Matrix <Complex> matrixEtype = Matrix <Complex> .Build.Dense(2, 2);//, new Complex[] { a_e, b_e, c_e, d_e });
matrixEtype[0, 0] = a_e;
matrixEtype[0, 1] = b_e;
matrixEtype[1, 0] = c_e;
matrixEtype[1, 1] = d_e;
generalMatrixEtype = generalMatrixEtype * matrixEtype;
//generalMatrixEtype = Multyply(generalMatrixEtype, matrixEtype);
Matrix <Complex> matrixMtype = Matrix <Complex> .Build.Dense(2, 2); //, new Complex[] { a_m, b_m, c_m, d_m });
matrixMtype[0, 0] = a_m;
matrixMtype[0, 1] = b_m;
matrixMtype[1, 0] = c_m;
matrixMtype[1, 1] = d_m;
generalMatrixMtype = generalMatrixMtype * matrixMtype;
//generalMatrixMtype = Multyply(generalMatrixMtype, matrixMtype);
}
//
// расчет гамма в свободном пространстве
//
Complex gamma0 = Complex.Sqrt(kappaTo2 - K2);
//
// Волновое сопротивление в свободном пространстве
//
Complex w0e = gamma0 / Y0e;
Complex w0m = Z0m / gamma0;
Complex A_e = generalMatrixEtype[0, 0]; // а элемент матрицы передачи сквозь весь диэлектрик для полей типа Е
Complex A_m = generalMatrixMtype[0, 0]; // а элемент матрицы передачи сквозь весь диэлектрик для полей типа H
Complex B_e = generalMatrixEtype[0, 1]; // b элемент матрицы передачи сквозь весь диэлектрик для полей типа Е
Complex B_m = generalMatrixMtype[0, 1]; // b элемент матрицы передачи сквозь весь диэлектрик для полей типа H
Complex C_e = generalMatrixEtype[1, 0]; // с элемент матрицы передачи сквозь весь диэлектрик для полей типа Е
Complex C_m = generalMatrixMtype[1, 0]; // с элемент матрицы передачи сквозь весь диэлектрик для полей типа H
Complex D_e = generalMatrixEtype[1, 1]; // d элемент матрицы передачи сквозь весь диэлектрик для полей типа Е
Complex D_m = generalMatrixMtype[1, 1]; // d элемент матрицы передачи сквозь весь диэлектрик для полей типа H
//
// входное сопротивление длинной линии со стороны слоя
//
Complex inputZe = (A_e * w0e + B_e) / (C_e * w0e + D_e);
Complex inputZm = (A_m * w0m + B_m) / (C_m * w0m + D_m);
//
// расчет коэффициента прохождения
//
Complex refE = (inputZe - w0e) / (inputZe + w0e);
Complex refH = (inputZm - w0m) / (inputZm + w0m);
Complex tE = inputZe * w0e / (inputZe + w0e) / (A_e * w0e + B_e);
Complex tH = inputZm * w0m / (inputZm + w0m) / (A_m * w0m + B_m);
return(Tuple.Create(refE, refH, tE, tH));
}
public static NearFieldC ReflactedNearFieldCs(Radome radUnion, NearFieldC incidentField, double freq, 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 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[] 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++;
}
}
Point3D[] pointsCenter = new Point3D[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;
pointsCenter[h] = rad[i].Center;
stenkaIndexer[h] = w;
h++;
}
}
int numberElements = incidentField.Count;
NearFieldC reflectedNearField = new NearFieldC(numberElements);
Task[] tasks = new Task[proc];
for (int g = 0; g < proc; g++)
{
tasks[g] = Task.Factory.StartNew((Object obj) =>
{
int cur_proc = (int)obj;
int start = GetStartIndex(cur_proc, proc, numberElements);
int end = GetEndIndex(cur_proc, proc, numberElements);
for (int j = start; j <= end; j++)
{
double thetaLoc = 0;
double nx = Nx[j];
double ny = Ny[j];
double nz = Nz[j];
Complex Eincx = incEx[j];
Complex Eincy = incEy[j];
Complex Eincz = incEz[j];
Complex Hincx = incHx[j];
Complex Hincy = incHy[j];
Complex Hincz = incHz[j];
Complex HincxCoj = Complex.Conjugate(incHx[j]);
Complex HincyCoj = Complex.Conjugate(incHy[j]);
Complex HinczCoj = Complex.Conjugate(incHz[j]);
Complex JincComplexx = Eincy * HinczCoj - Eincz * HincyCoj;
Complex JincComplexy = Eincz * HincxCoj - Eincx * HinczCoj;
Complex JincComplexz = Eincx * HincyCoj - Eincy * HincxCoj;
double kx = JincComplexx.Real;
double ky = JincComplexy.Real;
double kz = JincComplexz.Real;
double modulus = Math.Sqrt(kx * kx + ky * ky + kz * kz);
kx /= modulus;
ky /= modulus;
kz /= modulus;
double scalNK = kx * nx + ky * ny + kz * nz; // скалярное произведение вектора нормали n и вектора k;
//
// Определение thetaLoc
//
if (Math.Abs(scalNK) >= 1)
{
thetaLoc = 0;
}
else if (Math.Abs(scalNK) >= 0.035)
{
thetaLoc = Math.Acos(scalNK); // угол theta в локальной системе координат, в радианах
}
else if (Math.Abs(scalNK) >= 0)
{
thetaLoc = cutoff_angle;
}
double VincRx, VincRy, VincRz;
if (thetaLoc > 0.001)
{
VincRx = ky * nz - kz * ny;
VincRy = kz * nx - kx * nz;
VincRz = kx * ny - ky * nx;
double modulus2 = Math.Sqrt(VincRx * VincRx + VincRy * VincRy + VincRz * VincRz);
VincRx /= modulus2;
VincRy /= modulus2;
VincRz /= modulus2;
}
else
{
if (Math.Abs(nx) < 0.98)
{
VincRx = 0;
VincRy = nz;
VincRz = (-1) * ny;
double modulus2 = Math.Sqrt(VincRy * VincRy + VincRz * VincRz);
VincRy /= modulus2;
VincRz /= modulus2;
}
else
{
VincRx = (-1) * nz;
VincRy = 0;
VincRz = nx;
double modulus2 = Math.Sqrt(VincRx * VincRx + VincRz * VincRz);
VincRx /= modulus2;
VincRz /= modulus2;
}
}
double VincLx = ky * VincRz - kz * VincRy;
double VincLy = kz * VincRx - kx * VincRz;
double VincLz = kx * VincRy - ky * VincRx;
double modulus3 = Math.Sqrt(VincLx * VincLx + VincLy * VincLy + VincLz * VincLz);
VincLx /= modulus3;
VincLy /= modulus3;
VincLz /= modulus3;
double kp1 = K_0 * Math.Sin(thetaLoc); // kp1, kp2 - пространственные частоты
double kappa2 = kp1 * kp1;
Stenka st = radUnion[stenkaIndexer[j]].Structure;
Tuple <Complex, Complex, Complex, Complex> reflect = TRCoeffitients.ReflectionCoefficientCalc2(st, kappa2, thetaLoc, Omega, K2, Y0e, Z0m);
Complex refE = reflect.Item1;
Complex refH = reflect.Item2;
Complex tE = reflect.Item3;
Complex tH = reflect.Item4;
Complex EincL = Eincx * VincLx + Eincy * VincLy + Eincz * VincLz;
Complex EincR = Eincx * VincRx + Eincy * VincRy + Eincz * VincRz;
Complex HincL = Hincx * VincLx + Hincy * VincLy + Hincz * VincLz;
Complex HincR = Hincx * VincRx + Hincy * VincRy + Hincz * VincRz;
double VrefRx = VincRx;
double VrefRy = VincRy;
double VrefRz = VincRz;
//double doubleVincLByNScal = Math.Abs(VincLx * nx + VincLy * ny + VincLz * nz);
double kref_x = kx - 2 * nx * Math.Cos(thetaLoc);
double kref_y = ky - 2 * ny * Math.Cos(thetaLoc);
double kref_z = kz - 2 * nz * Math.Cos(thetaLoc);
//double VrefLx = (2 * doubleVincLByNScal * nx) + VincLx;
//double VrefLy = (2 * doubleVincLByNScal * ny) + VincLy;
//double VrefLz = (2 * doubleVincLByNScal * nz) + VincLz;
double VrefLx = -(kref_y * VincRz - kref_z * VincRy);
double VrefLy = -(kref_z * VincRx - kref_x * VincRz);
double VrefLz = -(kref_x * VincRy - kref_y * VincRx);
double modulus4 = Math.Sqrt(VrefLx * VrefLx + VrefLy * VrefLy + VrefLz * VrefLz);
VrefLx /= modulus4;
VrefLy /= modulus4;
VrefLz /= modulus4;
Complex ErefLx = refE * EincL * VrefLx; //(2 * (SCVector.Scal(EincL, n) * n) - EincL)
Complex ErefLy = refE * EincL * VrefLy;
Complex ErefLz = refE * EincL * VrefLz;
Complex ErefRx = refH * EincR * VrefRx;
Complex ErefRy = refH * EincR * VrefRy;
Complex ErefRz = refH * EincR * VrefRz;
Complex HrefLx = refH * HincL * VrefLx;
Complex HrefLy = refH * HincL * VrefLy;
Complex HrefLz = refH * HincL * VrefLz;
Complex HrefRx = refE * HincR * VrefRx;
Complex HrefRy = refE * HincR * VrefRy;
Complex HrefRz = refE * HincR * VrefRz;
Complex Erefx = (-1) * (ErefLx + ErefRx);
Complex Erefy = (-1) * (ErefLy + ErefRy);
Complex Erefz = (-1) * (ErefLz + ErefRz);
Complex Hrefx = HrefLx + HrefRx;
Complex Hrefy = HrefLy + HrefRy;
Complex Hrefz = HrefLz + HrefRz;
reflectedNearField[j].E = new CVector(Erefx, Erefy, Erefz); //
reflectedNearField[j].H = new CVector(Hrefx, Hrefy, Hrefz); //
reflectedNearField[j].Place = pointsCenter[j];
}
}, g);
}
Task.WaitAll(tasks);
return(reflectedNearField);
}