📄 globalelement.cpp

📁 三维框架梁单元C++版本的源程序可以使结构力学的概念更上升一个层次
💻 CPP
📖 第 1 页 / 共 4 页
字号:
12 3 4 下一页
#include "stdafx.h"
//#include "FORCE.h"
#include "GlobalElement.h"

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CGlobalElement::CGlobalElement()
{

}

CGlobalElement::~CGlobalElement()
{

}

void CGlobalElement::Initial(CString filaname)
{	
	m_cFilePath = filaname;
	ifstream fin;	
	fin.open(m_cFilePath);

	char str[100];
	//*
	bool m_bMAT1 = 0; //线弹性材料
	bool m_bMAT2 = 0; //为将来扩展准备
	bool m_bMAT3 = 0; //为将来扩展准备
	//*
	bool m_bRC1 = 0; //SpaceFrame实常数（可以退化为平面单元、桁架）
	bool m_bRC2 = 0; //为将来扩展准备
	bool m_bRC3 = 0; //为将来扩展准备
	//*
	bool m_bElement1 = 0; //SpaceFrame单元
	bool m_bElement2 = 0; //为将来扩展准备，例如壳单元
	bool m_bElement3 = 0; //为将来扩展准备，例如体单元

	//探索行动
	while(!fin.eof())
	{
		fin>>str;
		//*
		if(!strcmp(str,"MATERIAL_1"))
			m_bMAT1 = 1;
		if(!strcmp(str,"MATERIAL_2"))
			m_bMAT2 = 1;
		if(!strcmp(str,"MATERIAL_3"))
			m_bMAT3 = 1;
		//* 
		if(!strcmp(str,"REAL_CONSTANT_1"))
			m_bRC1 = 1;
		if(!strcmp(str,"REAL_CONSTANT_2"))
			m_bRC2 = 1;
		if(!strcmp(str,"REAL_CONSTANT_3"))
			m_bRC3 = 1;
		//*
		if(!strcmp(str,"ELEMENT_SPACEFRAME_START"))
			m_bElement1 = 1;	
	}
	fin.close();	

	//通过对象指针建立各成员变量之间的关系
	CBaseElement::m_pNode = &m_Node;
	CBaseElement::m_papMaterial = &m_apMaterial;
	CBaseElement::m_papBaseRealConstant = &m_apBaseRealConstant;
	CBaseElement::m_pLoad = &m_Load;

	//节点类初始化
	m_Node.ReadFile(m_cFilePath);
	//材料类初始化
	if(m_bMAT1) 
	{
		m_apMaterial.SetSize(1);
		m_apMaterial[0] = new CElasticSteelMat();
		//这里有一个问题，不能调用基类没有而该继承类有的东西
		m_apMaterial[0]->ReadFile(m_cFilePath);
	}
	if(m_bMAT2)
	{
		m_bMAT2 = true;
	}
	if(m_bMAT3)
	{
		m_bMAT3 = true;
	}
	//实常数类的初始化
	if(m_bRC1)
	{
		m_apBaseRealConstant.SetSize(1);
		m_apBaseRealConstant[0] = new CSpaceFrameRC();
		m_apBaseRealConstant[0]->ReadFile(m_cFilePath);
	}
	if(m_bRC2)
	{
		m_bRC2 = true;
	}
	if(m_bRC3)
	{
		m_bRC3 = true;
	}
	//单元类的初始化
	if(m_bElement1)
	{
		m_apEle.SetSize(1);
		m_apEle[0] = new CSpaceFrameBeam();		
	}
	//荷载类的初始化
	m_Load.ReadFile(m_cFilePath);
}

void CGlobalElement::StiffAssemble()
{
	m_apEle[0]->ReadFile(m_cFilePath);
	m_apEle[0]->GetStiffness();
	m_apEle[0]->StiffAssemble();
}

void CGlobalElement::Loading()   //暂时仅仅考虑节点荷载
{
	Node_LoadVectorAssemble();	
	ElemDis_LoadVectorAssemble();
	ElemCen_LoadVectorAssemble();

	//荷载向量的叠加
	//CASE 1
	m_adLoadVector_C1 = new double [m_Node.m_nTotalDOF];
	for(int loop=0;loop<m_Node.m_nTotalDOF;loop++)
	{
		m_adLoadVector_C1[loop] = m_adCase1_Node_LoadVector[loop] + m_adCase1_ElemDis_LoadVector[loop]
		+ m_adCase1_ElemCen_LoadVector[loop];
	}

	//CASE 2
	m_adLoadVector_C2 = new double [m_Node.m_nTotalDOF];
	for(loop=0;loop<m_Node.m_nTotalDOF;loop++)
	{
		m_adLoadVector_C2[loop] = m_adCase2_Node_LoadVector[loop] + m_adCase2_ElemDis_LoadVector[loop]		
		+ m_adCase2_ElemCen_LoadVector[loop];
	} 
	
	//m_adLoadVector_C2滤除限制自由度的力,用于求解单元内力，保留LoadVector用于求解支座反力

	//LoadVector赋初值
	LoadVector.SetSize(m_Node.m_nTotalDOF);
	for(loop=0;loop<m_Node.m_nTotalDOF;loop++)
	{
		LoadVector[loop] = 0;	
	}

	for(loop=0;loop<m_Node.m_nTotalDOF;loop++)
	{
		LoadVector[loop] = m_adLoadVector_C2[loop];
		if(loop>=m_Node.m_nFreeDOF)
			m_adLoadVector_C2[loop] = 0;
	}

	OutputParameter();
}

void CGlobalElement::Node_LoadVectorAssemble()
{
	//CASE1 初始化
	m_adCase1_Node_LoadVector.SetSize(m_Node.m_nTotalDOF);
	for(int loop=0;loop<m_Node.m_nTotalDOF;loop++)
		m_adCase1_Node_LoadVector[loop] = 0;	
	//赋值
	int m_nTemp = 0;
	for(int loop1=0;loop1<(m_Node.m_nNodeNum - m_Node.m_nNode_K_Num);loop1++)
	{
		for(int loop2=0;loop2<m_Load.m_nNodeLoadNum_Case1;loop2++)
		{
			if(m_Node.m_aDOFIndex[loop1].m_aiNode == m_Load.m_adJointLoadValue_Case1[loop2].m_nNodeNO)
			{
				m_nTemp = m_Node.m_aDOFIndex[loop1].m_aiDOFIndex_X;
				//if(m_nTemp<m_Node.m_nFreeDOF)				
					m_adCase1_Node_LoadVector[m_nTemp] += m_Load.m_adJointLoadValue_Case1[loop2].m_dFX;
				m_nTemp = m_Node.m_aDOFIndex[loop1].m_aiDOFIndex_Y;
				//if(m_nTemp<m_Node.m_nFreeDOF)
					m_adCase1_Node_LoadVector[m_nTemp] += m_Load.m_adJointLoadValue_Case1[loop2].m_dFY;
				m_nTemp = m_Node.m_aDOFIndex[loop1].m_aiDOFIndex_Z;
				//if(m_nTemp<m_Node.m_nFreeDOF)
					m_adCase1_Node_LoadVector[m_nTemp] += m_Load.m_adJointLoadValue_Case1[loop2].m_dFZ;
				m_nTemp = m_Node.m_aDOFIndex[loop1].m_aiDOFIndex_RX;
				//if(m_nTemp<m_Node.m_nFreeDOF)
					m_adCase1_Node_LoadVector[m_nTemp] += m_Load.m_adJointLoadValue_Case1[loop2].m_dMX;
				m_nTemp = m_Node.m_aDOFIndex[loop1].m_aiDOFIndex_RY;
				//if(m_nTemp<m_Node.m_nFreeDOF)
					m_adCase1_Node_LoadVector[m_nTemp] += m_Load.m_adJointLoadValue_Case1[loop2].m_dMY;
				m_nTemp = m_Node.m_aDOFIndex[loop1].m_aiDOFIndex_RZ;
				//if(m_nTemp<m_Node.m_nFreeDOF)
					m_adCase1_Node_LoadVector[m_nTemp] += m_Load.m_adJointLoadValue_Case1[loop2].m_dMZ;				
			}
		}
	}

	//CASE2 初始化
	m_adCase2_Node_LoadVector.SetSize(m_Node.m_nTotalDOF);
	for(loop=0;loop<m_Node.m_nTotalDOF;loop++)
		m_adCase2_Node_LoadVector[loop] = 0;	
	//赋值	
	for(loop1=0;loop1<(m_Node.m_nNodeNum - m_Node.m_nNode_K_Num);loop1++)
	{
		for(int loop2=0;loop2<m_Load.m_nNodeLoadNum_Case2;loop2++)
		{
			if(m_Node.m_aDOFIndex[loop1].m_aiNode == m_Load.m_adJointLoadValue_Case2[loop2].m_nNodeNO)
			{
				m_nTemp = m_Node.m_aDOFIndex[loop1].m_aiDOFIndex_X;
				//if(m_nTemp<m_Node.m_nFreeDOF)				
					m_adCase2_Node_LoadVector[m_nTemp] += m_Load.m_adJointLoadValue_Case2[loop2].m_dFX;
				m_nTemp = m_Node.m_aDOFIndex[loop1].m_aiDOFIndex_Y;
				//if(m_nTemp<m_Node.m_nFreeDOF)
					m_adCase2_Node_LoadVector[m_nTemp] += m_Load.m_adJointLoadValue_Case2[loop2].m_dFY;
				m_nTemp = m_Node.m_aDOFIndex[loop1].m_aiDOFIndex_Z;
				//if(m_nTemp<m_Node.m_nFreeDOF)
					m_adCase2_Node_LoadVector[m_nTemp] += m_Load.m_adJointLoadValue_Case2[loop2].m_dFZ;
				m_nTemp = m_Node.m_aDOFIndex[loop1].m_aiDOFIndex_RX;
				//if(m_nTemp<m_Node.m_nFreeDOF)
					m_adCase2_Node_LoadVector[m_nTemp] += m_Load.m_adJointLoadValue_Case2[loop2].m_dMX;
				m_nTemp = m_Node.m_aDOFIndex[loop1].m_aiDOFIndex_RY;
				//if(m_nTemp<m_Node.m_nFreeDOF)
					m_adCase2_Node_LoadVector[m_nTemp] += m_Load.m_adJointLoadValue_Case2[loop2].m_dMY;
				m_nTemp = m_Node.m_aDOFIndex[loop1].m_aiDOFIndex_RZ;
				//if(m_nTemp<m_Node.m_nFreeDOF)
					m_adCase2_Node_LoadVector[m_nTemp] += m_Load.m_adJointLoadValue_Case2[loop2].m_dMZ;				
			}
		}
	}
}

void CGlobalElement::ElemDis_LoadVectorAssemble()   //均布荷载
{
	//临时变量
	int m_nTemp = 0;
	int m_nTemp1 = 0;
	int m_nNode1 = 0;
	int m_nNode2 = 0;
	double L = 0;
	//
	double m_dDX = 0;
	double m_dDY = 0;
	double m_dDZ = 0;
	double m_dDMX = 0;
	double m_dDMY = 0;
	double m_dDMZ = 0;
	//
	double Q = 0;
	double MA = 0;
	double RA = 0;				
	double x = 0;
	
	//临时荷载向量（局部座标->整体座标）
	CMatrix TempCM_DisLoadVector(12,1,0);	
	CMatrix TempCM_DisLoadVectorG(12,1,0);	
	
	//CASE1 初始化
	m_adCase1_ElemDis_LoadVector.SetSize(m_Node.m_nTotalDOF);
	for(int loop=0;loop<m_Node.m_nTotalDOF;loop++)
		m_adCase1_ElemDis_LoadVector[loop] = 0;
	//具体赋值
	for(loop=0;loop<m_Load.m_nElemLoadNum_Case1_Dis;loop++)
	{
		//受荷单元号
		m_nTemp = m_Load.m_adElemLoadValue_Case1_Dis[loop].m_nElementNO;
		//单元对应节点
		for(int loop1=0;loop1<m_apEle[0]->m_nElementNum;loop1++)
		{
			if(m_nTemp == m_apEle[0]->m_aBeamElemProValue[loop1].m_nElementNo)
			{
				m_nNode1 = m_apEle[0]->m_aBeamElemProValue[loop1].m_nElemNode1;
				m_nNode2 = m_apEle[0]->m_aBeamElemProValue[loop1].m_nElemNode2;
				L = m_apEle[0]->m_aBeamElemProValue[loop1].m_L;
				//转化矩阵
				CMatrix cm_TT = m_apEle[0]->m_CaElemTranFactorMatrixT[loop1];
				
				//等效节点荷载
				m_dDX = m_Load.m_adElemLoadValue_Case1_Dis[loop].m_dElemForceX * L/2;
				m_dDY = m_Load.m_adElemLoadValue_Case1_Dis[loop].m_dElemForceY * L/2;
				m_dDZ = m_Load.m_adElemLoadValue_Case1_Dis[loop].m_dElemForceZ * L/2;
				m_dDMX = 0;
				m_dDMY = m_Load.m_adElemLoadValue_Case1_Dis[loop].m_dElemForceZ *L*L/12;
				m_dDMZ = m_Load.m_adElemLoadValue_Case1_Dis[loop].m_dElemForceY *L*L/12;

				//局部荷载向量
				TempCM_DisLoadVector(0,0) = m_dDX;
				TempCM_DisLoadVector(1,0) = m_dDY;
				TempCM_DisLoadVector(2,0) = m_dDZ;
				TempCM_DisLoadVector(3,0) = m_dDMX;
				TempCM_DisLoadVector(4,0) = -m_dDMY;
				TempCM_DisLoadVector(5,0) = m_dDMZ;
				//
				TempCM_DisLoadVector(6,0) = m_dDX;
				TempCM_DisLoadVector(7,0) = m_dDY;
				TempCM_DisLoadVector(8,0) = m_dDZ;
				TempCM_DisLoadVector(9,0) = -m_dDMX;
				TempCM_DisLoadVector(10,0) = m_dDMY;
				TempCM_DisLoadVector(11,0) = -m_dDMZ;

				//转换
				TempCM_DisLoadVectorG = cm_TT * TempCM_DisLoadVector;				
				
				for(int loop2=0;loop2<(m_Node.m_nNodeNum - m_Node.m_nNode_K_Num);loop2++)
				{
					if(m_nNode1 == m_Node.m_aDOFIndex[loop2].m_aiNode)
					{
						m_nTemp1 = m_Node.m_aDOFIndex[loop2].m_aiDOFIndex_X;
						//if(m_nTemp1<m_Node.m_nFreeDOF)	
							m_adCase1_ElemDis_LoadVector[m_nTemp1] += TempCM_DisLoadVectorG(0,0);
						m_nTemp1 = m_Node.m_aDOFIndex[loop2].m_aiDOFIndex_Y;
						//if(m_nTemp1<m_Node.m_nFreeDOF)	
							m_adCase1_ElemDis_LoadVector[m_nTemp1] += TempCM_DisLoadVectorG(1,0);
						m_nTemp1 = m_Node.m_aDOFIndex[loop2].m_aiDOFIndex_Z;
						//if(m_nTemp1<m_Node.m_nFreeDOF)	
							m_adCase1_ElemDis_LoadVector[m_nTemp1] += TempCM_DisLoadVectorG(2,0);	
						m_nTemp1 = m_Node.m_aDOFIndex[loop2].m_aiDOFIndex_RX;
						//if(m_nTemp1<m_Node.m_nFreeDOF)	
							m_adCase1_ElemDis_LoadVector[m_nTemp1] += TempCM_DisLoadVectorG(3,0);
						m_nTemp1 = m_Node.m_aDOFIndex[loop2].m_aiDOFIndex_RY;
						//if(m_nTemp1<m_Node.m_nFreeDOF)	
							m_adCase1_ElemDis_LoadVector[m_nTemp1] += TempCM_DisLoadVectorG(4,0);
						m_nTemp1 = m_Node.m_aDOFIndex[loop2].m_aiDOFIndex_RZ;
						//if(m_nTemp1<m_Node.m_nFreeDOF)	
							m_adCase1_ElemDis_LoadVector[m_nTemp1] += TempCM_DisLoadVectorG(5,0);
					}
					if(m_nNode2 == m_Node.m_aDOFIndex[loop2].m_aiNode)
					{
						m_nTemp1 = m_Node.m_aDOFIndex[loop2].m_aiDOFIndex_X;
						//if(m_nTemp1<m_Node.m_nFreeDOF)	
							m_adCase1_ElemDis_LoadVector[m_nTemp1] += TempCM_DisLoadVectorG(6,0);
						m_nTemp1 = m_Node.m_aDOFIndex[loop2].m_aiDOFIndex_Y;
						//if(m_nTemp1<m_Node.m_nFreeDOF)	
							m_adCase1_ElemDis_LoadVector[m_nTemp1] += TempCM_DisLoadVectorG(7,0);
						m_nTemp1 = m_Node.m_aDOFIndex[loop2].m_aiDOFIndex_Z;
						//if(m_nTemp1<m_Node.m_nFreeDOF)	
							m_adCase1_ElemDis_LoadVector[m_nTemp1] += TempCM_DisLoadVectorG(8,0);	
						m_nTemp1 = m_Node.m_aDOFIndex[loop2].m_aiDOFIndex_RX;
						//if(m_nTemp1<m_Node.m_nFreeDOF)	
							m_adCase1_ElemDis_LoadVector[m_nTemp1] += TempCM_DisLoadVectorG(9,0);
						m_nTemp1 = m_Node.m_aDOFIndex[loop2].m_aiDOFIndex_RY;
						//if(m_nTemp1<m_Node.m_nFreeDOF)	
							m_adCase1_ElemDis_LoadVector[m_nTemp1] += TempCM_DisLoadVectorG(10,0);
						m_nTemp1 = m_Node.m_aDOFIndex[loop2].m_aiDOFIndex_RZ;
						//if(m_nTemp1<m_Node.m_nFreeDOF)	
							m_adCase1_ElemDis_LoadVector[m_nTemp1] += TempCM_DisLoadVectorG(11,0);	
					}
				}

				//修改单元的挠度				
				m_dDY = m_Load.m_adElemLoadValue_Case1_Dis[loop].m_dElemForceY;
				m_dDZ = m_Load.m_adElemLoadValue_Case1_Dis[loop].m_dElemForceZ;
				double E = m_apEle[0]->m_aBeamElemProValue[loop1].m_E;
				double IY = m_apEle[0]->m_aBeamElemProValue[loop1].m_Iy;
				double IZ = m_apEle[0]->m_aBeamElemProValue[loop1].m_Iz;
				//
12 3 4 下一页
💿 文件大小 195 K
👤 上传用户 cnnotes
📂 所属分类数学计算
🏷️ 相关标签

#版本 #源程序
⌨️ 快捷键说明

复制代码 Ctrl + C
搜索代码 Ctrl + F
全屏模式 F11
切换主题 Ctrl + Shift + D
显示快捷键 ?
增大字号 Ctrl + =
减小字号 Ctrl + -