156 lines
3.8 KiB
C++
156 lines
3.8 KiB
C++
#include "Geo_OversetGrid.h"
|
|
#include "Geo_UnstructGrid.h"
|
|
#include "PHMatrix.h"
|
|
#include "PHIO.h"
|
|
#include "TK_Exit.h"
|
|
using namespace std;
|
|
|
|
namespace PHSPACE
|
|
{
|
|
Geo_OversetGrid::Geo_OversetGrid(Grid *grid_in, int rank, int nBlocks)
|
|
{
|
|
grid = grid_in;
|
|
this->rank = rank;
|
|
this->nBlocks = nBlocks;
|
|
xb = 0;
|
|
yb = 0;
|
|
zb = 0;
|
|
numberOfBoundaryPoints = 0;
|
|
|
|
oversetInfoProxy = new OversetInfoProxy();
|
|
//! Transfer oversetInfoProxy release right to grid.
|
|
grid->SetOversetInfoProxy(oversetInfoProxy);
|
|
}
|
|
|
|
Geo_OversetGrid::~Geo_OversetGrid()
|
|
{
|
|
delete [] xb;
|
|
delete [] yb;
|
|
delete [] zb;
|
|
}
|
|
|
|
bool Geo_OversetGrid::IsExteriorPoint(int flagOfPoint)
|
|
{
|
|
return flagOfPoint == ExteriorPoint;
|
|
}
|
|
|
|
void Geo_OversetGrid::InitReceivingInformation(vector<int> &cellIndexRef1, vector<int> &zoneIndexRef2, vector<int> &cellIndexRef2)
|
|
{
|
|
oversetInfoProxy->InitReceivingInformation(cellIndexRef1, zoneIndexRef2, cellIndexRef2);
|
|
}
|
|
|
|
void Geo_OversetGrid::PrepareSendingInformation(Geo_OversetGrid **oversetGrids)
|
|
{
|
|
oversetInfoProxy->PrepareSendingInformation(oversetGrids);
|
|
}
|
|
|
|
void Geo_OversetGrid::PreProcess()
|
|
{
|
|
Grid *grid = this->GetGrid();
|
|
grid->ComputeMetrics();
|
|
}
|
|
|
|
void Geo_OversetGrid::PostProcess(Geo_OversetGrid **oversetGrids)
|
|
{
|
|
oversetInfoProxy->PostProcess(oversetGrids);
|
|
}
|
|
|
|
void Geo_OversetGrid::DumpOversetGrid(fstream &file)
|
|
{
|
|
DataContainer *cdata = new DataContainer();
|
|
|
|
grid->Encode(cdata, 1);
|
|
WriteFile(file, cdata);
|
|
|
|
delete cdata;
|
|
}
|
|
|
|
bool InBox(RDouble &xb, RDouble &yb, RDouble &zb, RDouble *pmin, RDouble *pmax)
|
|
{
|
|
if (xb < pmin[0] || xb > pmax[0]) return false;
|
|
if (yb < pmin[1] || yb > pmax[1]) return false;
|
|
if (zb < pmin[2] || zb > pmax[2]) return false;
|
|
return true;
|
|
}
|
|
|
|
bool p_On_RHSide(RDouble &x, RDouble &y, RDouble &z, RDouble *p1, RDouble *p2)
|
|
{
|
|
RDouble dx1,dy1,dz1,dx2,dy2,dz2;
|
|
dx1 = x - p1[0];
|
|
dy1 = y - p1[1];
|
|
dz1 = z - p1[2];
|
|
|
|
dx2 = p2[0] - p1[0];
|
|
dy2 = p2[1] - p1[1];
|
|
dz2 = p2[2] - p1[2];
|
|
|
|
//RDouble sx = dy1 * dz2 - dy2 * dz1;
|
|
//RDouble sy = dz1 * dx2 - dz2 * dx1;
|
|
RDouble sz = dx1 * dy2 - dx2 * dy1;
|
|
|
|
if (sz <= 0.0) return false;
|
|
return true;
|
|
}
|
|
|
|
bool RightSide(RDouble &xm, RDouble &ym, RDouble &zm, RDouble &xfc, RDouble &yfc, RDouble &zfc, RDouble &xfn, RDouble &yfn, RDouble &zfn)
|
|
{
|
|
RDouble dx = xm - xfc;
|
|
RDouble dy = ym - yfc;
|
|
RDouble dz = zm - zfc;
|
|
|
|
RDouble result = dx * xfn + dy * yfn + dz * zfn;
|
|
|
|
if (result > 0) return true;
|
|
return false;
|
|
}
|
|
|
|
vector<string> GetTecplotTitle(const string &field_name)
|
|
{
|
|
vector<string> title_tecplot;
|
|
title_tecplot.push_back("title=\"Flow Fields of PHengLEI\"");
|
|
title_tecplot.push_back("variables = ");
|
|
title_tecplot.push_back("\"x\"");
|
|
title_tecplot.push_back("\"y\"");
|
|
title_tecplot.push_back("\"z\"");
|
|
|
|
string str = "\"" + field_name + "\"";
|
|
title_tecplot.push_back(str);
|
|
|
|
return title_tecplot;
|
|
}
|
|
|
|
void DumpField(UnstructGrid *grid, fstream &file, RDouble *field, const string &name)
|
|
{
|
|
int nTotalNode = grid->GetNTotalNode();
|
|
|
|
int nplot = 1;
|
|
std::ostringstream oss;
|
|
|
|
RDouble ** qv = NewPointer2<RDouble>(nplot, nTotalNode);
|
|
|
|
CompNodeVar(grid, qv[0], field);
|
|
|
|
vector<string> title_tecplot = GetTecplotTitle(name);
|
|
FieldVisualization(grid, oss, title_tecplot, qv, nplot);
|
|
|
|
DelPointer2(qv);
|
|
|
|
file << oss.str();
|
|
}
|
|
|
|
void Visualization(UnstructGrid *grid, RDouble *field, const string &filename, const string &fieldname)
|
|
{
|
|
fstream file;
|
|
file.open(filename.c_str(),ios_base::out|ios_base::trunc);
|
|
if (!file)
|
|
{
|
|
TK_Exit::FileOpenErrorExit(filename);
|
|
}
|
|
DumpField(grid, file, field, fieldname);
|
|
file.close();
|
|
file.clear();
|
|
}
|
|
|
|
|
|
}
|