node.cpp

三维框架梁单元C++版本的源程序 可以使结构力学的概念更上升一个层次

#include "stdafx.h"
//#include "FORCE.h"
#include "Node.h"

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

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

CNode::CNode(void)
{
	//节点数量
	m_nNodeNum = 0;
	m_nNode_K_Num = 0;

	//约束节点数量
	m_nNodeFixNum = 0;
}

CNode::~CNode(void)
{
	OutputParameter();
}

void CNode::ReadFile(CString m_cFilePath)
{
	//临时变量
	char char1[100];
	int m_N;
	double m_D;
	bool m_bRUN1 = 0; // 控制运行的变量1
	bool m_bRUN2 = 0; // 控制运行的变量2

	ifstream fin;
	fin.open(m_cFilePath,ios::in);	

	while(!fin.eof())
	{
		fin>>char1;	
    	if(!strcmp(char1,"DEFINE_NODE_START"))
		{
			m_bRUN1= 1;
			fin>>char1;	
			m_N = atoi(char1);
			m_nNode_K_Num = m_N;
		}

		while(m_bRUN1)	
		{	
			fin>>char1;	
			//到定义的结尾了
			if(!strcmp(char1,"DEFINE_NODE_END"))  
			{				
				m_bRUN1 = 0;
				break;	
			}
			if(!strcmp(char1,"N"))
			{
				m_nNodeNum++;
				m_CaNodeCoor.SetSize(m_nNodeNum);
				fin>>char1;	
				m_N = atoi(char1);
				m_CaNodeCoor[m_nNodeNum-1].m_aiNode = m_N;
				fin>>char1;	
				m_D = atof(char1);
				m_CaNodeCoor[m_nNodeNum-1].m_adX = m_D;
				fin>>char1;	
				m_D = atof(char1);
				m_CaNodeCoor[m_nNodeNum-1].m_adY = m_D;
				fin>>char1;	
				m_D = atof(char1);
				m_CaNodeCoor[m_nNodeNum-1].m_adZ = m_D;
			}
		}
	}
	fin.close();

	fin.open(m_cFilePath,ios::in);	
	while(!fin.eof())
	{
		fin>>char1;	    
		if(!strcmp(char1,"RESTRICT_LOAD_START"))			
			m_bRUN2= 1;			

		while(m_bRUN2)
		{
			fin>>char1;	
			//到定义的结尾了		
			if(!strcmp(char1,"RESTRICT_LOAD_END"))  
			{				
				m_bRUN2 = 0;
				break;	
			}

			//约束节点号
			int FixNodeNo = atoi(char1);			
			//操作位置
			int OperateNo = -1;

			//判断是否重复编号，并确定位置
			for(int loop=0;loop<m_nNodeFixNum;loop++)
			{
				if(m_CaNodeFix[loop].m_aiConstrainedNode==FixNodeNo)
				{
					OperateNo = loop;	
					AfxMessageBox("约束节点有重复编号！",MB_OK,1);///////////////////////
				}
			}

			//如非重复编号，需要初始化，并且确定位置
			if(OperateNo == -1) 
			{	
				m_nNodeFixNum++;
				m_CaNodeFix.SetSize(m_nNodeFixNum);
				OperateNo = m_nNodeFixNum -1;
				//约束情况初始化
				m_CaNodeFix[OperateNo].m_aiConstrainedNode = FixNodeNo;
				m_CaNodeFix[OperateNo].m_aiIsFixedX = 0;
				m_CaNodeFix[OperateNo].m_aiIsFixedY = 0;
				m_CaNodeFix[OperateNo].m_aiIsFixedZ = 0;
				m_CaNodeFix[OperateNo].m_aiIsFixedRX = 0;
				m_CaNodeFix[OperateNo].m_aiIsFixedRY = 0;
				m_CaNodeFix[OperateNo].m_aiIsFixedRZ = 0;
			}

			//停止逻辑符号
			bool bEOF = 1;
			while(bEOF)
			{	
				fin>>char1;
				if(!strcmp(char1,"EOF"))
				{
					//到头了
					bEOF = 0;	
					//AfxMessageBox("一行结束！",MB_OK,0);////////////////////
					break;	
				}
				else 
				{
					if(!strcmp(char1,"UX"))	
						m_CaNodeFix[OperateNo].m_aiIsFixedX = 1;
					if(!strcmp(char1,"UY"))	
						m_CaNodeFix[OperateNo].m_aiIsFixedY = 1;
					if(!strcmp(char1,"UZ"))	
						m_CaNodeFix[OperateNo].m_aiIsFixedZ = 1;
					if(!strcmp(char1,"ROTX"))
						m_CaNodeFix[OperateNo].m_aiIsFixedRX = 1;
					if(!strcmp(char1,"ROTY"))
						m_CaNodeFix[OperateNo].m_aiIsFixedRY = 1;
					if(!strcmp(char1,"ROTZ"))
						m_CaNodeFix[OperateNo].m_aiIsFixedRZ = 1;
				}
			}
		}
	}
	fin.close();


	//***********************计算自由度的函数应用内嵌在此***********************
	CalcuDOFIndex();	
}

void  CNode::CalcuDOFIndex()
{
	//总的自由度数	
	m_nTotalDOF = (m_nNodeNum - m_nNode_K_Num)*6;

	//约束的自由度数
	m_nRestrictDOF = 0;
	for(int loop=0;loop<m_nNodeFixNum;loop++)
	{
		m_nRestrictDOF += m_CaNodeFix[loop].m_aiIsFixedX;
		m_nRestrictDOF += m_CaNodeFix[loop].m_aiIsFixedY;
		m_nRestrictDOF += m_CaNodeFix[loop].m_aiIsFixedZ;
		m_nRestrictDOF += m_CaNodeFix[loop].m_aiIsFixedRX;
		m_nRestrictDOF += m_CaNodeFix[loop].m_aiIsFixedRY;
		m_nRestrictDOF += m_CaNodeFix[loop].m_aiIsFixedRZ;
	}
	//非约束自由度数
	m_nFreeDOF = m_nTotalDOF - m_nRestrictDOF;	

	//自由度序列编号
	//初始化
	m_aDOFIndex.SetSize(m_nNodeNum - m_nNode_K_Num);
	for(loop=0;loop<(m_nNodeNum - m_nNode_K_Num);loop++)
	{
		m_aDOFIndex[loop].m_aiNode = m_CaNodeCoor[loop].m_aiNode;
		m_aDOFIndex[loop].m_aiDOFIndex_X = 0;
		m_aDOFIndex[loop].m_aiDOFIndex_Y = 0;
		m_aDOFIndex[loop].m_aiDOFIndex_Z = 0;
		m_aDOFIndex[loop].m_aiDOFIndex_RX = 0;
		m_aDOFIndex[loop].m_aiDOFIndex_RY = 0;
		m_aDOFIndex[loop].m_aiDOFIndex_RZ = 0;
	}
	//如果被约束，置为－1
	for(loop=0;loop<(m_nNodeNum - m_nNode_K_Num);loop++)
	{
		for(int loop1=0;loop1<m_nNodeFixNum;loop1++)
		{
			if(m_aDOFIndex[loop].m_aiNode == m_CaNodeFix[loop1].m_aiConstrainedNode)
			{
				m_aDOFIndex[loop].m_aiDOFIndex_X = -m_CaNodeFix[loop1].m_aiIsFixedX;
				m_aDOFIndex[loop].m_aiDOFIndex_Y = -m_CaNodeFix[loop1].m_aiIsFixedY;
				m_aDOFIndex[loop].m_aiDOFIndex_Z = -m_CaNodeFix[loop1].m_aiIsFixedZ;
				m_aDOFIndex[loop].m_aiDOFIndex_RX = -m_CaNodeFix[loop1].m_aiIsFixedRX;
				m_aDOFIndex[loop].m_aiDOFIndex_RY = -m_CaNodeFix[loop1].m_aiIsFixedRY;
				m_aDOFIndex[loop].m_aiDOFIndex_RZ = -m_CaNodeFix[loop1].m_aiIsFixedRZ;
			}
		}
	}

	int iDOFIndex = 0; //当前自由度序列编号从零开始 (前++和后++不一样！)
	int iBuf = m_nFreeDOF; //受约束自由度序列编号起始位置
	//进行结点自由度序列编号（要求节点必须按大小写排列！）
	for(loop=0;loop<(m_nNodeNum - m_nNode_K_Num);loop++)
	{
		//X
		if(m_aDOFIndex[loop].m_aiDOFIndex_X < 0)
			m_aDOFIndex[loop].m_aiDOFIndex_X = iBuf++;
		else
			m_aDOFIndex[loop].m_aiDOFIndex_X = iDOFIndex++;
		//Y
		if(m_aDOFIndex[loop].m_aiDOFIndex_Y < 0)
			m_aDOFIndex[loop].m_aiDOFIndex_Y = iBuf++;
		else
			m_aDOFIndex[loop].m_aiDOFIndex_Y = iDOFIndex++;
		//Z
		if(m_aDOFIndex[loop].m_aiDOFIndex_Z < 0)
			m_aDOFIndex[loop].m_aiDOFIndex_Z = iBuf++;
		else
			m_aDOFIndex[loop].m_aiDOFIndex_Z = iDOFIndex++;
		//RX
		if(m_aDOFIndex[loop].m_aiDOFIndex_RX < 0)
			m_aDOFIndex[loop].m_aiDOFIndex_RX = iBuf++;
		else
			m_aDOFIndex[loop].m_aiDOFIndex_RX = iDOFIndex++;
		//RY
		if(m_aDOFIndex[loop].m_aiDOFIndex_RY < 0)
			m_aDOFIndex[loop].m_aiDOFIndex_RY = iBuf++;
		else
			m_aDOFIndex[loop].m_aiDOFIndex_RY = iDOFIndex++;
		//RZ
		if(m_aDOFIndex[loop].m_aiDOFIndex_RZ < 0)
			m_aDOFIndex[loop].m_aiDOFIndex_RZ = iBuf++;
		else
			m_aDOFIndex[loop].m_aiDOFIndex_RZ = iDOFIndex++;
	}
}


void CNode::OutputParameter()
{
	ofstream fout;
	fout.open("Node Class Test.tst",ios::out);

	fout<<"节点数量     "<< m_nNodeNum<<endl;
	fout.width(10);
	fout<<"节点号";
	fout.width(10);
	fout<<"X Coor";
	fout.width(10);
	fout<<"Y Coor";
	fout.width(10);
	fout<<"Z Coor"<<endl;
	for(int loop=0;loop<m_nNodeNum;loop++)
	{
		fout.width(10);
		fout<<m_CaNodeCoor[loop].m_aiNode;
		fout.width(10);
		fout<<m_CaNodeCoor[loop].m_adX;
		fout.width(10);
		fout<<m_CaNodeCoor[loop].m_adY;
		fout.width(10);
		fout<<m_CaNodeCoor[loop].m_adZ<<endl;
	}	

	fout<<endl;
	fout<<endl;
	fout<<"约束节点的数量   "<<m_nNodeFixNum<<endl;
	fout.width(10);
	fout<<"节点号";
	fout.width(10);
	fout<<"FX";
	fout.width(10);
	fout<<"FY";
	fout.width(10);
	fout<<"FZ";
	fout.width(10);
	fout<<"ROTX";
	fout.width(10);
	fout<<"ROTY";
	fout.width(10);
	fout<<"ROTZ"<<endl;
	for(loop=0;loop<m_nNodeFixNum;loop++)
	{
		fout.width(10);
		fout<<m_CaNodeFix[loop].m_aiConstrainedNode;
		fout.width(10);
		fout<<m_CaNodeFix[loop].m_aiIsFixedX;
		fout.width(10);
		fout<<m_CaNodeFix[loop].m_aiIsFixedY;
		fout.width(10);
		fout<<m_CaNodeFix[loop].m_aiIsFixedZ;
		fout.width(10);
		fout<<m_CaNodeFix[loop].m_aiIsFixedRX;
		fout.width(10);
		fout<<m_CaNodeFix[loop].m_aiIsFixedRY;
		fout.width(10);
		fout<<m_CaNodeFix[loop].m_aiIsFixedRZ<<endl;
	}

	fout<<endl;
	fout<<"K点数量：     "<<m_nNode_K_Num<<endl;
	fout<<"m_nTotalDOF: "<<m_nTotalDOF<<endl;
	fout<<"m_nFreeDOF:  "<<m_nFreeDOF<<endl;

	fout<<endl;
	fout<<endl;
	fout<<endl;

	fout.width(10);
	fout<<"节点号";
	fout.width(10);
	fout<<"X";
	fout.width(10);
	fout<<"Y";
	fout.width(10);
	fout<<"Z";
	fout.width(10);
	fout<<"RX";
	fout.width(10);
	fout<<"RY";
	fout.width(10);
	fout<<"RZ";
	fout<<endl;

	for(loop=0;loop<(m_nNodeNum - m_nNode_K_Num);loop++)
	{
		fout.width(10);
		fout<<m_aDOFIndex[loop].m_aiNode;
		fout.width(10);
		fout<<m_aDOFIndex[loop].m_aiDOFIndex_X;
		fout.width(10);
		fout<<m_aDOFIndex[loop].m_aiDOFIndex_Y;
		fout.width(10);
		fout<<m_aDOFIndex[loop].m_aiDOFIndex_Z;
		fout.width(10);
		fout<<m_aDOFIndex[loop].m_aiDOFIndex_RX;
		fout.width(10);
		fout<<m_aDOFIndex[loop].m_aiDOFIndex_RY;
		fout.width(10);
		fout<<m_aDOFIndex[loop].m_aiDOFIndex_RZ;
		fout<<endl;
	}

	fout.close();
}