📄 stress.cpp
字号:
#include <iostream>
using namespace std;
#include "Plate.h"
//---------------------------------------------------------------------------
void TPlate::Stress(){
double x = 0, y = 0;
double NQ = 0, MP = 0;
double ta1 = 0, ta2 = 0, ta3 = 0, ta4 = 0;
double tb1 = 0, tb2 = 0, tb3 = 0, tb4 = 0;
double u1 = 0, u2 = 0, u3 = 0, u4 = 0;
double v1 = 0, v2 = 0, v3 = 0, v4 = 0;
int *countNStress_x, *countNStress_y, *countSStress;
int *countNStrain_x, *countNStrain_y, *countSStrain;
//-----------------------------------------------------------------------
countNStress_x = Allocate_1D_Matrix(countNStress_x, Nodes);
countNStress_x = SetZero_1D_Matrix(countNStress_x, Nodes);
countNStress_y = Allocate_1D_Matrix(countNStress_y, Nodes);
countNStress_y = SetZero_1D_Matrix(countNStress_y, Nodes);
countSStress = Allocate_1D_Matrix(countSStress, Nodes);
countSStress = SetZero_1D_Matrix(countSStress, Nodes);
countNStrain_x = Allocate_1D_Matrix(countNStrain_x, Nodes);
countNStrain_x = SetZero_1D_Matrix(countNStrain_x, Nodes);
countNStrain_y = Allocate_1D_Matrix(countNStrain_y, Nodes);
countNStrain_y = SetZero_1D_Matrix(countNStrain_y, Nodes);
countSStrain = Allocate_1D_Matrix(countSStrain, Nodes);
countSStrain = SetZero_1D_Matrix(countSStrain, Nodes);
//-----------------------------------------------------------------------
NQ = (1 / (4 * aa * bb));
MP = NQ * (E / (1 - (v * v)));
for (int i = 0; i < Elements; i++){
for (int j = 0; j < Quad; j++){
d[j] = Connect[i][j] - 1;
}
u1 = DXYZ[2 * d[0]]; v1 = DXYZ[(2 * d[0]) + 1];
u2 = DXYZ[2 * d[1]]; v2 = DXYZ[(2 * d[1]) + 1];
u3 = DXYZ[2 * d[2]]; v3 = DXYZ[(2 * d[2]) + 1];
u4 = DXYZ[2 * d[3]]; v4 = DXYZ[(2 * d[3]) + 1];
for (int j = 0; j < Quad; j++){
///* // coordinate (-a, -b) 1. down-left coner of the plate
if (j == 0){
x = -1 * aa; y = -1 * bb;
ta1 = (x + aa); tb1 = (y + bb);
ta2 = (x - aa); tb2 = (y - bb);
ta3 = (aa - x); tb3 = (bb - y);
ta4 = -1 * ta1; tb4 = -1 * tb1;
El_Stress_Strain(i, x, y, MP, NQ, ta1, ta2, ta3, ta4,
tb1, tb2, tb3, tb4, u1, u2, u3, u4,
v1, v2, v3, v4);
No_Stress_Strain(d, i, j,
countNStress_x, countNStress_y, countSStress,
countNStrain_x, countNStrain_y, countSStrain);
}
//*/
///* // coordinate (a, -b) 2. down-right coner of the plate
if (j == 1){
x = aa; y = -1 * bb;
ta1 = (x + aa); tb1 = (y + bb);
ta2 = (x - aa); tb2 = (y - bb);
ta3 = (aa - x); tb3 = (bb - y);
ta4 = -1 * ta1; tb4 = -1 * tb1;
El_Stress_Strain(i, x, y, MP, NQ, ta1, ta2, ta3, ta4,
tb1, tb2, tb3, tb4, u1, u2, u3, u4,
v1, v2, v3, v4);
No_Stress_Strain(d, i, j,
countNStress_x, countNStress_y, countSStress,
countNStrain_x, countNStrain_y, countSStrain);
}
//*/
///* // coordinate (a, b) 3. up-right coner of the plate
if (j == 2){
x = aa; y = bb;
ta1 = (x + aa); tb1 = (y + bb);
ta2 = (x - aa); tb2 = (y - bb);
ta3 = (aa - x); tb3 = (bb - y);
ta4 = -1 * ta1; tb4 = -1 * tb1;
El_Stress_Strain(i, x, y, MP, NQ, ta1, ta2, ta3, ta4,
tb1, tb2, tb3, tb4, u1, u2, u3, u4,
v1, v2, v3, v4);
No_Stress_Strain(d, i, j,
countNStress_x, countNStress_y, countSStress,
countNStrain_x, countNStrain_y, countSStrain);
}
//*/
///* // coordinate (-a, b) 4. up-left coner of the plate
if (j == 3){
x = -1 * aa; y = bb;
ta1 = (x + aa); tb1 = (y + bb);
ta2 = (x - aa); tb2 = (y - bb);
ta3 = (aa - x); tb3 = (bb - y);
ta4 = -1 * ta1; tb4 = -1 * tb1;
El_Stress_Strain(i, x, y, MP, NQ, ta1, ta2, ta3, ta4,
tb1, tb2, tb3, tb4, u1, u2, u3, u4,
v1, v2, v3, v4);
No_Stress_Strain(d, i, j,
countNStress_x, countNStress_y, countSStress,
countNStrain_x, countNStrain_y, countSStrain);
}
//*/
}
// coordinate (0, 0) 5. Centre of the plate
x = 0; y = 0;
ta1 = (x + aa); tb1 = (y + bb);
ta2 = (x - aa); tb2 = (y - bb);
ta3 = (aa - x); tb3 = (bb - y);
ta4 = -1 * ta1; tb4 = -1 * tb1;
El_Stress_Strain(i, x, y, MP, NQ, ta1, ta2, ta3, ta4,
tb1, tb2, tb3, tb4, u1, u2, u3, u4,
v1, v2, v3, v4);
}
for (int i = 0; i < Nodes; i++){
NNStress_x[i] = NNStress_x[i] / countNStress_x[i];
NNStress_y[i] = NNStress_y[i] / countNStress_y[i];
NSStress[i] = NSStress[i] / countSStress[i];
NNStrain_x[i] = NNStrain_x[i] / countNStrain_x[i];
NNStrain_y[i] = NNStrain_y[i] / countNStrain_y[i];
NSStrain[i] = NSStrain[i] / countSStrain[i];
}
///*
cout << endl;
char* char_ENStress_x = "ENStress_x";
Matrix_1D_Display(ENStress_x, Elements, char_ENStress_x);
cout << endl;
char* char_ENStress_y = "ENStress_y";
Matrix_1D_Display(ENStress_y, Elements, char_ENStress_y);
cout << endl;
char* char_ESStress = "ESStress";
Matrix_1D_Display(ESStress, Elements, char_ESStress);
cout << endl;
char* char_ENStrain_x = "ENStrain_x";
Matrix_1D_Display(ENStrain_x, Elements, char_ENStrain_x);
cout << endl;
char* char_ENStrain_y = "ENStrain_y";
Matrix_1D_Display(ENStrain_y, Elements, char_ENStrain_y);
cout << endl;
char* char_ESStrain = "ESStrain";
Matrix_1D_Display(ESStrain, Elements, char_ESStrain);
//*/
///*
cout << endl;
char* char_NNStress_x = "NNStress_x";
Matrix_1D_Display(NNStress_x, Nodes, char_NNStress_x);
cout << endl;
char* char_NNStress_y = "NNStress_y";
Matrix_1D_Display(NNStress_y, Nodes, char_NNStress_y);
cout << endl;
char* char_NSStress = "NSStress";
Matrix_1D_Display(NSStress, Nodes, char_NSStress);
cout << endl;
char* char_NNStrain_x = "NNStrain_x";
Matrix_1D_Display(NNStrain_x, Nodes, char_NNStrain_x);
cout << endl;
char* char_NNStrain_y = "NNStrain_y";
Matrix_1D_Display(NNStrain_y, Nodes, char_NNStrain_y);
cout << endl;
char* char_NSStrain = "NSStrain";
Matrix_1D_Display(NSStrain, Nodes, char_NSStrain);
//*/
/*
cout << endl;
char* char_countNStress_x = "countNStress_x";
Matrix_1D_Display(countNStress_x, Nodes, char_countNStress_x);
cout << endl;
char* char_countNStress_y = "countNStress_y";
Matrix_1D_Display(countNStress_y, Nodes, char_countNStress_y);
cout << endl;
char* char_countSStress = "countSStress";
Matrix_1D_Display(countSStress, Nodes, char_countSStress);
cout << endl;
char* char_countNStrain_x = "countNStrain_x";
Matrix_1D_Display(countNStrain_x, Nodes, char_countNStrain_x);
cout << endl;
char* char_countNStrain_y = "countNStrain_y";
Matrix_1D_Display(countNStrain_y, Nodes, char_countNStrain_y);
cout << endl;
char* char_countSStrain = "countSStrain";
Matrix_1D_Display(countSStrain, Nodes, char_countSStrain);
*/
De_Allocate_1D_Matrix(countNStress_x);
De_Allocate_1D_Matrix(countNStress_y);
De_Allocate_1D_Matrix(countSStress);
De_Allocate_1D_Matrix(countNStrain_x);
De_Allocate_1D_Matrix(countNStrain_y);
De_Allocate_1D_Matrix(countSStrain);
}
//---------------------------------------------------------------------------
void TPlate::El_Stress_Strain(int i, double x, double y, double MP, double NQ,
double ta1, double ta2, double ta3, double ta4,
double tb1, double tb2, double tb3, double tb4,
double u1, double u2, double u3, double u4,
double v1, double v2, double v3, double v4){
ENStress_x[i] = MP * ((u3 * tb1 + u1 * tb2 + u2 * tb3 + u4 * tb4) +
(v * (v3 * ta1 + v1 * ta2 + v4 * ta3 + v2 * ta4)));
ENStress_y[i] = MP * ((v3 * ta1 + v1 * ta2 + v4 * ta3 + v2 * ta4) +
(v * (u3 * tb1 + u1 * tb2 + u2 * tb3 + u4 * tb4)));
ESStress[i] = (MP / 2) * (1 - v) *
((v3 * tb1 + v1 * tb2 + v2 * tb3 + v4 * tb4) +
(u3 * ta1 + u1 * ta2 + u4 * ta3 + u2 * ta4));
ENStrain_x[i] = NQ * (((u1 - u2 + u3 - u4) * y) +
((u2 - u1 + u3 - u4) * bb));
ENStrain_y[i] = NQ * (((v1 - v2 + v3 - v4) * x) +
((v3 - v1 + v4 - v2) * aa));
ESStrain[i] = NQ * (((v1 - v2 + v3 - v4) * y) +
((u1 - u2 + u3 - u4) * x) +
((u3 - u1 + u4 - u2) * aa) +
((v3 - v1 + v2 - v4) * bb));
}
//---------------------------------------------------------------------------
void TPlate::No_Stress_Strain(int *d, int i, int j,
int *countNStress_x, int *countNStress_y, int *countSStress,
int *countNStrain_x, int *countNStrain_y, int *countSStrain){
NNStress_x[d[j]] = NNStress_x[d[j]] + ENStress_x[i];
countNStress_x[d[j]] = countNStress_x[d[j]] + 1;
NNStress_y[d[j]] = NNStress_y[d[j]] + ENStress_y[i];
countNStress_y[d[j]] = countNStress_y[d[j]] + 1;
NSStress[d[j]] = NSStress[d[j]] + ESStress[i];
countSStress[d[j]] = countSStress[d[j]] + 1;
NNStrain_x[d[j]] = NNStrain_x[d[j]] + ENStrain_x[i];
countNStrain_x[d[j]] = countNStrain_x[d[j]] + 1;
NNStrain_y[d[j]] = NNStrain_y[d[j]] + ENStrain_y[i];
countNStrain_y[d[j]] = countNStrain_y[d[j]] + 1;
NSStrain[d[j]] = NSStrain[d[j]] + ESStrain[i];
countSStrain[d[j]] = countSStrain[d[j]] + 1;
}
//---------------------------------------------------------------------------
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -