MoM矩量法（二）：阻抗矩阵的填充

最新推荐文章于 2021-06-06 14:15:51 发布
最新推荐文章于 2021-06-06 14:15:51 发布
阅读量3.7k 收藏 21
点赞数 7
分类专栏： MoM矩量法 计算电磁学 文章标签： 电磁学 矩阵
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/luckytsw/article/details/107553171
版权

MoM矩量法（二）：阻抗矩阵的填充

阻抗矩阵的填充是矩量法的核心，也是矩量法中最难的一部分。本文采用的是基于RWG基函数的矩量法，公式的推导不再赘述，直接贴上公式讲代码思路。
这里采用的公式来自于聂在平主编的《目标与环境 电磁散射特性建模——理论、方法与实现（应用篇）》，所有数据均采用国际标准单位。

完整代码已贴在文章最后。文章和代码思路借鉴了https://blog.csdn.net/u014411646/article/details/99689460，谢谢原作者！

由于阻抗矩阵是在两个三角单元上积分而来，当两个三角单元相同时，就会出现积分的奇异性问题，所以阻抗矩阵的计算包括奇异积分和非奇异积分两部分。

一、非奇异积分

在这里插入图片描述

上面是阻抗矩阵的填充公式，我们以 m m m和 n n n代表两条边，字母右上角的正负号表示的是左右两个三角单元。例如， Z m n + − Z_{mn}^{+-} Zmn+−​就表示对 m m m边的左边三角单元和 n n n边的右边三角单元进行运算。

上式中各符号的含义：
  1. k k k代表自由空间波数，值为 2 π / λ 2\pi/\lambda 2π/λ，单位为 r a d / m rad/m rad/m； Z Z Z代表自由空间波阻抗，值为 376.73031 376.73031 376.73031欧姆；
  2. l m l_m lm​和 l n l_n ln​代表两条边的长度；
  3. w k 、 w j w_k、w_j wk​、wj​和 x k 、 y k 、 z k 、 x j 、 y j 、 z j x_k、y_k、z_k、x_j、y_j、z_j xk​、yk​、zk​、xj​、yj​、zj​分别为采样点加权因子和三角形数值积分采样点参数值，具体取值在后面给出；
  4. p m i p_{mi} pmi​和 p n i p_{ni} pni​代表三角单元的三个顶点。
    下表为三角单元数值积分表：
    在这里插入图片描述
核心代码：
for (int k = 0;k < 4;k++) {
		rowvec rmk(3);
		rmk(0) = ptm(0, 0) * xx[k] + ptm(1, 0) * yy[k] + ptm(2, 0) * zz[k];
		rmk(1) = ptm(0, 1) * xx[k] + ptm(1, 1) * yy[k] + ptm(2, 1) * zz[k];
		rmk(2) = ptm(0, 2) * xx[k] + ptm(1, 2) * yy[k] + ptm(2, 2) * zz[k];
		rowvec P = rmk - ptm.row(0);
		for (int j = 0;j < 4;j++) {
			rowvec rnj(3);
			rnj(0) = ptn(0, 0) * xx[j] + ptn(1, 0) * yy[j] + ptn(2, 0) * zz[j];
			rnj(1) = ptn(0, 1) * xx[j] + ptn(1, 1) * yy[j] + ptn(2, 1) * zz[j];
			rnj(2) = ptn(0, 2) * xx[j] + ptn(1, 2) * yy[j] + ptn(2, 2) * zz[j];
			rowvec Q = rnj - ptn.row(0);
			double R = getDist(rmk, rnj);
			Z += ww[k] * ww[j] * (getDot(P, Q) - 4. / (k0 * k0)) * exp(-J * k0 * R) / R;
		}
	}

代码与公式的联系比较直观。 r m k rmk rmk和 r n j rnj rnj为3列的行矩阵，储存的便是上面公式中的 r m k r_{mk} rmk​ r n j r_{nj} rnj​；而 P P P和 Q Q Q分别为 ( r m k − p m 1 ) (r_{mk}-p_{m1}) (rmk​−pm1​)与 ( r n j − p n 1 ) (r_{nj} - p_{n1}) (rnj​−pn1​)， R R R即为上式中的 ∣ r m k − r n j ∣ |r_{mk}-r_{nj}| ∣rmk​−rnj​∣。

二、奇异积分

由 Z m n + − Z_{mn}^{+-} Zmn+−​的公式就可以看到，它的计算其实就是每次从四个三角单元里面拎出来两个进行运算的过程，而当被拎出来的两个三角单元为同一个三角形时，就会出现奇异问题，这时就要进行相应的奇异积分。
在这里插入图片描述
上式即为奇异值的计算公式。下面来说明一下各符号的含义：

  1. l m 、 l n l_m、l_n lm​、ln​和 w k w_k wk​等符号与上一节的一致；
  2. R R R也为上一节中的 ∣ r m k − r n j ∣ |r_{mk}-r_{nj}| ∣rmk​−rnj​∣；
  3. A n A_n An​为 n n n边所对应的三角单元面积， r n c r_{nc} rnc​为 n n n边所对应的三角单元中心；
  4. P 、 R P、R P、R和 l l l的公式见下面代码。
核心代码：
for (int k = 0;k < 7;k++) {
		rowvec rmk(3);
		rmk(0) = ptm(0, 0) * xxx[k] + ptm(1, 0) * yyy[k] + ptm(2, 0) * zzz[k];
		rmk(1) = ptm(0, 1) * xxx[k] + ptm(1, 1) * yyy[k] + ptm(2, 1) * zzz[k];
		rmk(2) = ptm(0, 2) * xxx[k] + ptm(1, 2) * yyy[k] + ptm(2, 2) * zzz[k];
		rowvec P = rmk - ptm.row(0);
		Complex temp1, temp2;
		temp1 = 0;
		for (int j = 0;j < 7;j++) {
			rowvec rnj(3);
			rnj(0) = ptn(0, 0) * xxx[j] + ptn(1, 0) * yyy[j] + ptn(2, 0) * zzz[j];
			rnj(1) = ptn(0, 1) * xxx[j] + ptn(1, 1) * yyy[j] + ptn(2, 1) * zzz[j];
			rnj(2) = ptn(0, 2) * xxx[j] + ptn(1, 2) * yyy[j] + ptn(2, 2) * zzz[j];
			rowvec Q = rnj - ptn.row(0);
			double R = getDist(rmk, rnj);
			temp1 += www[j] * (getDot(P, Q) - 4. / (k0 * k0)) *
				(-k0 * k0 * R / 2. + J * k0 / 6. * (k0 * k0 * R * R - 6));
		}
		temp2 = 0;
		for (int j = 0;j < 3;j++) {
			rowvec lj(3);
			rowvec nj0(3);
			lj = getUnit(ptn.row((j + 1) % 3) - ptn.row(j));
			nj0 = ptn.row(j) + lj * getDot(rmk - ptn.row(j), lj);
			double lmj = getDot(ptn.row(j) - rmk, lj);
			double lpj = getDot(ptn.row((j + 1) % 3) - rmk, lj);
			double rmj = getDist(rmk, ptn.row(j));
			double rpj = getDist(rmk, ptn.row((j + 1) % 3));
			double pj0 = getDist(nj0, rmk);
			if (pj0 > 1.e-15) {
				temp2 += (getDot(P, ptnc - ptn.row(0)) - 4. / (k0 * k0)) * pj0 * log((rpj + lpj) / (rmj + lmj));
			}
		}
		Z += www[k] * (temp1 + temp2 / (2. * TriArea(n)));
	}

与上一节相似，代码与公式的联系比较紧密，所以这里就不再赘述了。

下面贴上所有代码：
/***********************************************************/
/*            该函数对阻抗矩阵进行填充                      */
/*                                                         */
/***********************************************************/
/*                                                         */
/*             Author：Tianshaowenwen                      */
/*                                                         */
/***********************************************************/
#include <iostream>
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include "rwg2.h"
#include "armadillo"


using namespace arma;
using namespace std;


extern Complex J;
extern mat Edge_list;//[端点1， 端点2， 对点1， 对点2， 左三角单元， 右三角单元]
extern mat TriCenter;
extern vec EdgeLength;
extern vec TriArea;
extern int TriTotal, EdgeTotal;
extern mat pdata, tdata;
extern double k0, Z0, PI;
extern double xx[4];
extern double yy[4];
extern double zz[4];
extern double ww[4];
extern double xxx[7];
extern double yyy[7];
extern double zzz[7];
extern double www[7];

cx_mat Zmn;



void rwg2_main() {
	rwg1_main();
	complex<double> Zll, Zlr, Zrl, Zrr;
	int ml1, ml2, ml3, mr1, mr2, mr3;
	int nl1, nl2, nl3, nr1, nr2, nr3;
	double lm, ln;
	cx_mat zmn(EdgeTotal, EdgeTotal);
	cout << "\n" << "填充阻抗矩阵..." << endl;
	clock_t start = clock();
	for (int i = 0;i < EdgeTotal;i++) {
		int ml = Edge_list(i, 4);
		int mr = Edge_list(i, 5);
		ml1 = Edge_list(i, 2);
		mr1 = Edge_list(i, 3);
		ml2 = mr3 = Edge_list(i, 0);
		ml3 = mr2 = Edge_list(i, 1);
		lm = EdgeLength(i);
		for (int j = 0;j <= i;j++) {
			int nl = Edge_list(j, 4);
			int nr = Edge_list(j, 5);
			nl1 = Edge_list(j, 2);
			nr1 = Edge_list(j, 3);
			nl2 = nr3 = Edge_list(j, 0);
			nl3 = nr2 = Edge_list(j, 1);
			ln = EdgeLength(j);
			if (ml == nl) {
				Zll = getZmnSingular(ml1, ml2, ml3, nl1, nl2, nl3, nl);
			}
			else {
				Zll = getZmnGeneral(ml1, ml2, ml3, nl1, nl2, nl3);
			}
			if (ml == nr) {
				Zlr = getZmnSingular(ml1, ml2, ml3, nr1, nr2, nr3, nr);
			}
			else {
				Zlr = getZmnGeneral(ml1, ml2, ml3, nr1, nr2, nr3);
			}
			if (mr == nl) {
				Zrl = getZmnSingular(mr1, mr2, mr3, nl1, nl2, nl3, nl);
			}
			else {
				Zrl = getZmnGeneral(mr1, mr2, mr3, nl1, nl2, nl3);
			}
			if (mr == nr) {
				Zrr = getZmnSingular(mr1, mr2, mr3, nr1, nr2, nr3, nr);
			}
			else {
				Zrr = getZmnGeneral(mr1, mr2, mr3, nr1, nr2, nr3);
			}
			zmn(i, j) = J * k0 * Z0 * lm * ln * (Zll + Zrr - Zlr - Zrl) / (4 * PI);
			if (i != j) {
				zmn(j, i) = zmn(i, j);
			}
		}
	}
	clock_t end = clock();
	cout << "\n" << "阻抗矩阵填充时间： " << (end - start) / 1000.0 << "s" << endl;
	zmn = luDcmp(zmn);
	/*zmn.save("Zmn.txt", raw_ascii);*/
	Zmn = zmn;
}

/***********************************************************/
/*            Function：Complex getZmnSingular()           */
/***********************************************************/
/* 1.计算三角单元奇异积分                                   */
/***********************************************************/
Complex getZmnSingular(int m1, int m2, int m3, int n1, int n2, int n3, int n) {
	Complex Z = 0;
	mat ptm(3, 3), ptn(3, 3);
	ptm.row(0) = pdata.row(m1);
	ptm.row(1) = pdata.row(m2);
	ptm.row(2) = pdata.row(m3);
	ptn.row(0) = pdata.row(n1);
	ptn.row(1) = pdata.row(n2);
	ptn.row(2) = pdata.row(n3);
	rowvec ptnc = TriCenter.row(n);
	for (int k = 0;k < 7;k++) {
		rowvec rmk(3);
		rmk(0) = ptm(0, 0) * xxx[k] + ptm(1, 0) * yyy[k] + ptm(2, 0) * zzz[k];
		rmk(1) = ptm(0, 1) * xxx[k] + ptm(1, 1) * yyy[k] + ptm(2, 1) * zzz[k];
		rmk(2) = ptm(0, 2) * xxx[k] + ptm(1, 2) * yyy[k] + ptm(2, 2) * zzz[k];
		rowvec P = rmk - ptm.row(0);
		Complex temp1, temp2;
		temp1 = 0;
		for (int j = 0;j < 7;j++) {
			rowvec rnj(3);
			rnj(0) = ptn(0, 0) * xxx[j] + ptn(1, 0) * yyy[j] + ptn(2, 0) * zzz[j];
			rnj(1) = ptn(0, 1) * xxx[j] + ptn(1, 1) * yyy[j] + ptn(2, 1) * zzz[j];
			rnj(2) = ptn(0, 2) * xxx[j] + ptn(1, 2) * yyy[j] + ptn(2, 2) * zzz[j];
			rowvec Q = rnj - ptn.row(0);
			double R = getDist(rmk, rnj);
			temp1 += www[j] * (getDot(P, Q) - 4. / (k0 * k0)) *
				(-k0 * k0 * R / 2. + J * k0 / 6. * (k0 * k0 * R * R - 6));
		}
		temp2 = 0;
		for (int j = 0;j < 3;j++) {
			rowvec lj(3);
			rowvec nj0(3);
			lj = getUnit(ptn.row((j + 1) % 3) - ptn.row(j));
			nj0 = ptn.row(j) + lj * getDot(rmk - ptn.row(j), lj);
			double lmj = getDot(ptn.row(j) - rmk, lj);
			double lpj = getDot(ptn.row((j + 1) % 3) - rmk, lj);
			double rmj = getDist(rmk, ptn.row(j));
			double rpj = getDist(rmk, ptn.row((j + 1) % 3));
			double pj0 = getDist(nj0, rmk);
			if (pj0 > 1.e-15) {
				temp2 += (getDot(P, ptnc - ptn.row(0)) - 4. / (k0 * k0)) * pj0 * log((rpj + lpj) / (rmj + lmj));
			}
		}
		Z += www[k] * (temp1 + temp2 / (2. * TriArea(n)));
	}
	return Z;
}

/***********************************************************/
/*            Function：Complex getZmnGeneral()            */
/***********************************************************/
/* 1.计算三角单元非奇异积分                                 */
/***********************************************************/
Complex getZmnGeneral(int m1, int m2, int m3, int n1, int n2, int n3) {
	Complex Z = 0;
	mat ptm(3, 3), ptn(3, 3);
	ptm.row(0) = pdata.row(m1);
	ptm.row(1) = pdata.row(m2);
	ptm.row(2) = pdata.row(m3);
	ptn.row(0) = pdata.row(n1);
	ptn.row(1) = pdata.row(n2);
	ptn.row(2) = pdata.row(n3);
	for (int k = 0;k < 4;k++) {
		rowvec rmk(3);
		rmk(0) = ptm(0, 0) * xx[k] + ptm(1, 0) * yy[k] + ptm(2, 0) * zz[k];
		rmk(1) = ptm(0, 1) * xx[k] + ptm(1, 1) * yy[k] + ptm(2, 1) * zz[k];
		rmk(2) = ptm(0, 2) * xx[k] + ptm(1, 2) * yy[k] + ptm(2, 2) * zz[k];
		rowvec P = rmk - ptm.row(0);
		for (int j = 0;j < 4;j++) {
			rowvec rnj(3);
			rnj(0) = ptn(0, 0) * xx[j] + ptn(1, 0) * yy[j] + ptn(2, 0) * zz[j];
			rnj(1) = ptn(0, 1) * xx[j] + ptn(1, 1) * yy[j] + ptn(2, 1) * zz[j];
			rnj(2) = ptn(0, 2) * xx[j] + ptn(1, 2) * yy[j] + ptn(2, 2) * zz[j];
			rowvec Q = rnj - ptn.row(0);
			double R = getDist(rmk, rnj);
			Z += ww[k] * ww[j] * (getDot(P, Q) - 4. / (k0 * k0)) * exp(-J * k0 * R) / R;
		}
	}
	return Z;
}
/***********************************************************/
/*            Function：cx_mat luDcmp(cx_mat zmn)          */
/***********************************************************/
/* 1.对复矩阵进行LU分解                                     */
/***********************************************************/
cx_mat luDcmp(cx_mat zmn) {
	int i, j, k;
	Complex dum, sum, temp;
	for (j = 0;j < EdgeTotal;j++) {
		for (i = 0;i < j;i++) {
			sum = zmn(i, j);
			for (k = 0;k < i;k++) {
				sum -= zmn(i, k) * zmn(k, j);
			}
			zmn(i, j) = sum;
		}
		for (i = j;i < EdgeTotal;i++) {
			sum = zmn(i, j);
			for (k = 0;k < j;k++) {
				sum -= zmn(i, k) * zmn(k, j);
			}
			zmn(i, j) = sum;
		}
		if ((zmn(j, j).real() < 1.e-20) && (zmn(j, j).real() > -1.e-20) &&
			(zmn(j, j).imag() < 1.e-20) && (zmn(j, j).imag() > -1.e-20)) {
			zmn(j, j) = 1.e-20;
		}
		if (j != EdgeTotal) {
			dum = 1.0 / zmn(j, j);
			for (i = j + 1;i < EdgeTotal;i++) {
				zmn(i, j) *= dum;
			}
		}
	}
	return zmn;
}

代码中还包含一部分是对复矩阵的LU分解，这是为了后面解矩阵方程时提高效率。如果你是用已经写好的库函数来解矩阵方程的话，这一部分就可以忽略掉。

clamtian
关注
  • 7
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
矩量法RWG基函数及SWG基函数介绍
小龙徐游的专栏
12-29 8765
矩量法是一种常用的计算方法，使用该方法处理三维散射问题时，RWG基函数和SWG基函数是两种常用的基函数。 RWG和SWG基函数的定义区域如下图所示： RWG 基函数 SWG基函数 RWG基函数主要用于处理面积分，而SWG基函数主要用于处理体积分。下面分别进行详细的介绍：  一. RWG 基函数 RWG基函数是一种面元函数，其定义区域为一对有公共边的三角形。其
MoM(四) 阻抗矩阵填充
范fun的博客
03-06 1147
一、一些函数介绍 1、函数 1、函数原型： 功能：返回一个小于传入参数的最大整数 参数：x为将来被处理的数 返回值：返回不大于x的最大整数 例： 2、 为矩阵表示列相加，表示行相加 二、注意事项 格林函数： 填充阻抗矩阵时，一个 element 三角形 要与其他所有的 element 三角形(包括它自己) 进行格林函数计...
矩量法(MOM)源代码，三角形面元基函数(RWG).rar
09-02
矩量法(MOM)源代码，三角形面元基函数(RWG)
基于RWG基函数和LL基函数的电磁场积分方程矩量法对比 (2009年)
06-05
利用基于Rao-Wihon-Glisson（RWG）基函数和双线性（LL）基函数的矩量法求解了任意形状理想导体目标的电磁场积分方程。通过几个计算实例的比较表明，在相同或类似的计算量的情况下，LL基函数比RWG基函数更为完备地描述实际的电流分布，并具有更高的求解精度和更快的收敛特性；同时，仅需作很小的改动，就可以将基于RwG基函数的矩量法程序改写成基于LL基函数的矩量法程序。
金属介质复合结构通用矩量法原理（三）：典型线性基函数
yongmom的博客
06-06 702
三、典型线性基函数 以下介绍几种典型线性基函数的定义及应用。其中三角基函数用于模拟先结构表面的电流分布；RWG基函数用于模拟表面电流密度分布；连接域基函数用于模拟线面连接处电流密度分布；模式基函数用于模拟波端口上磁流密度分布。 3.1线结构三角基函数 三角基函数定义： 一维电流散度 电流散度为常数，且与线段长度成反比，这就保证了每个基函数上电荷总和为0。 3.2 RWG基函数 RWG基函数定义： RWG的定义式可以看出表面电磁流没有沿着垂直于三角形...
\Matlab实现矩量法计算框形天线的输入阻抗
03-02
\Matlab实现矩量法计算框形天线的输入阻抗
PLATE.rar_MOM_矩量法
07-15
矩量法MOM的程序，程序代码是mathcad的
Hallen_matlabHallen方程对称振子_MOM_矩量法matlab_
10-04
本项目涉及的内容是利用MATLAB的矩量法（Method of Moments, MoM）来求解Hallen方程，以计算对称振子的电流分布和方向图。 首先，我们需要理解Hallen方程。Hallen方程是基于泊松方程的扩展，主要描述了在均匀磁场中...
MOM.rar_MoM 偶极子_matlab矩量法_mom 环_矩量法_计算天线阻抗
09-21
《矩量法在计算天线阻抗中的应用——以MOM.rar为例》 矩量法（Method of Moments，简称MOM）是电磁场计算中的一种重要数值方法，尤其在天线设计、微波工程和射频领域有广泛的应用。本资料“MOM.rar”包含了利用...
zuoye.rar_MOM_波阻抗_矩量法_矩量法 matlab_矩量法 天线 阻抗
09-21
本案例中的“zuoye.rar”压缩包提供了一个使用矩量法（Method of Moments, MOM）计算半波振子天线阻抗的MATLAB实现。下面将详细阐述矩量法、波阻抗以及它们在天线分析中的应用。 矩量法是一种数值电磁学计算方法，...
稀疏估计/压缩感知线性系统求解器：为欠定系统 Ax=y 找到一个稀疏解 x，最多有 2 个非零元素-matlab开发
06-01
sparse_sensing12 - 是函数代码sparse_sensing_example - 展示如何使用它。 x = sparse_sensing12(A,y,epsE) 由 Yoash Levron 教授撰写， 电气工程，以色列理工学院，2014 年 9 月。 此函数使用行数少于列数的矩阵 A 求解欠定方程组 Ax=y。 该函数定位“最稀疏”的解向量 x，即具有最少数量的非零元素的解向量。 如果存在稀疏解决方案，则该函数可以保证找到它。 功能输入： A - 传感矩阵（尺寸 M x N，其中 M<N） y - 已知输出向量（已知测量值的向量，（尺寸 M x 1） epsE - 解决方案的可容忍误差。 如果解向量 x 产生第二个范数大于 epsE 的错误，则该函数会抛出错误消息。 函数输出： x - 估计的稀疏向量（维度 N x 1）。 假设 x 最多有 2 个非零元素。 此
ieee9节点标准算例求其导纳矩阵、阻抗矩阵
11-02
根据三角分解法，利用MATLAB求IEEE标准算例中的009节点导纳矩阵和阻抗矩阵。程序中附有详细说明。当然，稍作修改可以求任意节点的导纳矩阵和阻抗矩阵。对电气专业的毕业设计以及研究生很有用。
RWG 基函数 1982 文献
05-13
RWG 基函数 1982 文献
采用支路追加法生成的节点阻抗矩阵Matlab程序
04-13
通过支路追加法计算节点阻抗矩阵Z，通过与Y的逆对比验证结果正确性，计算例子为标准的case39电力系统。程序带注释。 补充idx_brch；idx_bus文件防止运行出错。
mom.zip_MOM_矩量法_矩量法计算半波阵子
09-21
矩量法（Method of Moments，MOM）是电磁场计算中的一个重要方法，尤其在天线设计和射频工程中广泛应用。这种方法通过将复杂的物理问题转化为矩阵形式的代数方程来求解，使得复杂的电磁问题得以简化。在这个“mom....
【源码】二维偶极子相控阵扫描阻抗仿真
weixin_42825609的博客
11-13 337
用矩量法计算了垂直偶极子相控阵矩形阵列在不同扫描角下的输入阻抗 Evaluates the input impedance of rectangular array of vertical dipoles phased array at various scanning angle using method of moment 该程序基于矩量法分析了二维矩形相控阵在角度（theta,phi）激励下的扫描。 This code is based on the Method of Moments which .
MoM(五)解矩阵方程
范fun的博客
03-11 1116
在阻抗矩阵填充之后，接下来就是解矩阵方程了。后期在补上公式，先上代码。 注意：方程求得解是函数的解。 #pragma once #include<iostream> #include<stdio.h> #include<armadillo> #include<math.h> #include<complex> #include&...
matlab求变量方成,关于MATLAB的电力系统潮流计算程序设计
weixin_42149145的博客
03-24 1112
图3.6 自阻抗和互阻抗的关系同时，在一个网络内各节点之间总是有一定的电和磁的联系。这样在节点i 注入单位电流时，其他任一节点j 上总有电压出现。也就是说，在一般情况互阻抗ji Z 并不等于零，因而阻抗矩阵是一个满矩阵，这是一个很重要的特点。由于网络结构复杂，直接应用式(3.30)计算ii Z 和ij Z 是很困难的。 综合以上所述，阻抗矩阵具有以下特点：(1) 和导纳矩阵一样，阻抗矩阵也是对称矩...
MOM 理论总述
范fun的博客
03-22 3105
一、原理: 矩量法的求解过程主要包括以下四个部分： 区域的离散； 基函数和权函数的选择； 阻抗元素的求解； 方程组的求解。 现有线性算子方程如下： 其中，为线性算子，是已知函数(如激励源)，为未知函数(如电流)。 1、离散化过程 这一过程的主要目的在于将算子方程化为代数方程，其具体步骤如下： <1>...
matlab mom矩量法
最新发布
01-28
MATLAB的Moment（MOM）矩量法是一种用于解决结构力学问题的数值方法。它通过将结构分割为小单元并在每个单元上应用平衡和相容性原理来分析结构的受力情况。通过这种方法，我们可以得到结构内部的应力分布、变形情况以及结构的整体受力情况。 在MATLAB中使用Moment矩量法，首先需要将结构模型进行离散化，将结构分解为若干个小单元，然后利用MATLAB中的矩阵运算和数值计算功能，对每个单元进行受力分析。通过计算每个单元的受力情况，并在整个结构上进行叠加，就可以得到整个结构的受力情况。 MATLAB提供了丰富的矩阵运算和数值计算函数，可以方便地进行Moment矩量法的计算和求解。同时，MATLAB也提供了强大的可视化功能，可以直观地展现结构的受力情况、应力分布和变形情况。 使用MATLAB Moment矩量法能够快速、准确地分析结构的受力情况，可以帮助工程师和研究人员设计和优化结构，确保结构的安全、稳定和可靠性。因此，MATLAB Moment矩量法在工程领域有着广泛的应用和重要的意义。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值