oopfeview.cpp

一个计算悬臂梁的有限元vc源码

// OOPFEView.cpp : implementation of the COOPFEView class
//

#include "stdafx.h"
#include "math.h"
#include "OOPFE.h"
#include "GlobalElement.h"
#include "OOPFEDoc.h"
#include "OOPFEView.h"
#include "DlgDisplaySet.h"

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

#define DISPLAY_DATA 1
#define DISPLAY_ELEMENT 2
#define DISPLAY_MOMENT 3
#define DISPLAY_SHEAR 4
#define DISPLAY_DEFORMATION 5
#define DISPLAY_TSTRESS 6
#define DISPLAY_CSTRESS 7
#define DISPLAY_MODE_SHAPES 8
#define DISPLAY_VIBRATION 9
#define DISPLAY_AXIAL_FORCE 10

#define TRUSS 0
#define BEAM 1
#define BEAM_HINGE 2
#define PLANE_8NODE_ELE 3

#define PI 3.1415926535897932384626433832795

/////////////////////////////////////////////////////////////////////////////
// COOPFEView

IMPLEMENT_DYNCREATE(COOPFEView, CScrollView)

BEGIN_MESSAGE_MAP(COOPFEView, CScrollView)
	//{{AFX_MSG_MAP(COOPFEView)
	ON_COMMAND(ID_DISPLAY_MOMENT, OnDisplayMoment)
	ON_COMMAND(ID_DISPLAY_SHEAR, OnDisplayShear)
	ON_COMMAND(ID_DISPLAY_DEFORMATION, OnDisplayDeformation)
	ON_COMMAND(ID_DISPLAY_CSTRESS, OnDisplayCompressionStress)
	ON_COMMAND(ID_DISPLAY_TSTRESS, OnDisplayTensionStress)
	ON_COMMAND(ID_DISPLAY_ZOOMIN, OnDisplayZoomIn)
	ON_COMMAND(ID_DISPLAY_ZOOMOUT, OnDisplayZoomOut)
	ON_COMMAND(ID_DISPLAY_ELEMENT, OnDisplayElement)
	ON_COMMAND(ID_DISPLAY_DATA, OnDisplayData)
	ON_COMMAND(ID_DISPALY_SETTINGS, OnDispalySettings)
	ON_COMMAND(ID_OUTPUT_DXF_DEFORMATION, OnOutputDxfDeformation)
	ON_COMMAND(ID_OUTPUT_DXF_MOMENT, OnOutputDxfMoment)
	ON_COMMAND(ID_OUTPUT_DXF_SHEAR, OnOutputDxfShear)
	ON_COMMAND(ID_OUTPUT_DXF_TSTRESS, OnOutputDxfTensionStress)
	ON_COMMAND(ID_OUTPUT_DXF_CSTRESS, OnOutputDxfCompressionStress)
	ON_COMMAND(ID_DISPLAY_MODE_SHAPES_PREVIOUS, OnDisplayModeShapesPrevious)
	ON_COMMAND(ID_DISPLAY_MODE_SHAPES_NEXT, OnDisplayModeShapesNext)
	ON_COMMAND(ID_DISPLAY_VIBRATION, OnDisplayVibration)
	ON_COMMAND(ID_OUTPUT_DXF_MODE_SHAPES, OnOutputDxfModeShapes)
	ON_COMMAND(ID_DISPLAY_ANIMATION_QUICK, OnDisplayAnimationQuick)
	ON_COMMAND(ID_DISPLAY_ANIMATION_SLOW, OnDisplayAnimationSlow)
	ON_COMMAND(ID_DISPLAY_AXIAL_FORCE, OnDisplayAxialForce)
	ON_COMMAND(ID_BUTTON_ZOOMIN, OnDisplayZoomIn)
	ON_COMMAND(ID_BUTTON_ZOOMOUT, OnDisplayZoomOut)
	ON_COMMAND(ID_BUTTON_MODE_NEXT, OnDisplayModeShapesNext)
	ON_COMMAND(ID_BUTTON_MODE_PREVIOUS, OnDisplayModeShapesPrevious)
	ON_COMMAND(ID_BUTTON_DISPLAY_VIBRATION, OnDisplayVibration)
	ON_COMMAND(ID_BUTTON_DISPLAY_ANIMATION_SLOW, OnDisplayAnimationSlow)
	ON_COMMAND(ID_BUTTON_DISPLAY_ANIMATION_QUICK, OnDisplayAnimationQuick)
	ON_COMMAND(ID_OUTPUT_DXF_AXIAL_FORCE, OnOutputDxfAxialForce)
	//}}AFX_MSG_MAP
	// Standard printing commands
	ON_COMMAND(ID_FILE_PRINT, CScrollView::OnFilePrint)
	ON_COMMAND(ID_FILE_PRINT_DIRECT, CScrollView::OnFilePrint)
	ON_COMMAND(ID_FILE_PRINT_PREVIEW, CScrollView::OnFilePrintPreview)
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// COOPFEView construction/destruction

COOPFEView::COOPFEView()
{
	// TODO: add construction code here
	m_dInitScaleRtoD=0.0;
	m_nMaxShearDot=m_nMaxDispDot=m_nMaxMomentDot=m_nMaxAxialForceDot=50;
	m_nFontSize=12;
	m_dZoomTimes=0.0;
	m_sizeInitTotal.cx=600;
	m_sizeInitTotal.cy=400;
	m_iAnimationSpeed=18;
}

COOPFEView::~COOPFEView()
{
}

BOOL COOPFEView::PreCreateWindow(CREATESTRUCT& cs)
{
	// TODO: Modify the Window class or styles here by modifying
	//  the CREATESTRUCT cs

	return CScrollView::PreCreateWindow(cs);
}

/////////////////////////////////////////////////////////////////////////////
// COOPFEView drawing

void COOPFEView::OnDraw(CDC* pDC)
{
	COOPFEDoc* pDoc = GetDocument();
	ASSERT_VALID(pDoc);
	// TODO: add draw code for native data here
	switch(pDoc->m_iDisplay){
	case DISPLAY_DATA:
		DisplayData(pDC,pDoc);
		break;
	case DISPLAY_ELEMENT:
		DisplayElement(pDC,pDoc);
		break;
	case DISPLAY_MOMENT:
		DisplayMoment(pDC,pDoc);
		break;
	case DISPLAY_SHEAR:
		DisplayShear(pDC,pDoc);
		break;
	case DISPLAY_DEFORMATION:
		DisplayDeformation(pDC,pDoc);
		break;
	case DISPLAY_TSTRESS:
		DisplayTensionStress(pDC,pDoc);
		break;
	case DISPLAY_CSTRESS:
		DisplayCompressionStress(pDC,pDoc);
		break;
	case DISPLAY_MODE_SHAPES:
		DisplayModeShapes(pDC,pDoc);
		break;
	case DISPLAY_VIBRATION:
		DisplayVibration(pDC,pDoc);
		break;
	case DISPLAY_AXIAL_FORCE:
		DisplayAxialForce(pDC,pDoc);
		break;
	}
}

/////////////////////////////////////////////////////////////////////////////
// COOPFEView printing

BOOL COOPFEView::OnPreparePrinting(CPrintInfo* pInfo)
{
	// default preparation
	return DoPreparePrinting(pInfo);
}

void COOPFEView::OnBeginPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/)
{
	// TODO: add extra initialization before printing
}

void COOPFEView::OnEndPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/)
{
	// TODO: add cleanup after printing
}

/////////////////////////////////////////////////////////////////////////////
// COOPFEView diagnostics

#ifdef _DEBUG
void COOPFEView::AssertValid() const
{
	CScrollView::AssertValid();
}

void COOPFEView::Dump(CDumpContext& dc) const
{
	CScrollView::Dump(dc);
}

COOPFEDoc* COOPFEView::GetDocument() // non-debug version is inline
{
	ASSERT(m_pDocument->IsKindOf(RUNTIME_CLASS(COOPFEDoc)));
	return (COOPFEDoc*)m_pDocument;
}
#endif //_DEBUG

/////////////////////////////////////////////////////////////////////////////
// COOPFEView message handlers

void COOPFEView::OnInitialUpdate()
{
	CScrollView::OnInitialUpdate();
	CSize sizeTotal;
	// TODO: calculate the total size of this view
	sizeTotal.cx = sizeTotal.cy = 300;
	SetScrollSizes(MM_TEXT, sizeTotal);
}

void COOPFEView::DisplayElement(CDC *pDC,COOPFEDoc* pDoc)
{
	int nEle,nEleNode,nNode,aiNode[8];
	int loop,loop1;
	double dMaxX,dMaxY;
	double dX,dY,dBuf;
	CPoint aPt[8];
	CTypedPtrArray <CPtrArray,CBaseElement*>& apEle=pDoc->m_glEle.m_apEle;
	CNode& Node=pDoc->m_glEle.m_Node;
	CSize sizeTotal,sizePage,sizeLine;
	CRect rect;
	CString sText;
	CFont *pOldFont,fontNode,fontEle;
	
	SetFont(fontNode,"Times New Roman",m_nFontSize,0.0);
	SetFont(fontEle,"Times New Roman",m_nFontSize+4,0.0);

	if(pDoc->m_bNew){
		pDoc->m_bNew=false;
		m_sizeInitTotal.cx=600;
		m_sizeInitTotal.cy=400;
		nNode=Node.GetNum();
		if(nNode>0){
			dMaxX=m_dMinX=Node.GetX(0);
			dMaxY=m_dMinY=Node.GetY(0);
		}
		for(loop=0;loop<nNode;loop++){
			dBuf=Node.GetX(loop);
			if(dMaxX<dBuf) dMaxX=dBuf;
			if(m_dMinX>dBuf) m_dMinX=dBuf;
			dBuf=Node.GetY(loop);
			if(dMaxY<dBuf) dMaxY=dBuf;
			if(m_dMinY>dBuf) m_dMinY=dBuf;
		}
		m_dInitScaleRtoD=m_sizeInitTotal.cx/(dMaxX-m_dMinX);
		dBuf=m_sizeInitTotal.cy/(dMaxY-m_dMinY);
		if(m_dInitScaleRtoD>dBuf){
			m_dInitScaleRtoD=dBuf;
			m_sizeInitTotal.cx=(int)((dMaxY-m_dMinY)*m_dInitScaleRtoD);
		}
		else{
			m_sizeInitTotal.cy=(int)((dMaxY-m_dMinY)*m_dInitScaleRtoD);
		}
	}

	m_dScaleRtoD=m_dInitScaleRtoD+m_dInitScaleRtoD*0.2*m_dZoomTimes;
	GetClientRect(&rect);
	sizePage.cx=rect.right;
	sizePage.cy=rect.bottom;
	sizeLine.cx=sizePage.cx/10;
	sizeLine.cy=sizePage.cy/10;
	if(m_dInitScaleRtoD==0) return;
	sizeTotal.cx = (int)(m_sizeInitTotal.cx*m_dScaleRtoD/m_dInitScaleRtoD)+200;
	sizeTotal.cy = (int)(m_sizeInitTotal.cy*m_dScaleRtoD/m_dInitScaleRtoD)+200;
	
	SetScrollSizes(MM_TEXT,sizeTotal,sizePage,sizeLine);
	m_ptBase.x=100;
	m_ptBase.y=(int)(sizeTotal.cy-100);

	CPen pen(PS_SOLID,2,RGB(0,0,0));
	CPen *pOldPen;
	pOldPen=pDC->SelectObject(&pen);
	pOldFont=pDC->SelectObject(&fontEle);
	pDC->SetTextColor(RGB(255,0,0));
	nEle=apEle.GetSize();
	for(loop=0;loop<nEle;loop++){
		apEle[loop]->GetNode(aiNode,nEleNode);
		for(loop1=0;loop1<nEleNode;loop1++){
			dX=Node.GetX(aiNode[loop1]);
			dY=Node.GetY(aiNode[loop1]);
			aPt[loop1].x=m_ptBase.x+(int)((dX-m_dMinX)*m_dScaleRtoD);
			aPt[loop1].y=m_ptBase.y-(int)((dY-m_dMinY)*m_dScaleRtoD);
		}
		pDC->MoveTo(aPt[0]);
		for(loop1=0;loop1<nEleNode;loop1++){
			pDC->LineTo(aPt[loop1]);
		}
		pDC->LineTo(aPt[0]);

		if(pDoc->m_iDisplay==DISPLAY_ELEMENT){
			dX=dY=0.0;
			for(loop1=0;loop1<nEleNode;loop1++){
				dX+=aPt[loop1].x;
				dY+=aPt[loop1].y;
			}
			aPt[0].x=(int)(dX/nEleNode)-2;
			aPt[0].y=(int)(dY/nEleNode)-8;
			sText.Format("%d",loop);
			pDC->TextOut(aPt[0].x,aPt[0].y,sText);
		}
	}

	if(pDoc->m_iDisplay==DISPLAY_ELEMENT){
		pDC->SelectObject(&fontNode);
		pDC->SetTextColor(RGB(0,0,255));
		nNode=Node.GetNum();
		for(loop=0;loop<nNode;loop++){
			aPt[0].x=m_ptBase.x+(int)((Node.GetX(loop)-m_dMinX)*m_dScaleRtoD)+1;
			aPt[0].y=m_ptBase.y-(int)((Node.GetY(loop)-m_dMinY)*m_dScaleRtoD)+1;
			sText.Format("%d",loop);
			pDC->TextOut(aPt[0].x,aPt[0].y,sText);
		}
	}
	pDC->SelectObject(pOldFont);
	pDC->SelectObject(pOldPen);
}

void COOPFEView::DisplayShear(CDC *pDC,COOPFEDoc* pDoc)
{
	int loop,loop1,iBuf,nEle,nEleNode,aiNode[2];
	double adM[11],adQ[11],dN,dMaxShear;
	double dRationShearRtoD;
	double dCos,dSin,dLength,dAngle;
	double dXi0,dXj0,dXk0,dYi0,dYj0,dYk0;
	int iOldBkMode=pDC->SetBkMode(TRANSPARENT);
	CString sText;
	CFont font,*pOldFont;

	CTypedPtrArray <CPtrArray,CBaseElement*>& apEle=pDoc->m_glEle.m_apEle;
	CNode& Node=pDoc->m_glEle.m_Node;
	CPoint aPt[20];
	
	DisplayElement(pDC,pDoc);
	if(!pDoc->m_glEle.m_bFlagForceAnalyzed) return;

	CPen pen(PS_SOLID,1,RGB(255,0,0));
	CPen* pOldPen;
	pOldPen=pDC->SelectObject(&pen);

	dMaxShear=0.0;
	nEle=apEle.GetSize();
	for(loop=0;loop<nEle;loop++){
		iBuf=apEle[loop]->GetElementType();
		if(iBuf==BEAM||iBuf==BEAM_HINGE){
			((CBeam*)apEle[loop])->GetSectionForce(dN,adQ,adM);
			for(loop1=0;loop1<11;loop1++){
				if(adM[loop1]<0.0){
					if(dMaxShear<-adQ[loop1]) dMaxShear=-adQ[loop1];
				}
				else{
					if(dMaxShear<adQ[loop1]) dMaxShear=adQ[loop1];
				}
			}
		}
	}
	dRationShearRtoD=m_nMaxShearDot/dMaxShear;

	for(loop=0;loop<nEle;loop++){
		iBuf=apEle[loop]->GetElementType();
		if(iBuf==BEAM||iBuf==BEAM_HINGE){
			((CBeam*)apEle[loop])->GetSectionForce(dN,adQ,adM);
			dLength=((CBeam*)apEle[loop])->GetLength();
			apEle[loop]->GetNode(aiNode,nEleNode);
			dXi0=Node.GetX(aiNode[0]);
			dYi0=Node.GetY(aiNode[0]);
			dXj0=Node.GetX(aiNode[1]);
			dYj0=Node.GetY(aiNode[1]);
			dCos=(dXj0-dXi0)/dLength;
			dSin=(dYj0-dYi0)/dLength;
			
			aPt[0].x=m_ptBase.x+(int)((dXi0-m_dMinX)*m_dScaleRtoD);
			aPt[0].y=m_ptBase.y-(int)((dYi0-m_dMinY)*m_dScaleRtoD);
			for(loop1=0;loop1<11;loop1++){
				dXk0=m_ptBase.x+(int)((dXi0+(dXj0-dXi0)*loop1/10.0-m_dMinX)*m_dScaleRtoD);
				dYk0=m_ptBase.y-(int)((dYi0+(dYj0-dYi0)*loop1/10.0-m_dMinY)*m_dScaleRtoD);
				aPt[loop1+1].x=(int)dXk0+(int)(adQ[loop1]*dSin*dRationShearRtoD);
				aPt[loop1+1].y=(int)dYk0+(int)(adQ[loop1]*dCos*dRationShearRtoD);
			}
			aPt[12].x=m_ptBase.x+(int)((dXj0-m_dMinX)*m_dScaleRtoD);
			aPt[12].y=m_ptBase.y-(int)((dYj0-m_dMinY)*m_dScaleRtoD);

			pDC->MoveTo(aPt[0]);
			for(loop1=0;loop1<13;loop1++){
				pDC->LineTo(aPt[loop1]);
			}

			dAngle=atan2(dYj0-dYi0, dXj0-dXi0)*180.0/PI;	
			SetFont(font,"Times New Roman",m_nFontSize,dAngle);
			pDC->SetTextColor(RGB(0,0,0));
			pOldFont=pDC->SelectObject(&font);
		
			sText.Format("%0.3f",adQ[0]);
			pDC->TextOut(aPt[1].x,aPt[1].y,sText);
			sText.Format("%0.3f",adQ[10]);
			pDC->TextOut(aPt[11].x,aPt[11].y,sText);

			pDC->SelectObject(pOldFont);
			font.DeleteObject();	 
		}
	}
	pDC->SelectObject(pOldPen);
	pDC->SetBkMode(iOldBkMode);
}

void COOPFEView::OnDisplayMoment() 
{
	// TODO: Add your command handler code here
	COOPFEDoc* pDoc = GetDocument();
	ASSERT_VALID(pDoc);
	pDoc->m_iDisplay=DISPLAY_MOMENT;
	Invalidate();
	UpdateWindow();
}

void COOPFEView::OnDisplayShear() 
{
	// TODO: Add your command handler code here
	COOPFEDoc* pDoc = GetDocument();
	ASSERT_VALID(pDoc);
	pDoc->m_iDisplay=DISPLAY_SHEAR;
	Invalidate();
	UpdateWindow();	
}


void COOPFEView::OnDisplayDeformation() 
{
	// TODO: Add your command handler code here
	COOPFEDoc* pDoc = GetDocument();
	ASSERT_VALID(pDoc);
	pDoc->m_iDisplay=DISPLAY_DEFORMATION;
	Invalidate();
	UpdateWindow();	
}


void COOPFEView::DisplayMoment(CDC *pDC,COOPFEDoc* pDoc)
{
	int loop,loop1,iBuf,nEle,nEleNode,aiNode[2];
	double adM[11],adQ[11],dN,dMaxMoment;
	double dScaleMomentToD;
	double dCos,dSin,dLength,dAngle;
	double dXi0,dXj0,dXk0,dYi0,dYj0,dYk0;
	int iOldBkMode=pDC->SetBkMode(TRANSPARENT);
	CString sText;
	CFont font,*pOldFont;
	
	CTypedPtrArray <CPtrArray,CBaseElement*>& apEle=pDoc->m_glEle.m_apEle;
	CNode& Node=pDoc->m_glEle.m_Node;
	CPoint aPt[20];
	
	DisplayElement(pDC,pDoc);
	if(!pDoc->m_glEle.m_bFlagForceAnalyzed) return;

	CPen pen(PS_SOLID,1,RGB(255,0,0));