plate.cpp

有限元计算程序用于计算平面板结构单元的应力和位移。

//---------------------------------------------------------------------------

#include <iostream>
#include <iomanip>
#include <cmath>
#include <stdlib> 
using namespace std;
#pragma hdrstop

#include "Plate.h"


//---------------------------------------------------------------------------

TPlate::TPlate(int no, int el, int dof, int q,
               double e, double pr, double th, int s){

        Nodes = no;
        Elements = el;
        DOF = dof;
        Quad = q;
        E = e;
        v = pr;
        t = th;
        Solver = s;

        ID = Allocate_2D_Matrix(ID, DOF, Nodes);
        ID = SetZero_2D_Matrix(ID, DOF, Nodes);

        d = Allocate_1D_Matrix(d, Quad);
        d = SetZero_1D_Matrix(d, Quad);

        DXYZ = Allocate_1D_Matrix(DXYZ, (Nodes * DOF));
        DXYZ = SetZero_1D_Matrix(DXYZ, (Nodes * DOF));
    //-----------------------------------------------------------------------
        ENStress_x = Allocate_1D_Matrix(ENStress_x, Elements);
        ENStress_x = SetZero_1D_Matrix(ENStress_x, Elements);

        ENStress_y = Allocate_1D_Matrix(ENStress_y, Elements);
        ENStress_y = SetZero_1D_Matrix(ENStress_y, Elements);

        ESStress = Allocate_1D_Matrix(ESStress, Elements);
        ESStress = SetZero_1D_Matrix(ESStress, Elements);

        ENStrain_x = Allocate_1D_Matrix(ENStrain_x, Elements);
        ENStrain_x = SetZero_1D_Matrix(ENStrain_x, Elements);

        ENStrain_y = Allocate_1D_Matrix(ENStrain_y, Elements);
        ENStrain_y = SetZero_1D_Matrix(ENStrain_y, Elements);

        ESStrain = Allocate_1D_Matrix(ESStrain, Elements);
        ESStrain = SetZero_1D_Matrix(ESStrain, Elements);
    //-----------------------------------------------------------------------
        NNStress_x = Allocate_1D_Matrix(NNStress_x, Nodes);
        NNStress_x = SetZero_1D_Matrix(NNStress_x, Nodes);

        NNStress_y = Allocate_1D_Matrix(NNStress_y, Nodes);
        NNStress_y = SetZero_1D_Matrix(NNStress_y, Nodes);

        NSStress = Allocate_1D_Matrix(NSStress, Nodes);
        NSStress = SetZero_1D_Matrix(NSStress, Nodes);

        NNStrain_x = Allocate_1D_Matrix(NNStrain_x, Nodes);
        NNStrain_x = SetZero_1D_Matrix(NNStrain_x, Nodes);

        NNStrain_y = Allocate_1D_Matrix(NNStrain_y, Nodes);
        NNStrain_y = SetZero_1D_Matrix(NNStrain_y, Nodes);

        NSStrain = Allocate_1D_Matrix(NSStrain, Nodes);
        NSStrain = SetZero_1D_Matrix(NSStrain, Nodes);
    //-----------------------------------------------------------------------
}

//---------------------------------------------------------------------------

TPlate::TPlate(const TPlate& p){

        Nodes = p.Nodes;
        Elements = p.Elements;
        DOF = p.DOF;
        Quad = p.Quad;
        Solver = p.Solver;
        E = p.E;
        v = p.v;
        t = p.t;
        XYZ = p.XYZ;
        Connect = p.Connect;
        Freedom = p.Freedom;
        Force = p.Force;
        ID = p.ID;
        S = p.S;
        R = p.R;
        U = p.U;
        DXYZ = p.DXYZ;
        sa = p.sa;
        b = p.b;
        x = p.x;
        ija = p.ija;
        NEQ = p.NEQ;
        MBAND = p.MBAND;
        nmax = p.nmax;
        aa = p.aa;
        bb = p.bb;
        ENStress_x = p.ENStress_x;
        ENStress_y = p.ENStress_y;
        ESStress = p.ESStress;
        ENStrain_x = p.ENStrain_x;
        ENStrain_y = p.ENStrain_y;
        ESStrain = p.ESStrain;
        NNStress_x = p.NNStress_x;
        NNStress_y = p.NNStress_y;
        NSStress = p.NSStress;
        NNStrain_x = p.NNStrain_x;
        NNStrain_y = p.NNStrain_y;
        NSStrain = p.NSStrain;
}

//---------------------------------------------------------------------------

TPlate::~TPlate(){

        De_Allocate_2D_Matrix(ID, DOF);
        De_Allocate_2D_Matrix(S, (NEQ + 1));
        De_Allocate_1D_Matrix(d);
        De_Allocate_1D_Matrix(R);
        De_Allocate_1D_Matrix(U);
        De_Allocate_1D_Matrix(DXYZ);
        De_Allocate_1D_Matrix(ENStress_x);
        De_Allocate_1D_Matrix(ENStress_y);
        De_Allocate_1D_Matrix(ESStress);
        De_Allocate_1D_Matrix(ENStrain_x);
        De_Allocate_1D_Matrix(ENStrain_y);
        De_Allocate_1D_Matrix(ESStrain);

        if (Solver == 0){
           De_Allocate_1D_Matrix(sa);
           De_Allocate_1D_Matrix(b);
           De_Allocate_1D_Matrix(x);
           De_Allocate_1D_Matrix(ija);
        }
}

//---------------------------------------------------------------------------

void TPlate::Display(){

        cout << "Nodes: " << Nodes << endl;
        cout << "Elements: " << Elements << endl;
        cout << "DOF: " << DOF << endl;
        cout << "Quad: " << Quad << endl;
        cout << "E: " << E << endl;
        cout << "v: " << v << endl;
        cout << "t: " << t << endl;
        cout << "Solver: " << Solver << endl;

        Calculation();
}

//---------------------------------------------------------------------------

void TPlate::Matrix_Check(){

    //-----------------------------------------------------------------------
//        cout << setiosflags(ios::fixed) << setprecision(4);
    //-----------------------------------------------------------------------
//        cout << endl;
//        char* char_XYZ = "XYZ";
//        Matrix_2D_Display(XYZ, Nodes, DOF, char_XYZ);
    //-----------------------------------------------------------------------
//        cout << endl;
//        char* char_Connect = "Connect";
//        Matrix_2D_Display(Connect, Elements, Quad, char_Connect);
    //-----------------------------------------------------------------------
//        cout << endl;
//        char* char_Freedom = "Freedom";
//        Matrix_2D_Display(Freedom, Nodes, DOF, char_Freedom);
    //-----------------------------------------------------------------------
//        cout << endl;
//        char* char_Force = "Force";
//        Matrix_2D_Display(Force, Nodes, DOF, char_Force);
    //-----------------------------------------------------------------------
//        cout << endl;
//        char* char_ID = "ID";
//        Matrix_2D_Display(ID, DOF, Nodes, char_ID);
    //-----------------------------------------------------------------------
//        cout << endl;
//        char* char_S = "S";
//        Matrix_2D_Display(S, (NEQ + 1), (MBAND + 1), char_S);
    //-----------------------------------------------------------------------
//        cout << endl;
//        char* char_d = "d";
//        Matrix_1D_Display(d, Quad, char_d);
    //-----------------------------------------------------------------------
//        cout << endl;
//        cout << "NEQ = " << NEQ << endl;
//        cout << "MBAND = " << MBAND << endl;
    //-----------------------------------------------------------------------
//          char* char_R = "R";
        if (Solver == 0){
//          cout << endl;
//          Matrix_1D_Display(R, NEQ, char_R);
        }else if (Solver == 1){
//          cout << endl;
//          Matrix_1D_Display(R, (NEQ + 1), char_R);
        }
    //-----------------------------------------------------------------------
//          char* char_U = "U";
        if (Solver == 0){
//          cout << endl;
//          Matrix_1D_Display(U, NEQ, char_U);
        }else if (Solver == 1){
//          cout << endl;
//          Matrix_1D_Display(U, (NEQ + 1), char_U);
        }
    //-----------------------------------------------------------------------
//        cout << endl;
//        char* char_DXYZ = "DXYZ";
//        Matrix_1D_Display(DXYZ, (Nodes * DOF), char_DXYZ);
    //-----------------------------------------------------------------------
}

//---------------------------------------------------------------------------

void TPlate::Calculation(){

        ID = ID_Matrix();
        ID = Convert_ID();
        Count_MBAND();

        Banded_Stiffness_Matrix();
        Banded_Force();

        if (Solver == 0){

           U = Cal_CGSolver();          // Conjugate Gradient Method;

        }else if (Solver == 1){

           U = Cal_GESolver();          // Gauss Elimination Method;
        }

        DXYZ = Cal_DXYZ();
        Matrix_Check();
//        Stress();
}

//---------------------------------------------------------------------------