MIDAS
集合
Add3
添加集合
集合
展开
集合1,集合2,集合3,集合4
N1=$NODE.CTS1("0,0,0","0,1,0");
N2=$NODE.CTS1("0,0,0","0,1,0");
N3=$NODE.CTS1("0,0,0","0,1,0");
N4=$NODE.CTS1("0,0,0","0,1,0");
return $MIDAS.Add3(N1,N2,N3,N4);
测试
MIDAS
文件操作
NewFile
新文件
bool
展开
$MIDAS.NewFile();
测试
MIDAS
文件操作
SaveAs
文件另存C盘Temp文件夹
bool
展开
$MIDAS.SaveAs();
测试
MIDAS
集合
Add1
添加集合
集合
展开
集合1,集合2
N1=$NODE.CTS1("0,0,0","0,1,0");
N2=$NODE.CTS1("0,0,0","0,1,0");
return $MIDAS.Add1(N1,N2);
测试
MIDAS
集合
Add2
添加集合
集合
展开
集合1,集合2,集合3
N1=$NODE.CTS1("0,0,0","0,1,0");
N2=$NODE.CTS1("0,0,0","0,1,0");
N3=$NODE.CTS1("0,0,0","0,1,0");
return $MIDAS.Add2(N1,N2,N3);
测试
MIDAS
集合
Add4
添加集合
集合
展开
集合1,集合2,集合3,集合4,集合5
N1=$NODE.CTS1("0,0,0","0,1,0");
N2=$NODE.CTS1("0,0,0","0,1,0");
N3=$NODE.CTS1("0,0,0","0,1,0");
N4=$NODE.CTS1("0,0,0","0,1,0");
N5=$NODE.CTS1("0,0,0","0,1,0");
return $MIDAS.Add3(N1,N2,N3,N4,N5);
测试
UNIT
单位
CTS
修改单位
无意义
展开
力的单位默认KN,距离单位默认M,热量单位默认KJ,温度单位默认C
$UNIT.CTS();
测试
MATL
材料
CTBar1080
创建Steelbar1080
材料号
展开
材料名称默认Steelbar1080
$MATL.CTBar1080();
测试
MATL
材料
CTQ235
创建Q235
材料号
展开
材料名称默认Q235
$MATL.CTQ235();
测试
MATL
材料
CTQ345
创建Q345
材料号
展开
材料名称默认Q345
$MATL.CTQ345();
测试
MATL
材料
CTQ420
创建Q420
材料号
展开
材料名称默认Q420
$MATL.CTQ420();
测试
MATL
材料
CTSteel
创建钢材
材料号
展开
GB50917材料名称(Q235)|Q355|Q390|Q420|Q460|Q345GJ|Q345
$MATL.CTSteel("Q355");
测试
SECT
截面
CSB
创建箱型截面
截面号
展开
名称,高度,宽度,腹板厚度,顶板厚度,腹板间距,底板厚度
$MIDAS.NewFile();
BaseNodes=$NODE.CTS1("0,0,0","0,0,1","0,0,2","0,0,3");
BaseNodes1=$NODE.CTS1("0,2,0","0,2,1","0,2,2","0,2,3");
m=$MATL.CTQ235();
Jdc=$SECT.CTA("柱间连接",“L 63x4”);
jdcbeam=$ELEM.Generate(m,Jdc,0);
x1=$ELEM.ColumnSupportX(BaseNodes,BaseNodes1,jdcbeam);
测试
SECT
截面
CSSB
创建矩形截面
截面号
展开
名称,直径,厚度
$SECT.CSSB("方木",0.048,0.005);
测试
SECT
截面
CT1
创建截面
截面号
展开
截面类型BU/DU/U/H，名称，截面，间隙
$SECT.CT1("BU","a截面","C20a");
$SECT.CT1("DU","b截面","C20b",0.02);
$SECT.CT1("H","C截面","I20b");
$SECT.CT1("U","C截面","C16a");
测试
SECT
截面
CTA
创建角钢
截面号
展开
名称,截面
$SECT.CTA("Angle","L36x5");
测试
SECT
截面
CTBU
创建槽钢盒子
截面号
展开
名称,截面
$SECT.CTBU("A","C16b");
测试
SECT
截面
CTC
创建C截面
截面号
展开
名称,截面
$SECT.CTC("C","C16b");
测试
SECT
截面
CTCC
创建冷轧槽钢截面
截面号
展开
名称,截面
$SECT.CTCC("CC","CC-J 220x75x20x2.2");
测试
SECT
截面
CTDU
创建双C截面
截面号
展开
名称，截面，间隙
$SECT.CTDU("D","C16b",0.02);
测试
SECT
截面
CTH
创建H截面
截面号
展开
名称,截面
$SECT.CTH("H","I20a");
测试
SECT
截面
CTP
创建P截面
截面号
展开
名称,直径,厚度
$SECT.CTP("P48_5",0.048,0.005);
测试
SECT
截面
CTS
创建一组截面
截面号集合
展开
(BU/DU/U/H/CC:名称:截面)
$SECT.CTS("BU:A:C20a","DU:B:C20a:0.02");
测试
SECT
截面
CTSR
创建圆截面
截面号
展开
名称
$SECT.CTSR("SR",0.048);
测试
SECT
截面
CTUserH
创建自定义H型钢截面
截面号
展开
名称，高度，翼缘板，腹板厚度，翼缘板厚度
$SECT.CTUserH("I8",0.08,0.05,0.0065,0.0045);
测试
SECT
截面
GetHeigth
获取截面高度
高度
展开
形式H/B/C,截面名称
var h=$SECT.GetHeigth("H","I20a");
$NODE.CT(0,0,h);
测试
THIK
厚度
CT
创建厚度
厚度号
展开
板厚
N1=$THIK.CT(0.006);
测试
STLD
荷载工况
CTS
创建恒载工况
展开
工况名称,描述
$STLD.CTS("混凝土自重","混凝土");
测试
STLD
荷载工况
CTS1
创建活载工况
展开
工况名称,描述
$STLD.CTS1("施工荷载","人群");
测试
STLD
荷载工况
CTS2
创建用户定义荷载工况
展开
工况名称,描述
$STLD.CTS2("用户定义荷载","小型机具");
测试
NODE
节点
CPAnyS
任意间距拷贝节点
展开
XYZ方向,（5,6@7,8）
N1=$NODE.CTS1("0,0,0","0,1,0");
$NODE.CPAnyS(N1,"Z","5,3@6,8");
测试
NODE
节点
CPS
等距离拷贝节点
节点编号集合
展开
节点编码集合，方向XYZ,距离，次数
N1=$NODE.CTS1("1,2,3","2,4,5");
$NODE.CPS(N1,"Y",1,10);
测试
NODE
节点
CT
创建节点
节点编号
展开
x坐标，y坐标，z坐标
N1=$NODE.CT(5,6,7);
/*创建点集合,可多个参数*/
NS=CArray.ToIT(N1);
$NODE.CPS(NS,"Y",1,10);
测试
NODE
节点
CTByVirtual
虚拟点拷贝
节点集合
展开
基准点号,待移动的点集合,x偏移,y偏移,z偏移
function sin(x){
var z=Math.sin(x);
return {X: x,Y: 0,Z: z};
}
n=$NODE.GenerateNodesByCurve1(sin,0,3.1415,10);
self=$NODE.CT(1,1,2);
$NODE.CTByVirtual(self,n,0,0,-1);
测试
NODE
节点
CTByVirtualZero
虚拟曲线拷贝
节点集合
展开
点号,待移动的点集合,虚拟坐标轴参考原点
function sin(x){
var z=Math.sin(x);
return {X: x,Y: 0,Z: z};
}
n=$NODE.GenerateNodesByCurve1(sin,0,2*3.1415,100);
$NODE.CTByVirtualZero(n);
测试
NODE
节点
CTS1
创建多个节点
节点编号集合
展开
[x，y，z]
B=5;H=3;
/*`0,0,${H}`是字符串中的一种变量替换方式*/
$NODE.CTS1("0,0,0",`0,0,${H}`,`${B},0,${H}`)
测试
NODE
节点
Divide
分割点间距
包含起点和终点的节点编码
展开
起点号，终点号，数量
NS=$NODE.CTS1("0,0,0","0,0,8");
/*数组的索引，从0开始*/
NSD=$NODE.Divide(NS[0],NS[1],8);
/*返回值包含起止点号*/
$GRUP.AddNodeS("合并成一个组",NSD);
测试
NODE
节点
DivideUp
按照距离分割向上取整
节点编码集合
展开
起点号，终点号，距离
NS=$NODE.CTS1("0,0,0","0,0,1");
/*数组的索引，从0开始*/
NSD=$NODE.DivideUp(NS[0],NS[1],0.3);
/*返回值包含起止点号*/
/*1分割为0.3一段，需要分成4段，每段长度0.25*/
$GRUP.AddNodeS("合并成一个组",NSD);
测试
NODE
节点
Find
查找节点相关信息
点信息采用属性操作符"."取值
展开
节点号
NS=$NODE.CTS1("0,0,0","0,3,0","1,0,0","1,1,0","0,0,1","0,1,1","1,0,1","1,1,1");
return($NODE.Find(2));
测试
NODE
节点
FindProjection
查找投影面对应的点位
投影面(轴)x|y|z|xy|xz|yz,投影面值,投影轴值
展开
节点编码集合
$MIDAS.NewFile();
NS=$NODE.CTS1("8,0,0","9,0,0","3,0,0","4,0,0");
NS2=$NODE.CTS1("8,1,0","9,1,0","3,1,0","4,2,0","4,2,0");
NS3=$NODE.CTS1("8,1,1","9,1,1","3,1,0","4,1,1");
$GRUP.AddNodeS("NS在y=1面上的投影",$NODE.FindProjection(NS,"Y",1,0));
$GRUP.AddNodeS("NS在y=1，Z=1轴上的投影",$NODE.FindProjection(NS,"yz",1,1));
测试
NODE
节点
GenerateNodesByCurve1
等坐标分割曲线
创立的虚拟节点集合
展开
一个参数的自定义函数，起点参数，终点参数,等次数分割
$MIDAS.NewFile();
m=$MATL.CTQ235();
s=$SECT.CTH("H梁","I20a");
function sin(x){
var z=Math.sin(x);
return {X: x,Y: 0,Z: z};
}
vir=$NODE.GenerateNodesByCurve1(sin,0,3.1415,10);
n=$NODE.CTByVirtualZero(vir);
$ELEM.CT4(n,m,s,0);
测试
NODE
节点
GenerateNodesByCurve2
等坐标分割曲线
创立的虚拟节点集合
展开
二个参数的自定义函数，起点参数，终点参数,分割次数
$MIDAS.NewFile();
m=$MATL.CTQ235();
s=$SECT.CTH("H梁","I20a");
function sin(a,x){
var z=a*Math.sin(x);
return {X: x,Y: 0,Z: z};
}
vir=$NODE.GenerateNodesByCurve2(sin,3,0,3.1415,10);
n=$NODE.CTByVirtualZero(vir);
$ELEM.CT4(n,m,s,0);
测试
NODE
节点
GenerateNodesByCurve3
等坐标分割曲线
创立的虚拟节点集合
展开
三个参数的自定义函数，起点参数，终点参数,分割次数
$MIDAS.NewFile();
m=$MATL.CTQ235();
s=$SECT.CTH("H梁","I20a");
function sin(a,b,x){
var z=a*Math.sin(x)+b;
return {X: x,Y: 0,Z: z};
}
vir=$NODE.GenerateNodesByCurve3(sin,3,5,0,3.1415,10);
n=$NODE.CTByVirtualZero(vir);
$ELEM.CT4(n,m,s,0);
测试
NODE
节点
GenerateNodesByCurve4
等坐标分割曲线
创立的虚拟节点集合
展开
四个参数的自定义函数，起点参数，终点参数,分割次数
$MIDAS.NewFile();
m=$MATL.CTQ235();
s=$SECT.CTH("H梁","I20a");
function sin(a,b,c,x){
var z=a*Math.sin(x)+b;
var y=a*Math.cos(x)+c;
return {X: x,Y:y,Z: z};
}
vir=$NODE.GenerateNodesByCurve4(sin,3,5,1,0,3.1415,10);
n=$NODE.CTByVirtualZero(vir);
$ELEM.CT4(n,m,s,0);
测试
NODE
节点
GenerateNodesByCurveDis
按照坐标等距离分割
虚拟节点集合
展开
一个参数的自定义函数，起点，终点,分割距离
function sin(x){
var z=Math.sin(x);
return {X: x,Y: 0,Z: z};
}
n=$NODE.GenerateNodesByCurveDis(sin,0,3.1415,0.1);
$NODE.CTByVirtualZero(n);
测试
NODE
节点
GenerateNodesByCurveDis1
按照弧长分割曲线
虚拟点集合
展开
一个参数的自定义函数，起点参数，终点参数,分割距离
$MIDAS.NewFile();
function sin(x){
var z=Math.sin(x);
return {X: x,Y: 0,Z: z};
}
n=$NODE.GenerateNodesByCurveDis1(sin,0,3.1415,0.1);
$NODE.CTByVirtualZero(n);
测试
NODE
节点
GenerateNodesByCurveDis2
按照弧长分割曲线
分割虚拟点集合
展开
二个参数的自定义函数，起点参数，终点参数,分割距离
$MIDAS.NewFile();
function sin(a,x){
var z=a*Math.sin(x);
return {X: x,Y: 0,Z: z};
}
n=$NODE.GenerateNodesByCurveDis2(sin,2,0,3.1415,0.1);
$NODE.CTByVirtualZero(n);
测试
NODE
节点
GenerateNodesByCurveDis3
按照弧长分割曲线
分割虚拟点集合
展开
三个参数的自定义函数，起点参数，终点参数,分割距离
$MIDAS.NewFile();
function sin(a,b,x){
var z=a*Math.sin(x)+b;
return {X: x,Y: 0,Z: z};
}
n=$NODE.GenerateNodesByCurveDis3(sin,2,3,0,3.1415,0.1);
$NODE.CTByVirtualZero(n);
测试
NODE
节点
GenerateNodesByCurveDis4
按照弧长分割曲线
分割虚拟点集合
展开
四个参数的自定义函数，起点参数，终点参数,分割距离
$MIDAS.NewFile();
function sin(a,b,c,x){
var z=a*Math.sin(x)+b;
var y=a*Math.sin(x)+c;
return {X: x,Y: y,Z: z};
}
n=$NODE.GenerateNodesByCurveDis4(sin,2,2,4,0,3.1415,0.1);
$NODE.CTByVirtualZero(n);
测试
NODE
节点
GenerateNodesByCurveNumber1
将曲线等距离(弧长)分割
创立的节点号
展开
一个参数的自定义函数，起点参数，终点参数,分割距离
function sin(x){
var z=Math.sin(x);
return {X: x,Y: 0,Z: z};
}
n=$NODE.GenerateNodesByCurveNumber1(sin,0,3.1415,10);
$NODE.CTByVirtualZero(n);
测试
NODE
节点
GenerateNodesByCurveNumber2
将曲线等距离(弧长)分割
虚拟点集合
展开
二个参数的自定义函数，参数1,起点参数，终点参数,分割距离
$MIDAS.NewFile();
function sin(a,x){
var z=a*Math.sin(x);
return {X: x,Y: 0,Z: z};
}
n=$NODE.GenerateNodesByCurveNumber2(sin,2,0,3.1415,10);
$NODE.CTByVirtualZero(n);
测试
NODE
节点
GenerateNodesByCurveNumber3
按照弧长分割曲线
分割虚拟点集合
展开
三个参数的自定义函数，起点参数，终点参数,分割距离
$MIDAS.NewFile();
function sin(a,b,x){
var z=a*Math.sin(x)+b;
return {X: x,Y: 0,Z: z};
}
n=$NODE.GenerateNodesByCurveNumber3(sin,2,0,3.1415,0.1);
$NODE.CTByVirtualZero(n);
测试
NODE
节点
GenerateNodesByCurveNumber4
将曲线等距离(弧长)分割
虚拟点集合
展开
四个参数的自定义函数，参数1，参数2，参数3，起点参数，终点参数,分割距离
$MIDAS.NewFile();
function sin(a,b,c,x){
var z=a*Math.sin(x)+b;
var y=a*Math.sin(x)+c;
return {X: x,Y:y,Z:z};
}
n=$NODE.GenerateNodesByCurveNumber4(sin,2,3,5,0,3.1415,10);
$NODE.CTByVirtualZero(n);
测试
NODE
节点
Get
查找节点
节点编号集合
展开
"XZ:5.2,Y:25,Z:5.9"
NS=$NODE.CTS1("0,0,0","0,1,0","1,0,0","1,1,0","0,0,1","0,1,1","1,0,1","1,1,1");
SP=$GRUP.AddNodeS("水平面",$NODE.Get("Z:0"));
SP2=$GRUP.AddNodeS("Y面",$NODE.Get("X:0"));
SP3=$GRUP.AddNodeS("X面",$NODE.Get("Y:0"));
SP4=$GRUP.AddNodeS("X面,Z轴",$NODE.Get("Y:0,Z:1"));
测试
NODE
节点
GetBySelectNodes
通过选择点查找
节点编号集合
展开
节点集合,"XZ:5.2,Y:25,Z:5.9"
NS=$NODE.CTS1("0,0,0","0,1,0","1,0,0","1,1,0","0,0,1","0,1,1","1,0,1","1,1,1");
SP=$GRUP.AddNodeS("水平面",$NODE.GetBySelectNodes(NS,"Z:0"));
SP2=$GRUP.AddNodeS("Y面",$NODE.GetBySelectNodes(NS,"X:0"));
SP3=$GRUP.AddNodeS("X面",$NODE.GetBySelectNodes(NS,"Y:0"));
SP4=$GRUP.AddNodeS("X面,Z轴",$NODE.GetBySelectNodes(NS,"Y:0,Z:1"));
测试
NODE
节点
GetNodesAtIntervals
获取间隔数量的点
点的集合
展开
点的集合,间距,包含起点(0|1),反向旋转(1|0)
NS=$NODE.CTS1("0,0,0","0,1,0","1,0,0","1,1,0","0,0,1","0,1,1","1,0,1","1,1,1");
return($NODE.GetNodesAtIntervals(NS,2));
/*不包含起点*/
return($NODE.GetNodesAtIntervals(NS,2,1));
/*反向选择*/
return($NODE.GetNodesAtIntervals(NS,2,0,1));
测试
NODE
节点
GetStartAndEnd
查找起点和终点
包含起点和终点的集合
展开
节点编码集合
NS=$NODE.CTS1("8,0,0","9,0,0","3,0,0","4,0,0");
$GRUP.AddNodeS("起止点",$NODE.GetStartAndEnd(NS));
测试
NODE
节点
Length
计算空间点的累计长度
长度
展开
节点集合
NS=$NODE.CTS1("0,0,0","0,1,0","0,2,0","0,3,0","0,4,1","0,5,1","0,6,1","0,7,1");
return $NODE.Length(NS);
测试
NODE
节点
Sort
节点排序
包含起点和终点的排序后的点集合
展开
节点编码集合,X|Y|Z
NS=$NODE.CTS1("8,0,0","9,0,0","3,0,0","4,0,0");
return $NODE.Sort(NS,"X");
测试
ELEM
元素
ColumnSupportX
柱间X支撑
节点集合
展开
左侧柱节点,右侧柱节点,虚拟单元
$MIDAS.NewFile();
BaseNodes=$NODE.CTS1("0,0,0","0,0,1","0,0,2","0,0,3");
BaseNodes1=$NODE.CTS1("0,2,0","0,2,1","0,2,2","0,2,3");
m=$MATL.CTQ235();
Jdc=$SECT.CTA("Angle","L36x5");
jdcbeam=$ELEM.Generate(m,Jdc,0);
x1=$ELEM.ColumnSupportX(BaseNodes,BaseNodes1,jdcbeam);
测试
ELEM
元素
CopyAny
任意间距拷贝
梁编码集合
展开
梁编码集合，XYZ方向，'7,5@6'，是否赋值单元属性梁端约束0|1
$MIDAS.NewFile();
m=$MATL.CTQ235();
s=$SECT.CTH("H梁","I20a");
n=$NODE.CTS1("0,0,0","1,0,0","2,0,0");
b=$ELEM.CT(n[0],n[1],m,s,0);
b2=$ELEM.CT(n[1],n[2],m,s,0);
$ELEM.CopyAny(CArray.ToIT(b),"Y","5,8@6");
$FRLS.CT(b2,"组1",0,1,0);
$ELEM.CopyAny(CArray.ToIT(b2),"Y","5,8@6",1);
测试
ELEM
元素
CPS
等间距拷贝
梁编码集合
展开
梁编码集合，XYZ方向，距离，次数,是否赋值单元属性梁端约束0/1
m=$MATL.CTQ235();
s=$SECT.CTH("H梁","I20a");
n=$NODE.CTS1("0,0,0","1,0,0");
b=$ELEM.CT(n[0],n[1],m,s,0);
$ELEM.CPS(CArray.ToIT(b),"Y",5,5);
测试
ELEM
元素
CPS2
沿点路径拷贝梁,点在梁上
梁编码集合
展开
梁编码集合，点编码集合, 是否赋值单元属性梁端约束0/1
m=$MATL.CTQ235();
s=$SECT.CTH("H梁","I20a");
n=$NODE.CTS1("0,0,0","1,0,0");
b1=$ELEM.CT(n[0],n[1],m,s,0);
ns=$GRUP.AddNodeS("路径",$NODE.CTS1("0,1,0","0,2,1","0,3,2"));
bs=CArray.ToIT(b1);
$ELEM.CPS2(bs,ns);
测试
ELEM
元素
CPS3
沿点路径方向投影拷贝梁
梁编码集合
展开
梁编码集合，方向，点编码集合
m=$MATL.CTQ235();
s=$SECT.CTH("H梁","I20a");
n=$NODE.CTS1("0,0,0","1,0,0");
b1=$ELEM.CT(n[0],n[1],m,s,0);
ns=$GRUP.AddNodeS("路径",$NODE.CTS1("0,1,0","0,2,1","0,3,2"));
bs=CArray.ToIT(b1);
$ELEM.CPS3(bs,"Z",ns);
测试
ELEM
元素
CT
创建梁
梁编码
展开
起点，终点，材料，截面，梁的旋转角度
m=$MATL.CTQ235();
s=$SECT.CTH("H梁","I20a");
n=$NODE.CTS1("0,0,0","1,0,0");
b=$ELEM.CT(n[0],n[1],m,s,0);
测试
ELEM
元素
CT4
沿点路径方向创建梁
梁编码集合
展开
节点集合，材料，截面，角度，是否闭合(默认0不闭合)
m=$MATL.CTQ235();
s=$SECT.CTH("H梁","I20a");
n=$NODE.CTS1("0,0,0","1,0,0","1,2,4","2,4,5");
$ELEM.CT4(n,m,s,0);
测试
ELEM
元素
CTFromTwoArrays
用虚拟梁将两组节点数组连接
创建梁编号
展开
起点节点编号，终点节点编号，虚拟梁
m=$MATL.CTQ235();
s=$SECT.CTH("H梁","I20a");
b=$ELEM.Generate(m,s,0);
L1=$NODE.CTS1("0,0,0","0,1,0");
L2=$NODE.CTS1("0,0,1","0,1,1");
v=$ELEM.CTFromTwoArrays(L1,L2,b);
测试
ELEM
元素
CTPlane
从四个点创建板单元
展开
厚度号，材料号,P1点号，P2点号，P3点号，P4点号
C=$THIK.CT(0.006);
m=$MATL.CTQ235();
n=$NODE.CTS1("0,0,0","1,0,0","1,1,0","0,1,0");
B=$ELEM.CTPlane(C,m,n[0],n[1],n[2],n[3]);
测试
ELEM
元素
CTPlaneS1
从一组水平面点中创建板单元
展开
水平面点集合，厚度号，材料号
C=$THIK.CT(0.006);
m=$MATL.CTQ235();
n=$NODE.CTS1("0,0,0","1,0,0","1,1,0","0,1,0","2,0,0","2,1,0");
v=$ELEM.CTPlaneS1(n,C,m);
测试
ELEM
元素
CTPlaneS2
根据二维数组创建板单元
单元集合
展开
节点编码二维数组集合(CArray.ToListInt)，截面，材料
$MIDAS.NewFile();
var Ls=[];
n1=$NODE.CTS1(`0,0,0`,`0,1,0`,`0,2,0`);
n2=$NODE.CTS1(`1,0,0`,`1,1,0`,`1,2,0`);
Ls.push(n1);
Ls.push(n2);
$ELEM.CTPlaneS2(CArray.ToListInt(Ls),1,1);
测试
ELEM
元素
CTS1
创建梁，在节点处断开
梁编码
展开
起点，终点，材料，截面，梁的旋转角度
m=$MATL.CTQ235();
s=$SECT.CTH("H梁","I20a");
n=$NODE.CTS1("0,0,0","1,0,0","2,0,0");
B=$ELEM.CTS1(n[0],n[2],m,1,0);
测试
ELEM
元素
CTS2
创建多梁
梁编码
展开
'起点，终点，材料，截面，梁的旋转角度','起点，终点，材料，截面，梁的旋转角度'
$MIDAS.NewFile();
var times=2;
$UNIT.CTS();
Q235=$MATL.CTQ235();
Q345=$MATL.CTQ345();
I8=$SECT.CTUserH("I8",0.08,0.05,0.0065,0.0045);
C10_2=$SECT.CTDU("2C10","C10.0",0.08);
LSect=$SECT.CTA("支撑架竖杆","L 45x4");
XSect=$SECT.CTA("支撑架斜杆","L 25x4");
xgnodes=$NODE.CTS1("0,0,0","0.09,0,0","0.795,0,0","1.5,0,0","2.205,0,0","2.91,0,0","3,0,0");
fgnodes=$NODE.CTS1("0.09,0,0.11","0.09,0,0.7","0.09,0,1.29","1.5,0,0.7","2.91,0,0.11","2.91,0,0.7","2.91,0,1.29");
xgbeams=$GRUP.AddElemS("贝雷片弦杆",$ELEM.CTS1(xgnodes[0],xgnodes[6],Q345,C10_2,0));
xgbeams=$GRUP.AddNodeS("贝雷片弦杆",xgnodes);
sgbeams=$ELEM.CPS($GRUP.GetElemS("贝雷片弦杆"),"z",1.4,1);
copynodes=$GRUP.Add("贝雷片上弦杆",$ELEM.GetNodeS1(sgbeams),sgbeams);
$GRUP.AddElemS("竖杆",$ELEM.CTS2(`2,16,${Q345},${I8},90`,`4,18,${Q345},${I8},90`,`6,20,${Q345},${I8},90`));
I8S=$ELEM.CTS2(`9,17,${Q345},${I8},90`,`9,3,${Q345},${I8},90`,`11,17,${Q345},${I8},90`,`11,3,${Q345},${I8},90`,`11,19,${Q345},${I8},90`,`11,5,${Q345},${I8},90`,`13,19,${Q345},${I8},90`,`13,5,${Q345},${I8},90`);
测试
ELEM
元素
CTS3
创建多梁(废弃)
梁编码
展开
'起点，终点，材料，截面，梁的旋转角度','起点，终点，材料，截面，梁的旋转角度'
测试
ELEM
元素
Generate
创建虚拟梁
虚拟梁
展开
材料，截面，梁的旋转角度
m=$MATL.CTQ235();
s=$SECT.CTH("H梁","I20a");
return $ELEM.Generate(m,s,0);
测试
ELEM
元素
GetAngle
获取线段的法向转角
转角集合
展开
梁的编号集合，平面
m=$MATL.CTQ235();
s=$SECT.CTH("H梁","I20a");
n=$NODE.CTS1("0,0,0","0,1,0","0,2,4","0,4,5");
beams=$ELEM.CT4(n,m,s,0);
return $ELEM.GetAngle(beams,"yz");
测试
ELEM
元素
GetEndNodeS
获取梁的终点
节点集合
展开
梁编码
m=$MATL.CTQ235();
s=$SECT.CTH("H梁","I20a");
n=$NODE.CTS1("0,0,0","1,0,0");
b=$ELEM.CT(n[0],n[1],m,s,0);
$GRUP.AddNodeS("全部梁的终点",$ELEM.GetEndNodeS($ELEM.CPS(CArray.ToIT(b),"Y",5,5)));
测试
ELEM
元素
GetNodeS
获取节点
节点集合
展开
梁单元编码
n=$NODE.CTS1("0,0,0","1,0,0");
B=$ELEM.CT(n[0],n[1],1,1,0);
b=$GRUP.AddNodeS("结果",$ELEM.GetNodeS(B));
测试
ELEM
元素
GetNodeS1
获取节点
节点集合
展开
梁单元编码集合
n=$NODE.CTS1("0,0,0","1,0,0","0,1,0","1,1,0");
B1=$ELEM.CT(n[0],n[1],1,1,0);
B2=$ELEM.CT(n[2],n[3],1,1,0);
BS=CArray.ToIT(B1,B2);
b=$GRUP.AddNodeS("结果",$ELEM.GetNodeS1(BS));
测试
ELEM
元素
GetStartNodeS
获取梁的起点
节点集合
展开
梁编码
m=$MATL.CTQ235();
s=$SECT.CTH("H梁","I20a");
n=$NODE.CTS1("0,0,0","1,0,0");
b=$ELEM.CT(n[0],n[1],m,s,0);
$GRUP.AddNodeS("全部梁的起点",$ELEM.GetStartNodeS($ELEM.CPS(CArray.ToIT(b),"Y",5,5)));
测试
ELEM
元素
OffsetPoint
偏移梁
梁编码集合
展开
梁编码集合，距离,局部坐标轴方向(YZ(0)|XZ(1)|XY(2))
m=$MATL.CTQ235();
s=$SECT.CTH("H梁","I20a");
n=$NODE.CTS1("1,1,0","0,0,1");
b=$ELEM.CT(n[0],n[1],m,s,0);
bs=$ELEM.CopyAny(CArray.ToIT(b),"Z","5,8@6");
bs.Add(b);
cs= $ELEM.OffsetPoint(bs,5,1);
测试
ELEM
元素
OffsetShapeGetNodes
偏移梁获取虚拟点
梁编码集合
展开
梁编码集合，距离
m=$MATL.CTQ235();
s=$SECT.CTH("H梁","I20a");
n=$NODE.CTS1("0,0,0","0,-1,0","1,1,0");
bs=$ELEM.CTS2(`1,2,1,1,0`,`2,3,1,1,0`,`3,1,1,1,0`);
cs=$NODE.CTByVirtualZero($ELEM.OffsetShapeGetNodes(bs,1));
ems=$ELEM.CT4(cs,1,1,0,0);
测试
ELEM
元素
OffsetShapeGetNodesPart
偏移梁获取虚拟点
梁编码集合
展开
梁编码集合，距离,拟偏移点集合
m=$MATL.CTQ235();
s=$SECT.CTH("H梁","I20a");
n=$NODE.CTS1("0,0,0","0,-1,0","1,1,0");
bs=$ELEM.CTS2(`1,2,1,1,0`,`2,3,1,1,0`,`3,1,1,1,0`);
n.Remove(1);
cs=$NODE.CTByVirtualZero($ELEM.OffsetShapeGetNodesPart(bs,1,n));
ems=$ELEM.CT4(cs,1,1,0,1);
测试
CONS
边界
CTS
创建边界
展开
节点编码集合，组名称默认为空
N=$NODE.CTS1("0,0,0","1,0,0");
N2=$NODE.CTS1("2,0,0","3,0,0");
$CONS.CTS(N,"1110000");
$CONS.CTS(N2,"0001110");
测试
CONS
边界
CTS1
创建边界
展开
节点编码字符[1,2]，组名称默认为空
N=$NODE.CTS1("0,0,0","1,0,0");
N2=$NODE.CTS1("2,0,0","3,0,0");
$CONS.CTS1("[1,2]","1110000");
$CONS.CTS1("[3,4]","0001110");
测试
ELNK
弹性连接
CPS
根据节点拷贝弹性连接
展开
弹性连接编号,方向XYZ,节点编号集合
N=$NODE.CTS1("0,0,0","0,0,1"); N2=$NODE.CTS1("2,0,0","3,0,0","2,0,1","3,0,1");
E1=$ELNK.CT2(N[0],N[1]);
$ELNK.CPS(E1,"X",N2);
测试
ELNK
弹性连接
CPS1
根据节点拷贝弹性连接
展开
弹性连接编号集合,方向XYZ,节点编号集合
P1=$NODE.CTS1("0,0,0","0,1,0","1,1,0","2,1,0","2,2,0");
P2=$NODE.CTS1("0,0,1","0,1,1","1,1,1","2,1,1","2,2,1");
E1=$ELNK.CT5(P1[0],P2[0],0,"弹性连接1");
$ELNK.CPS1(CArray.ToIT(E1),"Y",P1);
测试
ELNK
弹性连接
CPS2
根据任意距离拷贝弹性连接
展开
弹性连接编号集合,方向XYZ,间距
P1=$NODE.CTS1("0,0,0","0,1,0","1,1,0","2,1,0","2,2,0");
P2=$NODE.CTS1("0,0,1","0,1,1","1,1,1","2,1,1","2,2,1");
E1=$ELNK.CT5(P1[0],P2[0],0,"弹性连接1");
$ELNK.CPS2(CArray.ToIT(E1),"Y","2@1");
测试
ELNK
弹性连接
CT
创建普通弹性连接
展开
起点编号,终点编号,边界组名
N=$NODE.CTS1("0,0,0","0,0,1");
E1=$ELNK.CT(N[0],N[1],"[0,0,0,1,0,0]","[0,0,0,5622,0,0]","Gr");
测试
ELNK
弹性连接
CT2
创建固定连接
展开
起点编号,终点编号,边界组名
N=$NODE.CTS1("0,0,0","0,0,1"); N2=$NODE.CTS1("2,0,0","3,0,0","2,0,1","3,0,1");
E1=$ELNK.CT2(N[0],N[1]);
测试
ELNK
弹性连接
CT3
创建只受拉连接
弹性连接号
展开
起点编号,终点编号,SD数值,边界组名
N=$NODE.CTS1("0,0,0","0,0,1"); N2=$NODE.CTS1("2,0,0","3,0,0","2,0,1","3,0,1");
E1=$ELNK.CT3(N[0],N[1],1000,"只受拉弹性连接");
测试
ELNK
弹性连接
CT4
创建只受压连接
弹性连接号
展开
起点编号,终点编号,SD数值,边界组名
N=$NODE.CTS1("0,0,0","0,0,1"); N2=$NODE.CTS1("2,0,0","3,0,0","2,0,1","3,0,1");
E1=$ELNK.CT4(N[0],N[1],10000,"只受压弹性连接");
测试
ELNK
弹性连接
CT5
创建十字交叉梁的弹性连接
展开
起点编号,重点编号,角度0或1,边界组名,y方向系数默认100000,z方向系数默认100000
P1=$NODE.CTS1("0,0,0","0,1,0","1,1,0","2,1,0","2,2,0");
P2=$NODE.CTS1("0,0,1","0,1,1","1,1,1","2,1,1","2,2,1");
$ELNK.CT5(P1[0],P2[0],0,"弹性连接1");
$ELNK.CT5(P1[1],P2[1],0,"弹性连接2");
$ELNK.CT5(P1[3],P2[3],0,"弹性连接3",20000,20000);
测试
ELNK
弹性连接
CTFromTwoArrays
根据两组数据建立弹性连接
弹性连接集合
展开
起点集合,终点集合,虚拟弹性连接
m=$MATL.CTQ235();
s=$SECT.CTH("H梁","I20a");
n=$NODE.CTS1("0,0,0","0,-1,0","1,1,0");
bs=$ELEM.CTS2(`1,2,1,1,0`,`2,3,1,1,0`,`3,1,1,1,0`);
cs=$NODE.CTByVirtualZero($ELEM.OffsetShapeGetNodes(bs,1));
virual=$ELNK.Generate(4,'','',"连接");
ess=$ELNK.CTFromTwoArrays(n,cs,virual);
ems=$ELEM.CT4(cs,1,1,0,1);
测试
ELNK
弹性连接
CTS6
平面之间点刚性连接
弹性连接集合
展开
第一个平面的全部点,第二个平面的全部点,面的方向XYZ,角度,边界组名
P1=$NODE.CTS1("0,0,0","0,1,0","1,1,0","2,1,0","2,2,0");
P2=$NODE.CTS1("0,0,1","0,1,1","1,1,1","2,1,1","2,2,1");
$ELNK.CTS6(P1,P2,"z",0,"两个面之间的刚性连接");
测试
ELNK
弹性连接
CTS7
平面之间点弹性连接
弹性连接集合
展开
第一个平面的全部点,第二个平面的全部点,面的方向XYZ,角度,边界组名
P1=$NODE.CTS1("0,0,0","0,1,0","1,1,0","2,1,0","2,2,0");
P2=$NODE.CTS1("0,0,1","0,1,1","1,1,1","2,1,1","2,2,1");
$ELNK.CTS7(P1,P2,"[0,0,0,1,0,0]","[0,0,0,10000,0,0]","z","两个面之间的弹性连接");
测试
ELNK
弹性连接
Generate
生成虚拟的弹性连接
虚拟弹性连接集合
展开
类型1普通弹性连接|2只受压弹性连接|3只受拉弹性连接|固定连接,普通弹性连接[0,0,0,1,0,0]|其它空,普通弹性连接[0,0,0,5622,0,0]|只受拉受压弹性连接[1],边界组名称
virual=$ELNK.Generate(4,'0','0',"固定连接");
virual1=$ELNK.Generate(1,'[0,0,0,1,0,0]','[0,0,0,5622,0,0]',"普通弹性连接");
virual2=$ELNK.Generate(2,'[0,0,0,1,0,0]','[5622]',"只受压弹性连接");
virual3=$ELNK.Generate(3,'[0,0,0,1,0,0]','[5622]',"只受拉弹性连接");
return(virual3);
测试
FRLS
释放梁端约束
CT
释放梁端约束
梁端约束的编号
展开
梁编号，组，MY(1)/MZ(0),起点，终点)
m=$MATL.CTQ235();
s=$SECT.CTH("H梁","I20a");
n=$NODE.CTS1("0,0,0","1,0,0");
b=$ELEM.CT(n[0],n[1],m,s,0);
$FRLS.CT(b,"组1",0,1,1);
测试
BODF
自重
CTS
自重荷载
展开
工况名称，组名称，力方向默认-1
$STLD.CTS1("自重1","自重工况");
$BODF.CTS("自重1","组a",-1);
测试
CNLD
节点荷载
CT
创建节点荷载
展开
节点号,工况名称,荷载组,FX，FY, FZ,MX,MY,MZ
C1='I20a';
matl=$MATL.CTSteel();
var secnumber=$SECT.CTS(`H:工钢:${C1}`);
BaseNodes=$GRUP.AddNodeS("简支梁",$NODE.CTS1("0,0,0",`5,0,0`,`10,0,0`));
Beam1=$ELEM.CTS1(BaseNodes[0],BaseNodes[2],matl,secnumber[0],0);
$STLD.CTS1("施工","施工工况");
$CNLD.CT(2,"施工","荷载组",0,0,-10,0,0,0);
测试
BMLD
梁单元荷载
CT
创建梁单元荷载
无意义
展开
单元编号，工况名称值，荷载值，荷载组名称
C1='I20a';
matl=$MATL.CTSteel();
var secnumber=$SECT.CTS(`H:工钢:${C1}`);
BaseNodes=$GRUP.AddNodeS("简支梁",$NODE.CTS1("0,0,0",`5,0,0`,`10,0,0`));
Beam1=$ELEM.CTS1(BaseNodes[0],BaseNodes[2],matl,secnumber[0],0);
$STLD.CTS1("施工","施工工况");
$BMLD.CT(Beam1[0],"施工",-50,"线荷载");
测试
BMLD
梁单元荷载
CT1
创建一组梁单元均布荷载
展开
单元编号集合，荷载工况名称，方向[LX/LZ/LY/GX/GY/GZ]，数值,x1[默认0],x2[默认1],荷载组名称[默认空]
C1='I20a';
matl=$MATL.CTSteel();
var secnumber=$SECT.CTS(`H:工钢:${C1}`);
BaseNodes=$GRUP.AddNodeS("简支梁",$NODE.CTS1("0,0,0",`5,0,0`,`10,0,0`));
Beam1=$ELEM.CTS1(BaseNodes[0],BaseNodes[2],matl,secnumber[0],0);
$STLD.CTS1("施工","施工工况");
$BMLD.CT1(Beam1,"施工","GZ",-50,0.1,0.5);
测试
BMLD
梁单元荷载
CT2
创建一组梁单元梯形荷载
展开
单元编号集合，荷载工况名称，方向[LX/LZ/LY/GX/GY/GZ]，数值W1,数值W2,数值W3,数值W4,x1[默认0],x2[默认0],x3[默认0],x4[默认0],荷载组名称[默认空]
C1='I20a';
matl=$MATL.CTSteel();
var secnumber=$SECT.CTS(`H:工钢:${C1}`);
BaseNodes=$GRUP.AddNodeS("简支梁",$NODE.CTS1("0,0,0",`5,0,0`,`10,0,0`));
Beam1=$ELEM.CTS1(BaseNodes[0],BaseNodes[2],matl,secnumber[0],0);
$STLD.CTS1("施工","施工工况");
$BMLD.CT2(Beam1,"施工","GZ",-50,-60,-90,-100,0.1,0.5,0.6,0.9);
测试
BMLD
梁单元荷载
CT3
创建一组梁单元集中荷载
展开
单元编号集合，荷载工况名称，方向[LX/LZ/LY/GX/GY/GZ]，数值W1,数值W2,数值W3,数值W4,x1[默认0],x2[默认0],x3[默认0],x4[默认0],荷载组名称[默认空]
C1='I20a';
matl=$MATL.CTSteel();
var secnumber=$SECT.CTS(`H:工钢:${C1}`);
BaseNodes=$GRUP.AddNodeS("简支梁",$NODE.CTS1("0,0,0",`5,0,0`,`10,0,0`));
Beam1=$ELEM.CTS1(BaseNodes[0],BaseNodes[2],matl,secnumber[0],0);
$STLD.CTS1("施工","施工工况");
$BMLD.CT3(Beam1,"施工","GZ",-50,-60,-90,-100,0.1,0.5,0.6,0.9);
测试
PRES
压力荷载
CT
创建均布压力荷载
展开
单元编号，工况名称，组名称，LX/LZ/LY，值
l=$STLD.CTS1("平台施工荷载","活载");
C=$THIK.CT(0.006);
m=$MATL.CTQ235();
n=$NODE.CTS1("0,0,0","1,0,0","1,1,0","0,1,0");
B=$ELEM.CTPlane(C,m,n[0],n[1],n[2],n[3]);
$PRES.CT(B,"平台施工荷载","荷载组1","LZ",-10);
测试
PRES
压力荷载
CT1
创建一组均布压力荷载
展开
单元编号集合，工况名称，组名称，LX/LZ/LY/GX/GY/GZ，值,组
$STLD.CTS1("平台施工荷载","活载");
C=$THIK.CT(0.006);
m=$MATL.CTQ235();
n=$NODE.CTS1("0,0,0","1,0,0","1,1,0","0,1,0","2,0,0","2,1,0");
v=$ELEM.CTPlaneS1(n,C,m);
$PRES.CT1(v,"平台施工荷载","LZ",-20);
测试
SDSP
强制位移
CT
创建强制位移
展开
节点编号，工况名称值，荷载值，荷载组名称
C1='I20a';
matl=$MATL.CTSteel();
var secnumber=$SECT.CTS(`H:工钢:${C1}`);
BaseNodes=$GRUP.AddNodeS("简支梁",$NODE.CTS1("0,0,0",`5,0,0`,`10,0,0`));
Beam1=$ELEM.CTS1(BaseNodes[0],BaseNodes[2],matl,secnumber[0],0);
$STLD.CTS1("施工","施工工况");
$SDSP.CT(1,"施工","[0,0,5,0,0,0]","荷载组");
测试
SDSP
强制位移
CT1
创建一组强制位移
展开
节点编号集合，荷载工况名称，六点位移[0,1,2,0,0,0],荷载组名称[默认空]
C1='I20a';
matl=$MATL.CTSteel();
var secnumber=$SECT.CTS(`H:工钢:${C1}`);
BaseNodes=$GRUP.AddNodeS("简支梁",$NODE.CTS1("0,0,0",`5,0,0`,`10,0,0`));
Beam1=$ELEM.CTS1(BaseNodes[0],BaseNodes[2],matl,secnumber[0],0);
$STLD.CTS1("施工","施工工况");
$SDSP.CT1(Beam1,"施工","[0,0,-10,0,0,0]","强制位移");
测试
GRUP
结构组
Add
增加节点和单元
节点号集合,单元集合
展开
组名称
m=$MATL.CTQ235();
s=$SECT.CTH("H梁","I20a");
n=$NODE.CTS1("0,0,0","1,0,0");
b=$ELEM.CT(n[0],n[1],m,s,0);
ms=$ELEM.CPS(CArray.ToIT(b),"Y",5,5);
g=$GRUP.Add("Newb", n,ms);
/*return g.Item1*/
测试
GRUP
结构组
AddElemS
添加单元
单元号集合
展开
单元号集合
m=$MATL.CTQ235();
s=$SECT.CTH("H梁","I20a");
n=$NODE.CTS1("0,0,0","1,0,0");
b=$ELEM.CT(n[0],n[1],m,s,0);
ms=$ELEM.CPS(CArray.ToIT(b),"Y",5,5);
$GRUP.AddElemS("Newb",ms);
测试
GRUP
结构组
AddNodeS
添加节点
节点号集合
展开
节点号集合
N=$GRUP.AddNodeS("CES",$NODE.CTS1("0,0,0","1,0,0"));
测试
GRUP
结构组
Combination
增加节点和单元
组名称1,组名称2
展开
组名称
N=$GRUP.AddNodeS("CES",$NODE.CTS1("0,0,0","1,0,0"));
m=$MATL.CTQ235();
s=$SECT.CTH("H梁","I20a");
n=$NODE.CTS1("0,0,0","1,0,0");
b=$ELEM.CT(n[0],n[1],m,s,0);
ms=$ELEM.CPS(CArray.ToIT(b),"Y",5,5);
$GRUP.AddElemS("Newb",ms);
var ne=$GRUP.Combination("单片贝雷片","CES","Newb");
测试
GRUP
结构组
CTS
创建组
展开
组名称1，组名称2
$GRUP.CTS("a","b");
测试
GRUP
结构组
GetElemS
获取单元
单元号集合
展开
组名称
n=$NODE.CTS1("0,0,0","1,0,0");
b=$ELEM.CT(n[0],n[1],m,s,0);
$GRUP.AddElemS("NEWG",CArray.ToIT(b));
$GRUP.GetElemS("NEWG");
测试
GRUP
结构组
GetNodeS
获取节点
节点号集合
展开
组名称
N=$GRUP.AddNodeS("CES",$NODE.CTS1("0,0,0","1,0,0"));
M=$GRUP.GetNodeS("CES");
$NODE.CPS(M,"Z",1,10);
测试
LDGR
荷载组
CT
创建荷载组
展开
名称
测试
BNGR
边界组
CT
创建边界组
展开
名称
测试
STEEL
钢结构设计荷载组合
CTS
创建基本组合
展开
荷载组合名称，描述,(荷载名称:组合系数,荷载名称:组合系数)
$STLD.CTS("混凝土自重","混凝土");
$STLD.CTS1("平台施工荷载","活载");
$STLD.CTS("结构自重","结构");
$BODF.CTS("结构自重");
$STEEL.CTS("基本组合","浇筑混凝时","混凝土自重:1.3","平台施工荷载:1.5","结构自重:1.3");
测试
STEEL
钢结构设计荷载组合
CTS1
创建标准组合
展开
荷载组合名称，描述,(荷载名称:组合系数,荷载名称:组合系数)
$STLD.CTS("混凝土自重","混凝土");
$STLD.CTS1("平台施工荷载","活载");
$STLD.CTS("结构自重","结构");
$BODF.CTS("结构自重");
$STEEL.CTS1("标准组合","浇筑混凝时","混凝土自重:1.0","平台施工荷载:1.0","结构自重:1.0");
测试
ANAL
分析
Analysis
分析
bool
展开
测试