Филатов Е.Ю., Ясинский Ф.Н. Математическое моделирование течений жидкостей и газов

Подождите немного. Документ загружается.

void UpdatePsi (BOOL blOnlyAir); // Сделать шаг по вр. для поля Psi

void UpdateNu(); // Сделать шаг по времени для поля Nu

// Сделать шаг по времени (часть шага номер step) для модели kind

// (поле G, коэффициент alfa)

void UpdateG (int step, TModelKind kind, double **G, double alfa,

int G1, int G2, int G3, int G4);// (0,0) Г2

// Грагичные условия: ****

// 1 - первого рода; Г1 * * Г3

// 2 - первая производная = 0 ****

// 3 - вторая производная = 0 Г4

void FindForce(); // Вычислить F

};

Листинг 6. Проект Client, файл Client.cpp

// Client.cpp : Defines the entry point for the application.

#include "stdafx.h"

#include "Client.h"

#include "..\Model\Model.h"

#include "..\mpiconsts.h"

CModel Model;

int idProc, idPrev, idNext, nProcs;

int APIENTRY WinMain(HINSTANCE hInstance,

HINSTANCE hPrevInstance,

LPTSTR lpCmdLine,

int nCmdShow)

{

MPI_Init (NULL, NULL);

MPI_Comm_size (MPI_COMM_WORLD, &nProcs);

MPI_Comm_rank (MPI_COMM_WORLD, &idProc);

idPrev=idProc-1;

idNext=idProc+1;

if (idProc==nProcs-1) idNext=0;

Run();

MPI_Finalize();

return 0;

}

void Run()

{

int cmd=mpicmdNone;

MPI_Status status;

do {

if (idProc==1) MPI_Recv (&cmd, 1, MPI_INT, 0, mpitagCmd,

MPI_COMM_WORLD, &status);

else cmd=RecvFromPrev();

switch (cmd) {

case mpicmdExit:

SendToNext(cmd);

break;

case mpicmdInit:

SendToNext(cmd);

RecvKoefsFromServer();

break;

case mpicmdDone:

SendToNext(cmd);

break;

case mpicmdFieldsToServer:

SendFieldsToServer();

SendToNext(cmd);

MPI_Barrier(MPI_COMM_WORLD);

break;

case mpicmdNext:

SendToNext(cmd);

OnUpdate();

break;

case mpicmdError:

MessageBox (0, "The Client program generated an error", "Error",

MB_OK);

break; }

if (cmd!=mpicmdExit) cmd=mpicmdNone;

} while (cmd!=mpicmdExit);

}

void SendToNext (int cmd)

{

if (idNext) MPI_Send (&cmd, 1, MPI_INT, idNext, mpitagCmd,

MPI_COMM_WORLD);

}

int RecvFromPrev()

{

if (idPrev) {

int cmd;

MPI_Status status;

MPI_Recv (&cmd, 1, MPI_INT, idPrev, mpitagCmd, MPI_COMM_WORLD,

&status);

return cmd; }

else return mpicmdError;

}

void RecvKoefsFromServer()

{

int kLeft, kRight, kNuMethod;

int Nx, Ny;

double h, tau;

RECT Build;

MPI_Status status;

MPI_Recv (&kLeft, 1, MPI_INT, 0, MPI_ANY_TAG, MPI_COMM_WORLD,

&status);

MPI_Recv (&kRight, 1, MPI_INT, 0, MPI_ANY_TAG, MPI_COMM_WORLD,

&status);

MPI_Recv (&kNuMethod, 1, MPI_INT, 0, MPI_ANY_TAG, MPI_COMM_WORLD,

&status);

MPI_Recv (&Nx, 1, MPI_INT, 0, MPI_ANY_TAG, MPI_COMM_WORLD, &status);

MPI_Recv (&Ny, 1, MPI_INT, 0, MPI_ANY_TAG, MPI_COMM_WORLD, &status);

MPI_Recv (&h, 1, MPI_DOUBLE, 0, MPI_ANY_TAG, MPI_COMM_WORLD,

&status);

MPI_Recv (&tau, 1, MPI_DOUBLE, 0, MPI_ANY_TAG, MPI_COMM_WORLD,

&status);

MPI_Recv (&Build, sizeof(Model.Build), MPI_CHAR, 0, MPI_ANY_TAG,

MPI_COMM_WORLD, &status);

MPI_Barrier(MPI_COMM_WORLD);

Model.Init (kClientProc, kLeft, kRight, kNuMethod, Nx, Ny, h, tau,

Build);

}

void SendFieldsToServer()

{

int j, k;

for (j=0; j<=Model.Nx+1; j++)

for (k=0; k<nFields; k++)

MPI_Send (&Model.Fields[k][j][0], Model.Ny+2, MPI_DOUBLE,

0, mpiSomeTag, MPI_COMM_WORLD);

}

void OnUpdate()

{

Model.UpdateData();

// Обменяться границами

MPI_Status status;

for (int k=0; k<nFields; k++) {

if (idPrev) {

MPI_Recv (&Model.Fields[k][0][0], Model.Ny+1, MPI_DOUBLE,

idPrev, MPI_ANY_TAG, MPI_COMM_WORLD, &status);

MPI_Send (&Model.Fields[k][1][0], Model.Ny+1, MPI_DOUBLE,

idPrev, mpiSomeTag, MPI_COMM_WORLD); }

if (idNext) {

MPI_Send (&Model.Fields[k][Model.Nx][0], Model.Ny+1, MPI_DOUBLE,

idNext, mpiSomeTag, MPI_COMM_WORLD);

MPI_Recv (&Model.Fields[k][Model.Nx+1][0], Model.Ny+1,

MPI_DOUBLE, idNext, MPI_ANY_TAG, MPI_COMM_WORLD, &status); } }

MPI_Barrier(MPI_COMM_WORLD);

}

Листинг 7. Проект Client, файл Client.h

// Client.h : main header file for the CLIENT application

void Run();

void SendToNext (int cmd);

int RecvFromPrev();

void RecvKoefsFromServer();

void SendFieldsToServer();

void OnUpdate();

Листинг 8. Проекты Client и AirAttack, файл mpiconsts.h

// MPIConst.h : constants for coordination between Server and Clients

#define mpicmdError (-1)

#define mpicmdNone 0

#define mpicmdExit 1

#define mpicmdInit 2

#define mpicmdDone 3

#define mpicmdFieldsToServer 5

#define mpicmdNext 6

#define mpiSomeTag 0

#define mpitagCmd 153

Листинг 9. Проект AirAttack, фрагменты файла AirAttack.cpp

// AirAttack.cpp : Defines the class behaviors for the application.

. . .

// CAirAttackApp initialization

BOOL CAirAttackApp::InitInstance()

{

MPI_Init (NULL, NULL);

. . .

}

. . .

BOOL CAirAttackApp::OnIdle(LONG lCount)

{

POSITION pos = GetFirstDocTemplatePosition();

CDocTemplate* pdt = GetNextDocTemplate(pos);

pos = pdt->GetFirstDocPosition();

CAirAttackDoc* pDoc = (CAirAttackDoc*) pdt->GetNextDoc(pos);

pDoc->OnIdle();

CWinApp::OnIdle(lCount);

return TRUE;

//return CWinApp::OnIdle(lCount);

}

int CAirAttackApp::ExitInstance()

{

int nProcs;

MPI_Comm_size (MPI_COMM_WORLD, &nProcs);

int cmd=mpicmdExit;

for (int i=1; i<nProcs; i++)

MPI_Send (&cmd, 1, MPI_INT, i, mpitagCmd, MPI_COMM_WORLD);

MPI_Finalize();

return CWinApp::ExitInstance();

}

Листинг 10. Проект AirAttack, фрагменты файла

AirAttackDoc.cpp

// AirAttackDoc.cpp : implementation of the CAirAttackDoc class

#include "stdafx.h"

#include "AirAttack.h"

#include "AirAttackDoc.h"

#include ".\airattackdoc.h"

. . .

// CAirAttackDoc construction/destruction

CAirAttackDoc::CAirAttackDoc()

{

kProc=kOneProc;

nClients=0;

}

CAirAttackDoc::~CAirAttackDoc()

{

if (nClients) SendCmd(mpicmdDone);

SendCmd(mpicmdExit);

}

BOOL CAirAttackDoc::OnNewDocument()

{

if (!CDocument::OnNewDocument()) return FALSE;

if (nClients) SendCmd(mpicmdDone);

//kProc=kOneProc;

kProc=kServerProc;

Nx=40; Ny=20;

h=3; tau=0.09; Time=0;

SetRect (&Build, 12, 8, 17, 13);

kNuMethod=kLaminaryMeth;

blWorking=FALSE;

blAutorefreshing=TRUE;

if (kProc==kServerProc) {

int np;

MPI_Comm_size (MPI_COMM_WORLD, &np);

if (np<CLIENTS_N+1) {

AfxMessageBox ("Недостаточно процессоров", MB_ICONSTOP|MB_OK);

kProc=kOneProc; } }

if (kProc==kOneProc) {

Model.Init (kOneProc, kBoundary, kBoundary, kNuMethod, Nx, Ny, h,

tau, Build); }

else {

int i;

nClients=CLIENTS_N;

// На i-ом проце узлы [0..Nx+1] = [ Regions[i-1] .. Regions[i]+1 ]

for (i=0; i<=nClients; i++)

Regions[i]=Nx*i/nClients;

SendCmd(mpicmdInit);

Model.Init (kServerProc, kBoundary, kBoundary, kNuMethod, Nx, Ny,

h, tau, Build);

SendKoefsToClients(); }

SetTitle ("Модель 1");

return TRUE;

}

. . .

void CAirAttackDoc::OnCompPlay()

{

blWorking=TRUE;

}

void CAirAttackDoc::OnCompStop()

{

blWorking=FALSE;

if (Model.kProc==kServerProc) {

SendCmd(mpicmdFieldsToServer);

RecvFieldsFromClients();

UpdateAllViews (NULL, TRUE); }

}

void CAirAttackDoc::OnCompNext()

{

if (blWorking) return;

if (Model.kProc==kOneProc) {

Model.UpdateData();

UpdateAllViews (NULL, TRUE); }

else {

SendCmd(mpicmdNext);

MPI_Barrier(MPI_COMM_WORLD);

SendCmd(mpicmdFieldsToServer);

RecvFieldsFromClients();

UpdateAllViews (NULL, TRUE); }

Time+=tau;

}

void CAirAttackDoc::OnIdle(void)

{

if (!blWorking) return;

if (Model.kProc==kOneProc) {

Model.UpdateData();

UpdateAllViews (NULL, TRUE); }

else {

SendCmd(mpicmdNext);

MPI_Barrier(MPI_COMM_WORLD);

if (blAutorefreshing) {

SendCmd(mpicmdFieldsToServer);

RecvFieldsFromClients();

UpdateAllViews (NULL, TRUE); } }

Time+=tau;

}

. . .

/////////////////////////////////////////////////////////////////////

// Operations

void CAirAttackDoc::SendCmd (int cmd)

{

if (Model.kProc==kOneProc) return;

MPI_Send (&cmd, 1, MPI_INT, 1, mpitagCmd, MPI_COMM_WORLD);

}

void CAirAttackDoc::SendKoefsToClients()

{

if (Model.kProc==kOneProc) return;

int i;

for (i=1; i<=nClients; i++) {

int Nx=Regions[i]-Regions[i-1];

int kLeft = (i==1)?kBoundary:kNextProc,

kRight = (i==nClients)?kBoundary:kNextProc;

RECT build = { Build.left-Regions[i-1], Build.top,

Build.right-Regions[i-1], Build.bottom };

if (build.left>Nx+1 || build.right<0) {

build.left=0;

build.right=-1; }

MPI_Send (&kLeft, 1, MPI_INT, i, mpiSomeTag, MPI_COMM_WORLD);

MPI_Send (&kRight, 1, MPI_INT, i, mpiSomeTag, MPI_COMM_WORLD);

MPI_Send (&Model.kNuMethod, 1, MPI_INT, i, mpiSomeTag,

MPI_COMM_WORLD);

MPI_Send (&Nx, 1, MPI_INT, i, mpiSomeTag, MPI_COMM_WORLD);

MPI_Send (&Model.Ny, 1, MPI_INT, i, mpiSomeTag, MPI_COMM_WORLD);

MPI_Send (&Model.h, 1, MPI_DOUBLE, i, mpiSomeTag, MPI_COMM_WORLD);

MPI_Send (&Model.tau, 1, MPI_DOUBLE, i, mpiSomeTag,

MPI_COMM_WORLD);

MPI_Send (&build, sizeof(build), MPI_CHAR, i, mpiSomeTag,

MPI_COMM_WORLD); }

MPI_Barrier(MPI_COMM_WORLD);

}

void CAirAttackDoc::RecvFieldsFromClients()

{

if (Model.kProc==kOneProc) return;

MPI_Status status;

int i, j, k;

for (i=1; i<=nClients; i++)

// На i-ом проце узлы [0..Nx+1] = [ Regions[i-1] .. Regions[i]+1 ]

for (j=Regions[i-1]; j<=Regions[i]+1; j++)

for (k=0; k<nFields; k++)

MPI_Recv (&Model.Fields[k][j][0], Model.Ny+2, MPI_DOUBLE,

i, MPI_ANY_TAG, MPI_COMM_WORLD, &status);

MPI_Barrier(MPI_COMM_WORLD);

}

Листинг 11. Проект AirAttack, фрагменты файла AirAttackDoc.h

// AirAttackDoc.h : interface of the CAirAttackDoc class

#pragma once

#include "Model\Model.h"

#include "mpiconsts.h"

#include <mpi.h>

class CAirAttackDoc : public CDocument

{

protected: // create from serialization only

CAirAttackDoc();

DECLARE_DYNCREATE(CAirAttackDoc)

#define CLIENTS_N 4

// Attributes

public:

int kProc, nClients; // Процессорность и кол-во клиентов

int Regions[CLIENTS_N+1]; // Участки процов

CModel Model; // Модель

int Nx, Ny; // Размеры сетки

double h, tau, Time; // Шаги по расстоянию и по времени, время

int kNuMethod; // Метод вычисления вязкости

BOOL blWorking, blAutorefreshing; // Нажата кнопка play,

автоперерисовка

RECT Build; // Координаты здания в метрах

// Operations

public:

void SendCmd (int cmd);

void SendKoefsToClients();

void RecvFieldsFromClients();

// Overrides

public:

virtual BOOL OnNewDocument();

virtual void Serialize(CArchive& ar);

// Implementation

public:

virtual ~CAirAttackDoc();

. . .

public:

afx_msg void OnCompPlay();

void OnIdle(void);

afx_msg void OnCompStop();

afx_msg void OnCompNext();

. . .

};

Листинг 12. Проект AirAttack, фрагменты файла

AirAttackView.cpp

// AirAttackView.cpp : implementation of the CAirAttackView class

#include "stdafx.h"

#include "AirAttack.h"

#include "AirAttackDoc.h"

#include "AirAttackView.h"

#include ".\airattackview.h"

#include <math.h>

. . .

// CAirAttackView construction/destruction

CAirAttackView::CAirAttackView()

{

blFieldU=blFieldPsi=blFieldOm=

blFieldT=blFieldNu=blViewProcs=TRUE;

fScaleX=19; fScaleY=19;

nViewStep=1;

}

CAirAttackView::~CAirAttackView()

{

}

. . .

// CAirAttackView drawing

void CAirAttackView::OnDraw(CDC* pDC)

{

CAirAttackDoc* pDoc = GetDocument();

ASSERT_VALID(pDoc);

if (!pDoc) return;

CModel *mdl=&pDoc->Model;

COLORREF col;

double scx=fScaleX, scy=fScaleY;

int i, j, ii, jj;

// Подготовка к выводу

//CClientDC dc(pView);

CRect rect;

GetClientRect(&rect);

CBitmap bmp;

CDC dcMem;

dcMem.CreateCompatibleDC (pDC);

bmp.CreateCompatibleBitmap (pDC, rect.Width(), rect.Height());

CBitmap *pOldBmp = dcMem.SelectObject (&bmp);

// Рисуем воздух и здание

CPen aPen1;

CBrush aBrush1;

COLORREF aCol1=RGB(0,0,0);

aPen1.CreatePen (PS_SOLID, 0, aCol1);

aBrush1.CreateSolidBrush (aCol1);

CPen *pOldPen = dcMem.SelectObject (&aPen1);

CBrush *pOldBrush = dcMem.SelectObject (&aBrush1);

dcMem.Rectangle (rect);

CPen aPen2;

CBrush aBrush2;

COLORREF aCol2=RGB(96,112,96);

aPen2.CreatePen (PS_SOLID, 0, aCol2);

aBrush2.CreateSolidBrush (aCol2);

dcMem.SelectObject (&aPen2);

dcMem.SelectObject (&aBrush2);

dcMem.Rectangle (scx/2, scy/2, scx*mdl->Nx+scx/2,

scy*mdl->Ny+scy/2);

dcMem.Rectangle (scx/2 + scx*mdl->Build.left, scy/2 + scx*mdl-

>Build.top,

scx/2 + scx*mdl->Build.right, scy/2 + scx*mdl->Build.bottom);

// Выводим вихрь Om и температуру T и вязкость Nu

if (blFieldOm || blFieldT || (blFieldNu && mdl->kNuMethod!

=kLaminaryMeth)) {

double t1;//, t2, v;

for (i=1; i<=mdl->Nx+1; i++)

for (j=0; j<=mdl->Ny+1; j++) {

if (blFieldNu && mdl->kNuMethod!=kLaminaryMeth) {

t1 = max (50, min (190, 120+30*(mdl->Nu[i][j]-0)));

col = RGB(0,0,t1); }

else if (blFieldOm) {

t1 = max (50, min (170, 120+50*mdl->Om[i][j]));

col = RGB(0,t1,0); }

else {

t1=130;

col = RGB(0,t1,0); }