force.cpp

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

// FORCE.cpp : Defines the initialization routines for the DLL.
//

#include "stdafx.h"
#include "FORCE.h"
#include "GlobalElement.h"
#include "load.h"

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

BEGIN_MESSAGE_MAP(CFORCEApp, CWinApp)
	//{{AFX_MSG_MAP(CFORCEApp)
		// NOTE - the ClassWizard will add and remove mapping macros here.
		//    DO NOT EDIT what you see in these blocks of generated code!
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CFORCEApp construction

CFORCEApp::CFORCEApp()
{
	// TODO: add construction code here,
	// Place all significant initialization in InitInstance
}

/////////////////////////////////////////////////////////////////////////////
// The one and only CFORCEApp object

CFORCEApp theApp;
/*
BOOL CFORCEApp::InitInstance()
{
	CWinApp::InitInstance();
	return true;
}   */


//版本号输出函数
extern "C" __declspec(dllexport) double __stdcall Version();
double __stdcall Version()
{
	double version = 1.3;
	return version;
}

//V1.2 模式的操作函数，输出twm格式的文件，靠读文本
extern "C" __declspec(dllexport) bool __stdcall Engine(char* FilePath);
bool __stdcall Engine(char* FilePath)
{
	AFX_MANAGE_STATE(AfxGetStaticModuleState());	

	CGlobalElement GM; 
	GM.Initial(FilePath);
	GM.StructureSolve();
	return true;
}

//V1.3 模式的操作函数，输入（荷载）或输出（内力、位移、反力）完全靠内存操作

extern "C" __declspec(dllexport) bool __stdcall NewEngine(char* FilePath,
														  int m_nNodeLoadNum_Case1);
bool __stdcall Engine(char* FilePath,
					  int m_nNodeLoadNum_Case1,
					  int m_nNodeLoadNum_Case2,
					  int m_nElemLoadNum_Case1_Dis,
					  int m_nElemLoadNum_Case2_Dis,
					  int m_nElemLoadNum_Case1_Cen,
					  int m_nElemLoadNum_Case2_Cen,
					 
					  double** m_adJointLoadValue_Case1,
					  double** m_adJointLoadValue_Case2,
					  double** m_adElemLoadValue_Case1_Dis,
					  double** m_adElemLoadValue_Case2_Dis,
					  double** m_adElemLoadValue_Case1_Cen,
					  double** m_adElemLoadValue_Case2_Cen,
					  double& m_aElemInForceDef,
					  double& m_aElemDeflection,
					  double& SupportReaction)
{
	CGlobalElement GM; 
	GM.Initial(FilePath);

	CLoad load;
	//荷载变量数量用于循环
	load.m_nNodeLoadNum_Case1 = m_nNodeLoadNum_Case1;
	load.m_nNodeLoadNum_Case2 = m_nNodeLoadNum_Case2;
	load.m_nElemLoadNum_Case1_Dis = m_nElemLoadNum_Case1_Dis;
	load.m_nElemLoadNum_Case2_Dis = m_nElemLoadNum_Case2_Dis;
	load.m_nElemLoadNum_Case1_Cen = m_nElemLoadNum_Case1_Cen;
	load.m_nElemLoadNum_Case2_Cen = m_nElemLoadNum_Case2_Cen;

	//具体荷载数值
	//节点荷载case1
	load.m_adJointLoadValue_Case1.SetSize(load.m_nNodeLoadNum_Case1);
	for(int loop=0;loop<load.m_nNodeLoadNum_Case1;loop++)
	{
		load.m_adJointLoadValue_Case1[loop].m_nNodeNO = int(m_adJointLoadValue_Case1[loop][0]);
		load.m_adJointLoadValue_Case1[loop].m_dFX =     m_adJointLoadValue_Case1[loop][1];
		load.m_adJointLoadValue_Case1[loop].m_dFY =     m_adJointLoadValue_Case1[loop][2];
		load.m_adJointLoadValue_Case1[loop].m_dFZ =     m_adJointLoadValue_Case1[loop][3];
		load.m_adJointLoadValue_Case1[loop].m_dMX =     m_adJointLoadValue_Case1[loop][4];
		load.m_adJointLoadValue_Case1[loop].m_dMY =     m_adJointLoadValue_Case1[loop][5];
		load.m_adJointLoadValue_Case1[loop].m_dMZ =     m_adJointLoadValue_Case1[loop][6];		
	}

	//节点荷载case2
	load.m_adJointLoadValue_Case2.SetSize(load.m_nNodeLoadNum_Case2);
	for(loop=0;loop<load.m_nNodeLoadNum_Case2;loop++)
	{
		load.m_adJointLoadValue_Case2[loop].m_nNodeNO = int(m_adJointLoadValue_Case2[loop][0]);
		load.m_adJointLoadValue_Case2[loop].m_dFX =     m_adJointLoadValue_Case2[loop][1];
		load.m_adJointLoadValue_Case2[loop].m_dFY =     m_adJointLoadValue_Case2[loop][2];
		load.m_adJointLoadValue_Case2[loop].m_dFZ =     m_adJointLoadValue_Case2[loop][3];
		load.m_adJointLoadValue_Case2[loop].m_dMX =     m_adJointLoadValue_Case2[loop][4];
		load.m_adJointLoadValue_Case2[loop].m_dMY =     m_adJointLoadValue_Case2[loop][5];
		load.m_adJointLoadValue_Case2[loop].m_dMZ =     m_adJointLoadValue_Case2[loop][6];	
	}

	//单元均布荷载一
	load.m_adElemLoadValue_Case1_Dis.SetSize(load.m_nElemLoadNum_Case1_Dis);
	for(loop=0;loop<load.m_nElemLoadNum_Case1_Dis;loop++)
	{
		load.m_adElemLoadValue_Case1_Dis[loop].m_nElementNO = int(m_adElemLoadValue_Case1_Dis[loop][0]);
		load.m_adElemLoadValue_Case1_Dis[loop].m_dElemForceX = m_adElemLoadValue_Case1_Dis[loop][1];
		load.m_adElemLoadValue_Case1_Dis[loop].m_dElemForceY = m_adElemLoadValue_Case1_Dis[loop][2];
		load.m_adElemLoadValue_Case1_Dis[loop].m_dElemForceZ = m_adElemLoadValue_Case1_Dis[loop][3];
	}

	//单元均布荷载二
	load.m_adElemLoadValue_Case2_Dis.SetSize(load.m_nElemLoadNum_Case2_Dis);
	for(loop=0;loop<load.m_nElemLoadNum_Case2_Dis;loop++)
	{
		load.m_adElemLoadValue_Case2_Dis[loop].m_nElementNO = int(m_adElemLoadValue_Case2_Dis[loop][0]);
		load.m_adElemLoadValue_Case2_Dis[loop].m_dElemForceX = m_adElemLoadValue_Case2_Dis[loop][1];
		load.m_adElemLoadValue_Case2_Dis[loop].m_dElemForceY = m_adElemLoadValue_Case2_Dis[loop][2];
		load.m_adElemLoadValue_Case2_Dis[loop].m_dElemForceZ = m_adElemLoadValue_Case2_Dis[loop][3];
	}

	//单元集中荷载一
	load.m_adElemLoadValue_Case1_Cen.SetSize(m_nElemLoadNum_Case1_Cen);
	for(loop=0;loop<load.m_nElemLoadNum_Case1_Cen;loop++)
	{
		load.m_adElemLoadValue_Case1_Cen[loop].m_nElementNO = int(m_adElemLoadValue_Case1_Cen[loop][0]);
		load.m_adElemLoadValue_Case1_Cen[loop].m_dDistance =   m_adElemLoadValue_Case1_Cen[loop][1];
		load.m_adElemLoadValue_Case1_Cen[loop].m_dElemForceX = m_adElemLoadValue_Case1_Cen[loop][2];
		load.m_adElemLoadValue_Case1_Cen[loop].m_dElemForceY = m_adElemLoadValue_Case1_Cen[loop][3];
		load.m_adElemLoadValue_Case1_Cen[loop].m_dElemForceZ = m_adElemLoadValue_Case1_Cen[loop][4];
		load.m_adElemLoadValue_Case1_Cen[loop].m_dElemMX =     m_adElemLoadValue_Case1_Cen[loop][5];
		load.m_adElemLoadValue_Case1_Cen[loop].m_dElemMY =     m_adElemLoadValue_Case1_Cen[loop][6];
		load.m_adElemLoadValue_Case1_Cen[loop].m_dElemMZ =     m_adElemLoadValue_Case1_Cen[loop][7];
	}

	//单元集中荷载二
	load.m_adElemLoadValue_Case2_Cen.SetSize(m_nElemLoadNum_Case2_Cen);
	for(loop=0;loop<load.m_nElemLoadNum_Case2_Cen;loop++)
	{
		load.m_adElemLoadValue_Case2_Cen[loop].m_nElementNO = int(m_adElemLoadValue_Case2_Cen[loop][0]);
		load.m_adElemLoadValue_Case2_Cen[loop].m_dDistance =   m_adElemLoadValue_Case2_Cen[loop][1];
		load.m_adElemLoadValue_Case2_Cen[loop].m_dElemForceX = m_adElemLoadValue_Case2_Cen[loop][2];
		load.m_adElemLoadValue_Case2_Cen[loop].m_dElemForceY = m_adElemLoadValue_Case2_Cen[loop][3];
		load.m_adElemLoadValue_Case2_Cen[loop].m_dElemForceZ = m_adElemLoadValue_Case2_Cen[loop][4];
		load.m_adElemLoadValue_Case2_Cen[loop].m_dElemMX =     m_adElemLoadValue_Case2_Cen[loop][5];
		load.m_adElemLoadValue_Case2_Cen[loop].m_dElemMY =     m_adElemLoadValue_Case2_Cen[loop][6];
		load.m_adElemLoadValue_Case2_Cen[loop].m_dElemMZ =     m_adElemLoadValue_Case2_Cen[loop][7];
	}

	//计算，先输出文本结果twm测试，以后再输出内存
	GM.StructureSolve();

	return true;
}