矩阵位移法大作业监工日记

 

 

 

5/15

新建文件夹，先做好前期结构数据化的手写性梳理，写一点变量的定义，感觉有很多重复的信息，但是懒得精简了。

编写输入文件in.txt，和直接用const差不多，感觉不如直接程序内打表，因为后面结构数据化的时候还是直接存的信息，泛用化水平进一步降低。

 

/* 矩阵位移法大作业
 单元数：10  结点数：12  整体结点位移编码：22 
 结点编码：
 1（0,0，1）
 2（2,3,4）
 3（5,6,7,）
 4（0,0,0）
 5（8,9,10）
 6（5,6,11）
 7（0,0,12）
 8（13,14,15）
 9（16,17,18）
 10（13,14,19）
 11（0,0,0） 
 12（20,21,22） 
 单元定位向量： 柱：0 梁：1
 （1） 【0,0,1,2,3,4】 1,2 0
 （2）【2,3,4,5,6,7】 2,3  1
 （3）【0,0,0,8,9,10】 4,5  0
 （4）【8,9,10,5,6,11】 5,6  0
 （5）【8,9,10,13,14,15】 5,8  1
 （6）【5，6,11,16,17,18】 6,9  1
 （7）【0,0,12,13,14,15】 7,8  0
 （8）【 13,14,15,16,17,18】 8,9  0
 （9）【13,14,19,20,21,22】 10,12  1
 （10）【0,0,0,20,21,22】 11,12  0
*/
/* 输入文件 in.txt
 12 10 22
 100000 15000
 1000000 10000
 3 4 3
 4 3 2 
 20
 12 14 10
 0 0 1 
 2 3 4
 5 6 7
 0 0 0
 8 9 10
 5 6 11
 0 0 12
 13 14 15
 16 17 18
 13 14 19
 0 0 0
 20 21 22
 1 2 0
 2 3 1
 4 5 0
 5 6 0
 5 8 1
 6 9 1
 7 8 0
 8 9 0
 10 12 1
 11 12 0
*/ 




#include<iostream>
#include<fstream>
#include<cstdio>
#include<algorithm>
#include<cmath> 
using namespace std;
double EA[3],EI[3]; //梁和柱的强度参数表
double l[4],h[4],q[4],Fp; // 跨长、层高、均布荷载、集中力
double K[25][25],k[25][25]; // 整体刚度矩阵 和 单元刚度矩阵
double alpha,T[8][8]; //旋转角和旋转矩阵 
int Njoint,Nelem,NglbDOF; //结点数，单元数，结点位移个数 
struct Joint{ //结点信息 
    double x,y; //坐标
    int GDOF[5]; //结点位移编码 
}J[20];
struct Elem{ //单元信息 
    int N1,N2; //两个结点
    int GlbDOF[8]; //单元定位向量
     double len,A,EI,EA; //长度，转角，抗弯刚度，抗拉刚度 
}E[15];
int main(){
    cin>>Njoint>>Nelem>>NglbDOF; //读入信息 并 进行结构数据化 
    cin>>EA[0]>>EI[0]>>EA[1]>>EI[1];
    for(int i=1;i<=3;++i) cin>>l[i];
    for(int i=1;i<=3;++i) cin>>h[i]; cin>>Fp;
    for(int i=1;i<=3;++i) cin>>q[i];
    
    J[1].x=J[2].x=0;  //结点初始化 
    J[3].x=J[4].x=J[5].x=J[6].x=l[1];
    J[7].x=J[8].x=J[9].x=J[10].x=l[1]+l[2];
    J[11].x=J[12].x=l[1]+l[2]+l[3];
    J[1].y=J[4].y=J[7].y=J[11].y=0;
    J[12].y=h[3];
    J[5].y=J[8].y=J[10].y=h[2];
    J[2].y=h[1];
    J[3].y=J[6].y=J[9].y=2.0*h[2];    
    for(int i=1;i<=Njoint;++i) 
        for(int j=1;j<=3;++j) 
            cin>>J[i].GDOF[j];
            
    for(int i=1;i<=Nelem;++i){ //单元初始化 
        cin>>E[i].N1>>E[i].N2;
        int opt; cin>>opt;
        E[i].EA=EA[opt]; E[i].EI=EI[opt];
        for(int j=1;j<=3;++j){
            E[i].GlbDOF[j]=J[E[i].N1].GDOF[j];
            E[i].GlbDOF[j+3]=J[E[i].N2].GDOF[j];
        } 
        E[i].len=sqrt(pow(J[E[i].N1].x-J[E[i].N2].x,2)+pow(J[E[i].N1].y-J[E[i].N2].y,2));
        E[i].A=
    }

    
}