void MeshPartition::setVolume(QString volume_name)
{
m_Grid = GuiMainWindow::pointer()->getGrid();
resetOrientation(m_Grid);
VolumeDefinition V = GuiMainWindow::pointer()->getVol(volume_name);
QList<vtkIdType> cls;
EG_VTKDCC(vtkIntArray, cell_code, m_Grid, "cell_code");
EG_VTKDCC(vtkIntArray, cell_orgdir, m_Grid, "cell_orgdir");
EG_VTKDCC(vtkIntArray, cell_curdir, m_Grid, "cell_curdir");
EG_VTKDCC(vtkIntArray, cell_voldir, m_Grid, "cell_voldir");
for (vtkIdType id_cell = 0; id_cell < m_Grid->GetNumberOfCells(); ++id_cell) {
if (isSurface(id_cell, m_Grid)) {
int bc = cell_code->GetValue(id_cell);
cell_voldir->SetValue(id_cell, 0);
if (V.getSign(bc) != 0) {
cls.append(id_cell);
if (V.getSign(bc) == -1) {
cell_voldir->SetValue(id_cell, 1);
}
}
} else {
if (cell_code->GetValue(id_cell) == V.getVC()) {
cls.append(id_cell);
}
}
}
setCells(cls);
}
void MeshPartition::setOriginalOrientation()
{
EG_VTKDCC(vtkIntArray, cell_curdir, m_Grid, "cell_curdir");
EG_VTKDCC(vtkIntArray, cell_orgdir, m_Grid, "cell_orgdir");
foreach (vtkIdType id_cell, m_Cells) {
if (isSurface(id_cell, m_Grid)) {
if (cell_curdir->GetValue(id_cell) != cell_orgdir->GetValue(id_cell)) {
reorientateFace(m_Grid, id_cell);
}
}
}
}
void Su2Writer::writeBoundaries()
{
QTextStream f(m_File);
f << "%\n";
f << "% Boundary elements\n";
f << "%\n";
QSet<int> bcs = GuiMainWindow::pointer()->getAllBoundaryCodes();
f << "NMARK= " << bcs.size() << "\n";
EG_VTKDCC(vtkIntArray, cell_code, m_Grid, "cell_code");
foreach (int bc, bcs) {
BoundaryCondition BC = GuiMainWindow::pointer()->getBC(bc);
f << "MARKER_TAG= " << BC.getName() << "\n";
QList<vtkIdType> faces;
for (vtkIdType id_cell = 0; id_cell < m_Grid->GetNumberOfCells(); ++id_cell) {
if (isSurface(id_cell, m_Grid)) {
if (cell_code->GetValue(id_cell) == bc) {
faces.append(id_cell);
}
}
}
f << "MARKER_ELEMS= " << faces.size() << "\n";
foreach (vtkIdType id_cell, faces) {
f << m_Grid->GetCellType(id_cell);
vtkIdType N_pts, *pts;
m_Grid->GetCellPoints(id_cell, N_pts, pts);
for (int j = 0; j < N_pts; ++j) {
f << " " << pts[j];
}
f << "\n";
}
void BoundaryLayerOperation::readSettings()
{
EG_VTKDCC(vtkIntArray, cell_code, m_Grid, "cell_code");
QString buffer = GuiMainWindow::pointer()->getXmlSection("engrid/blayer/settings");
if(!buffer.isEmpty()) {
QTextStream in(&buffer, QIODevice::ReadOnly);
int num_bcs;
in >> num_bcs;
QVector<bool> use_bc(num_bcs);
int N = 0;
for (int i = 0; i < num_bcs; ++i) {
int state;
in >> state;
use_bc[i] = bool(state);
if (use_bc[i]) {
++N;
}
}
m_BoundaryLayerCodes.resize(N);
QVector<int> bcs;
mainWindow()->getAllBoundaryCodes(bcs);
int j = 0;
for (int i = 0; i < bcs.size(); ++i) {
if (use_bc[i]) {
m_BoundaryLayerCodes[j++] = bcs[i];
}
}
m_LayerAdjacentBoundaryCodes.clear();
for (vtkIdType id_cell = 0; id_cell < m_Grid->GetNumberOfCells(); ++id_cell) {
if (isSurface(id_cell, m_Grid)) {
if (m_BoundaryLayerCodes.contains(cell_code->GetValue(id_cell))) {
for (int i = 0; i < m_Part.c2cGSize(id_cell); ++i) {
vtkIdType id_neigh = m_Part.c2cGG(id_cell, i);
if (!m_BoundaryLayerCodes.contains(cell_code->GetValue(id_neigh))) {
m_LayerAdjacentBoundaryCodes.insert(cell_code->GetValue(id_neigh));
}
}
}
}
}
in >> m_FeatureAngle;
m_FeatureAngle = deg2rad(m_FeatureAngle);
in >> m_StretchingRatio;
in >> m_FarfieldRatio;
in >> m_NumBoundaryLayerVectorRelaxations;
in >> m_NumBoundaryLayerHeightRelaxations;
in >> m_FaceSizeLowerLimit;
in >> m_FaceSizeUpperLimit;
in >> m_FaceAngleLimit;
m_FaceAngleLimit = deg2rad(m_FaceAngleLimit);
in >> m_MaxHeightInGaps;
in >> m_RadarAngle;
int use_grouping;
in >> use_grouping;
m_UseGrouping = use_grouping;
in >> m_GroupingAngle;
m_GroupingAngle = deg2rad(m_GroupingAngle);
}
void BrlcadReader::findBoundaryCodes()
{
int num_grids = m_Grids.size();
QVector<vtkUnstructuredGrid*> grids(num_grids);
qCopy(m_Grids.begin(), m_Grids.end(), grids.begin());
QVector<FaceFinder> finders(num_grids);
for (int i_grid = 0; i_grid < num_grids; ++i_grid) {
finders[i_grid].setGrid(grids[i_grid]);
}
EG_VTKDCC(vtkIntArray, cell_code, m_Grid, "cell_code");
bool has_errors = false;
QVector<bool> bc_exists(num_grids, false);
for (vtkIdType id_cell = 0; id_cell < m_Grid->GetNumberOfCells(); ++id_cell) {
int best_grid = -1;
double L_min = 1e99;
vec3_t x1 = cellCentre(m_Grid, id_cell);
for (int i_grid = 0; i_grid < num_grids; ++i_grid) {
double L = 1e99;
vtkIdType id_closest = finders[i_grid].getClosestFace(x1, L);
vec3_t x2(-999,-999,-999);
if (id_closest != -1) x2 = cellCentre(m_Grids[i_grid], id_closest);
if (id_closest != -1) {
if (L < L_min) {
best_grid = i_grid;
L_min = L;
}
}
}
if (best_grid == -1) {
has_errors = true;
cell_code->SetValue(id_cell, 9999);
} else {
bc_exists[best_grid] = true;
cell_code->SetValue(id_cell, best_grid + 1);
}
}
GuiMainWindow::pointer()->clearBCs();
int bc_max = 1;
QVector<int> bc_map(num_grids+1,9999);
m_BC2GridIndex.clear();
for (int i_grid = 0; i_grid < num_grids; ++i_grid) {
if (bc_exists[i_grid]) {
bc_map[i_grid+1] = bc_max;
GuiMainWindow::pointer()->addBC(bc_max, BoundaryCondition(m_BCNames[grids[i_grid]], "patch"));
m_BC2GridIndex[bc_max] = i_grid;
++bc_max;
}
}
for (vtkIdType id_cell = 0; id_cell < m_Grid->GetNumberOfCells(); ++id_cell) {
if (cell_code->GetValue(id_cell) != 9999) {
cell_code->SetValue(id_cell, bc_map[cell_code->GetValue(id_cell)]);
}
}
if (has_errors) {
GuiMainWindow::pointer()->addBC(9999, BoundaryCondition("error-faces", "patch"));
}
GuiMainWindow::pointer()->updateBoundaryCodes(true);
}
void MeshQuality::computeNodesFromCells()
{
EG_VTKDCN(vtkDoubleArray, node_mesh_quality, m_Grid, "node_mesh_quality");
EG_VTKDCC(vtkDoubleArray, cell_mesh_quality, m_Grid, "cell_mesh_quality");
EG_FORALL_NODES(id_node, m_Grid) {
double mq = 1;
for (int i = 0; i < m_Part.n2cGSize(id_node); ++i) {
vtkIdType id_cell = m_Part.n2cGG(id_node, i);
mq = min(cell_mesh_quality->GetValue(id_cell), mq);
}
node_mesh_quality->SetValue(id_node, mq);
}
void NeutralWriter::operate()
{
try {
QFileInfo file_info(GuiMainWindow::pointer()->getFilename());
readOutputFileName(file_info.completeBaseName() + ".mesh");
if (isValid()) {
QFile file(getFileName());
file.open(QIODevice::WriteOnly | QIODevice::Text);
QTextStream f(&file);
f << m_Grid->GetNumberOfPoints() << "\n";
for (vtkIdType pointId = 0; pointId < m_Grid->GetNumberOfPoints(); ++pointId) {
vec3_t x;
m_Grid->GetPoints()->GetPoint(pointId, x.data());
f << x[0] << " " << x[1] << " " << x[2] << "\n";
};
vtkIdType Nvol = 0;
vtkIdType Nsurf = 0;
for (vtkIdType cellId = 0; cellId < m_Grid->GetNumberOfCells(); ++cellId) {
vtkIdType cellType = m_Grid->GetCellType(cellId);
if ((cellType != VTK_TRIANGLE) && (cellType != VTK_TETRA)) {
EG_ERR_RETURN("only simplex elements are allowed for the NEUTRAL format");
};
if (isSurface(cellId, m_Grid)) {
++Nsurf;
} else {
++Nvol;
};
};
f << Nvol << "\n";
for (vtkIdType cellId = 0; cellId < m_Grid->GetNumberOfCells(); ++cellId) {
if (!isSurface(cellId, m_Grid)) {
vtkIdType Npts, *pts;
m_Grid->GetCellPoints(cellId, Npts, pts);
f << "1 " << pts[0]+1 << " " << pts[1]+1 << " " << pts[3]+1 << " " << pts[2]+1 << "\n";
};
};
f << Nsurf << "\n";
EG_VTKDCC(vtkIntArray, cell_code, m_Grid, "cell_code");
for (vtkIdType cellId = 0; cellId < m_Grid->GetNumberOfCells(); ++cellId) {
if (isSurface(cellId, m_Grid)) {
vtkIdType Npts, *pts;
m_Grid->GetCellPoints(cellId, Npts, pts);
f << 1;//cell_code->GetValue(cellId);
f << " " << pts[2]+1 << " " << pts[1]+1 << " " << pts[0]+1 << "\n";
};
};
};
} catch (Error err) {
err.display();
};
};
QString DrNumWriter::boundaryCode(vtkIdType id_cell, int i)
{
EG_VTKDCC(vtkIntArray, cell_code, m_Grid, "cell_code");
QString bcode = "0";
vtkIdType id_neigh = m_Part.c2cGG(id_cell, i);
if (id_neigh != -1) {
if (m_CellToCartPatch[id_neigh] == -1) {
if (isSurface(id_neigh, m_Grid)) {
BoundaryCondition bc = GuiMainWindow::pointer()->getBC(cell_code->GetValue(id_neigh));
if (bc.getName() != "unknown") {
bcode = bc.getType();
}
}
}
}
return bcode;
}
void UpdateDesiredMeshDensity::computeExistingLengths()
{
QSet<int> all_bcs = GuiMainWindow::pointer()->getAllBoundaryCodes();
QSet<int> fixed_bcs = all_bcs - m_BoundaryCodes;
QVector<double> edge_length(m_Grid->GetNumberOfPoints(), 1e99);
QVector<int> edge_count(m_Grid->GetNumberOfPoints(), 0);
m_Fixed.fill(false, m_Grid->GetNumberOfPoints());
EG_VTKDCC(vtkIntArray, cell_code, m_Grid, "cell_code");
for (vtkIdType id_cell = 0; id_cell < m_Grid->GetNumberOfCells(); ++id_cell) {
if (isSurface(id_cell, m_Grid)) {
if (fixed_bcs.contains(cell_code->GetValue(id_cell))) {
vtkIdType N_pts, *pts;
m_Grid->GetCellPoints(id_cell, N_pts, pts);
QVector<vec3_t> x(N_pts);
for (int i = 0; i < N_pts; ++i) {
m_Grid->GetPoint(pts[i], x[i].data());
m_Fixed[pts[i]] = true;
}
for (int i = 0; i < N_pts; ++i) {
int j = i + 1;
if (j >= N_pts) {
j = 0;
}
double L = (x[i] - x[j]).abs();
edge_length[pts[i]] = min(edge_length[pts[i]], L);
edge_length[pts[j]] = min(edge_length[pts[j]], L);
++edge_count[pts[i]];
++edge_count[pts[j]];
}
}
}
}
EG_VTKDCN(vtkDoubleArray, characteristic_length_desired, m_Grid, "node_meshdensity_desired");
for (vtkIdType id_node = 0; id_node < m_Grid->GetNumberOfPoints(); ++id_node) {
if (edge_count[id_node] > 0) {
if (edge_length[id_node] > 1e98) {
EG_BUG;
}
characteristic_length_desired->SetValue(id_node, edge_length[id_node]);
}
}
}
QList<vtkIdType> StitchHoles::getNextHole()
{
QList<vtkIdType> loop_nodes;
EG_VTKDCC(vtkIntArray, cell_code, m_Grid, "cell_code");
// find the first two nodes of the hole
//
vtkIdType id_node1 = -1;
vtkIdType id_node2 = -1;
EG_FORALL_CELLS (id_cell, m_Grid) {
if (isSurface(id_cell, m_Grid) && cell_code->GetValue(id_cell) == m_Bc) {
for (int i = 0; i < m_Part.c2cGSize(id_cell); ++i) {
if (m_Part.c2cGG(id_cell, i) == -1) {
QList<vtkIdType> pts;
getPointsOfCell(m_Grid, id_cell, pts);
pts << pts.first();
id_node1 = pts[i+1];
id_node2 = pts[i];
break;
}
}
if (id_node1 != -1) {
break;
}
}
}
if (id_node1 == -1) {
return loop_nodes;
}
// create node loop around hole
//
vtkIdType id_start = id_node1;
loop_nodes << id_node1;
vec3_t x0;
m_Grid->GetPoint(id_node1, x0.data());
while (id_node2 != id_start && loop_nodes.size() < m_Grid->GetNumberOfPoints()) {
loop_nodes << id_node2;
vec3_t x;
m_Grid->GetPoint(id_node2, x.data());
x0 += x;
bool found = false;
for (int i = 0; i < m_Part.n2nGSize(id_node2); ++i) {
vtkIdType id_node3 = m_Part.n2nGG(id_node2, i);
if (id_node3 != id_node1) {
QList<vtkIdType> edge_faces;
m_Part.getEdgeFaces(id_node2, id_node3, edge_faces);
if (edge_faces.size() == 1) {
found = true;
id_node1 = id_node2;
id_node2 = id_node3;
break;
}
}
}
if (!found) {
loop_nodes.clear();
return loop_nodes;
}
}
x0 *= 1.0/loop_nodes.size();
m_Cad->snap(x0);
vec3_t n = m_Cad->getLastNormal();
setOrigin(x0);
setNormal(n);
setupTransformation();
return loop_nodes;
}
void RestrictToAvailableVolumeCells::operate()
{
QList<vtkIdType> vol_cells, surf_cells;
for (vtkIdType id_cell = 0; id_cell < m_Grid->GetNumberOfCells(); ++id_cell) {
if (isVolume(id_cell, m_Grid)) {
vol_cells.append(id_cell);
}
}
foreach (vtkIdType id_cell, vol_cells) {
for (int i = 0; i < m_Part.c2cGSize(id_cell); ++i) {
vtkIdType id_neigh = m_Part.c2cGG(id_cell, i);
if (id_neigh >= 0) {
if (isSurface(id_neigh, m_Grid)) {
surf_cells.append(id_neigh);
}
}
}
}
MeshPartition vol_part(m_Grid);
vol_part.setCells(vol_cells + surf_cells);
EG_VTKSP(vtkUnstructuredGrid, new_grid1);
vol_part.extractToVtkGrid(new_grid1);
MeshPartition new_part1(new_grid1, true);
QList<QVector<vtkIdType> > new_faces;
for (vtkIdType id_cell = 0; id_cell < new_grid1->GetNumberOfCells(); ++id_cell) {
if (isVolume(id_cell, new_grid1)) {
for (int i = 0; i < new_part1.c2cGSize(id_cell); ++i) {
vtkIdType id_neigh = new_part1.c2cGG(id_cell, i);
if (id_neigh == -1) {
QVector<vtkIdType> pts;
getFaceOfCell(new_grid1, id_cell, i, pts);
new_faces.append(pts);
}
}
}
}
EG_VTKSP(vtkUnstructuredGrid, new_grid2);
allocateGrid(new_grid2, new_grid1->GetNumberOfCells() + new_faces.size(), new_grid1->GetNumberOfPoints());
EG_VTKDCC(vtkIntArray, cell_code1, new_grid1, "cell_code");
EG_VTKDCC(vtkIntArray, cell_code2, new_grid2, "cell_code");
for (vtkIdType id_node = 0; id_node < new_grid1->GetNumberOfPoints(); ++id_node) {
vec3_t x;
new_grid1->GetPoint(id_node, x.data());
new_grid2->GetPoints()->SetPoint(id_node, x.data());
copyNodeData(new_grid1, id_node, new_grid2, id_node);
}
int bc_new = 0;
for (vtkIdType id_cell = 0; id_cell < new_grid1->GetNumberOfCells(); ++id_cell) {
copyCell(new_grid1, id_cell, new_grid2);
copyCellData(new_grid1, id_cell, new_grid2, id_cell);
if (isSurface(id_cell, new_grid1)) {
bc_new = max(bc_new, cell_code1->GetValue(id_cell) + 1);
} else {
cell_code2->SetValue(id_cell, 0);
}
}
foreach (QVector<vtkIdType> face, new_faces) {
vtkIdType type = VTK_POLYGON;
if (face.size() == 3) {
type = VTK_TRIANGLE;
} else if (face.size() == 4) {
type = VTK_QUAD;
}
vtkIdType id_cell = new_grid2->InsertNextCell(type, face.size(), face.data());
cell_code2->SetValue(id_cell, bc_new);
}
void CreateCadTesselation::scan(bool create_grid, int interlaces)
{
m_Dx = (m_X2[0] - m_X1[0])/(m_Ni-1);
m_Dy = (m_X2[1] - m_X1[1])/(m_Nj-1);
m_Dz = (m_X2[2] - m_X1[2])/(m_Nk-1);
EG_VTKSP(vtkImageData, gdata);
gdata->SetDimensions(m_Ni, m_Nj, m_Nk);
EG_VTKSP(vtkFloatArray, g);
g->SetName("g");
g->SetNumberOfValues(m_Ni*m_Nj*m_Nk);
gdata->GetPointData()->AddArray(g);
for (int i = 0; i < m_Ni; ++i) {
for (int j = 0; j < m_Nj; ++j) {
for (int k = 0; k < m_Nk; ++k) {
if (preserveFluid()) {
g->SetValue(getIdx(i,j,k), 1);
} else {
g->SetValue(getIdx(i,j,k), 0);
}
}
}
}
m_XScan1 = m_X2;
m_XScan2 = m_X1;
vec3_t x_in, x_out, n_in, n_out;
int progress = 0;
m_GeometryFound = false;
double dxi = m_Dx/(interlaces + 1);
double dyi = m_Dy/(interlaces + 1);
double dzi = m_Dz/(interlaces + 1);
double shift = 1e-6;
// scan ij plane -> k direction
// xy plane -> z direction
for (int i = 0; i < m_Ni; ++i) {
for (int j = 0; j < m_Nj; ++j) {
vec3_t x0 = getX(i,j,0);
for (int i_il = 0; i_il <= interlaces; ++i_il) {
for (int j_il = 0; j_il <= interlaces; ++j_il) {
vec3_t x = x0;
x[0] += i_il*dxi;
x[1] += j_il*dyi;
int k_last = 0;
while (shootRay(x, vec3_t(0,0,1), x_in, x_out, n_in, n_out)) {
m_GeometryFound = true;
m_XScan1[2] = min(m_XScan1[2], x_in[2]);
m_XScan2[2] = max(m_XScan2[2], x_out[2]);
int k1 = int((x_in[2] - m_X1[2])/m_Dz) + 1;
int k2 = int((x_out[2] - m_X1[2])/m_Dz);
if (preserveFluid()) {
for (int k = k_last; k < min(m_Nk-1,k1); ++k) {
g->SetValue(getIdx(i,j,k), 0);
}
} else {
for (int k = max(0,k1); k <= min(m_Nk-1,k2); ++k) {
g->SetValue(getIdx(i,j,k), 1);
}
}
x = x_out;
x[2] += shift*m_Dz;
k_last = min(m_Nk-1,k2+1);
}
if (preserveFluid()) {
for (int k = k_last; k <= m_Nk-1; ++k) {
g->SetValue(getIdx(i,j,k), 0);
}
}
}
}
}
progress += m_Nj;
GuiMainWindow::pointer()->setProgress(progress);
}
// scan ik plane -> j direction
// xz plane -> y direction
for (int i = 0; i < m_Ni; ++i) {
for (int k = 0; k < m_Nk; ++k) {
vec3_t x0 = getX(i,0,k);
for (int i_il = 0; i_il <= interlaces; ++i_il) {
for (int k_il = 0; k_il <= interlaces; ++k_il) {
vec3_t x = x0;
x[0] += i_il*dxi;
x[2] += k_il*dzi;
int j_last = 0;
/*
if (fabs(x0[0]) < 1.5 && fabs(x0[2]) < 1.5 && create_grid) {
cout << x0 << endl;
}
*/
while (shootRay(x, vec3_t(0,1,0), x_in, x_out, n_in, n_out)) {
m_GeometryFound = true;
m_XScan1[1] = min(m_XScan1[1], x_in[1]);
m_XScan2[1] = max(m_XScan2[1], x_out[1]);
int j1 = int((x_in[1]-m_X1[1])/m_Dy) + 1;
int j2 = int((x_out[1]-m_X1[1])/m_Dy);
if (preserveFluid()) {
for (int j = j_last; j < min(m_Nj-1,j1); ++j) {
g->SetValue(getIdx(i,j,k), 0);
}
} else {
for (int j = max(0,j1); j <= min(m_Nj-1,j2); ++j) {
g->SetValue(getIdx(i,j,k), 1);
}
}
x = x_out;
x[1] += shift*m_Dy;
j_last = min(m_Nj-1,j2+1);
}
if (preserveFluid()) {
for (int j = j_last; j <= m_Nj-1; ++j) {
g->SetValue(getIdx(i,j,k), 0);
}
}
}
}
}
progress += m_Nk;
GuiMainWindow::pointer()->setProgress(progress);
}
// scan jk plane -> i direction
// yz plane -> x direction
for (int j = 0; j < m_Nj; ++j) {
for (int k = 0; k < m_Nk; ++k) {
vec3_t x0 = getX(0,j,k);
for (int j_il = 0; j_il <= interlaces; ++j_il) {
for (int k_il = 0; k_il <= interlaces; ++k_il) {
vec3_t x = x0;
x[1] += j_il*dyi;
x[2] += k_il*dzi;
int i_last = 0;
while (shootRay(x, vec3_t(1,0,0), x_in, x_out, n_in, n_out)) {
m_GeometryFound = true;
m_XScan1[0] = min(m_XScan1[0], x_in[0]);
m_XScan2[0] = max(m_XScan2[0], x_out[0]);
int i1 = int((x_in[0]-m_X1[0])/m_Dx) + 1;
int i2 = int((x_out[0]-m_X1[0])/m_Dx);
if (preserveFluid()) {
for (int i = i_last; i < min(m_Ni-1,i1); ++i) {
g->SetValue(getIdx(i,j,k), 0);
}
} else {
for (int i = max(0,i1); i <= min(m_Ni-1,i2); ++i) {
g->SetValue(getIdx(i,j,k), 1);
}
}
x = x_out;
x[0] += shift*m_Dx;
i_last = min(m_Ni-1,i2+1);
}
if (preserveFluid()) {
for (int i = i_last; i <= m_Ni-1; ++i) {
g->SetValue(getIdx(i,j,k), 0);
}
}
}
}
}
progress += m_Nk;
GuiMainWindow::pointer()->setProgress(progress);
}
if (create_grid) {
GuiMainWindow::pointer()->resetProgress("smoothing", m_Ni*m_Nj*m_Nk*m_NumIterations);
// smooth image data
int progress = 0;
for (int iter = 1; iter <= m_NumIterations; ++iter) {
for (int i = 1; i < m_Ni-1; ++i) {
for (int j = 1; j < m_Nj-1; ++j) {
for (int k = 1; k < m_Nk-1; ++k) {
int idx = getIdx(i,j,k);
bool preserve = false;
if (m_PreservationType == 1 && g->GetValue(idx) > 0.999) {
preserve = true;
}
if (m_PreservationType == 2 && g->GetValue(idx) < 0.001) {
preserve = true;
}
if (!preserve) {
double g_new = 0;
g_new += g->GetValue(getIdx(i+1,j,k));
g_new += g->GetValue(getIdx(i-1,j,k));
g_new += g->GetValue(getIdx(i,j+1,k));
g_new += g->GetValue(getIdx(i,j-1,k));
g_new += g->GetValue(getIdx(i,j,k+1));
g_new += g->GetValue(getIdx(i,j,k-1));
g_new *= 1.0/6.0;
g->SetValue(idx, g_new);
}
}
}
progress += m_Nj*m_Nk;
GuiMainWindow::pointer()->setProgress(progress);
}
}
// write image data for testing and reporting purposes
EG_VTKSP(vtkXMLImageDataWriter, vti);
QString file_name = GuiMainWindow::pointer()->getCwd() + "/g.vti";
vti->SetFileName(qPrintable(file_name));
vti->SetDataModeToBinary();
vti->SetInputData(gdata);
vti->Write();
gdata->GetPointData()->SetActiveScalars("g");
EG_VTKSP(vtkContourFilter, contour);
contour->SetInputData(gdata);
contour->SetNumberOfContours(1);
double g_level = 0.5;
if (m_PreservationType == 1) {
g_level = 0.5;
}
if (m_PreservationType == 2) {
g_level = 0.5;
}
contour->SetValue(0, g_level);
EG_VTKSP(vtkTriangleFilter, tri);
tri->SetInputConnection(contour->GetOutputPort());
EG_VTKSP(vtkDecimatePro, decimate);
decimate->PreserveTopologyOn();
decimate->SetTargetReduction(m_TargetReduction);
decimate->SetFeatureAngle(GeometryTools::deg2rad(45));
decimate->SetInputConnection(tri->GetOutputPort());
decimate->Update();
allocateGrid(m_Grid, decimate->GetOutput()->GetNumberOfPolys(), decimate->GetOutput()->GetNumberOfPoints());
for (vtkIdType id_node = 0; id_node < m_Grid->GetNumberOfPoints(); ++id_node) {
vec3_t x;
decimate->GetOutput()->GetPoint(id_node, x.data());
x[0] = m_X1[0] + x[0]*m_Dx;
x[1] = m_X1[1] + x[1]*m_Dx;
x[2] = m_X1[2] + x[2]*m_Dx;
m_Grid->GetPoints()->SetPoint(id_node, x.data());
}
EG_VTKDCC(vtkIntArray, cell_code, m_Grid, "cell_code");
for (vtkIdType id_cell = 0; id_cell < decimate->GetOutput()->GetNumberOfPolys(); ++id_cell) {
EG_GET_CELL(id_cell, decimate->GetOutput());
vtkIdType id_new_cell = m_Grid->InsertNextCell(type_cell, num_pts, pts);
cell_code->SetValue(id_new_cell, 1);
}
}
}
void BlenderReader::operate()
{
try {
QFileInfo file_info(GuiMainWindow::pointer()->getFilename());
readInputFileName(file_info.completeBaseName() + ".begc", false);
if (isValid()) {
// read raw data from exported file
QFile file(getFileName());
file.open(QIODevice::ReadOnly | QIODevice::Text);
QTextStream f(&file);
QList<vec3_t> rnodes;
QList<QVector<int> > rfaces;
int num_parts;
f >> num_parts;
QVector<QString> part_name(num_parts);
for (int i_part = 0; i_part < num_parts; ++i_part) {
f >> part_name[i_part];
}
QVector<QString> sorted_part_name = part_name;
qSort(sorted_part_name);
QVector<int> part_bc(part_name.size());
for (int i_part = 0; i_part < num_parts; ++i_part) {
part_bc[i_part] = sorted_part_name.indexOf(part_name[i_part]) + 1;
}
for (int i_part = 0; i_part < num_parts; ++i_part) {
int num_nodes, num_faces;
f >> num_nodes >> num_faces;
for (int i = 0; i < num_nodes; ++i) {
vec3_t x;
f >> x[0] >> x[1] >> x[2];
rnodes.push_back(x);
}
for (int i = 0; i < num_faces; ++i) {
int N;
f >> N;
QVector<int> face(N+1);
face[0] = i_part;
for (int j = 0; j < N; ++j) {
f >> face[j+1];
}
rfaces.push_back(face);
}
}
QVector<vec3_t> nodes(rnodes.size());
qCopy(rnodes.begin(), rnodes.end(), nodes.begin());
QVector<QVector<int> > faces(rfaces.size());
qCopy(rfaces.begin(), rfaces.end(), faces.begin());
// find smallest edge length
double L = 1e99;
foreach (QVector<int> face, faces) {
for (int i = 1; i < face.size(); ++i) {
int n1 = face[i];
int n2 = face[1];
if (i < face.size() - 1) {
n2 = face[i+1];
}
double l = (nodes[n1] - nodes[n2]).abs();
L = min(l, L);
}
}
cout << "smallest edge length is " << L << endl;
// delete duplicate nodes
PointFinder finder;
finder.setPoints(nodes);
QList<vec3_t> non_dup;
QVector<int> o2n(nodes.size());
int num_non_dup = 0;
for (int i = 0; i < nodes.size(); ++i) {
o2n[i] = num_non_dup;
bool dup = false;
QVector<int> close_points;
finder.getClosePoints(nodes[i], close_points);
foreach (int j, close_points) {
if (i > j) {
double l = (nodes[i] - nodes[j]).abs();
if (l < m_RelativeTolerance*L || l == 0) {
o2n[i] = o2n[j];
dup = true;
break;
}
}
}
if (!dup) {
non_dup.push_back(nodes[i]);
++num_non_dup;
}
}
EG_VTKSP(vtkUnstructuredGrid, new_grid);
allocateGrid(new_grid, faces.size(), non_dup.size());
EG_VTKDCC(vtkIntArray, cell_code, new_grid, "cell_code");
EG_VTKDCC(vtkIntArray, orgdir, new_grid, "cell_orgdir");
EG_VTKDCC(vtkIntArray, voldir, new_grid, "cell_voldir");
EG_VTKDCC(vtkIntArray, curdir, new_grid, "cell_curdir");
vtkIdType id_node = 0;
foreach (vec3_t x, non_dup) {
new_grid->GetPoints()->SetPoint(id_node, x.data());
++id_node;
}
foreach (QVector<int> face, faces) {
if (face.size() == 4) {
vtkIdType pts[3];
pts[0] = o2n[face[1]];
pts[1] = o2n[face[2]];
pts[2] = o2n[face[3]];
vtkIdType id_cell = new_grid->InsertNextCell(VTK_TRIANGLE, 3, pts);
cell_code->SetValue(id_cell, part_bc[face[0]]);
orgdir->SetValue(id_cell, 0);
voldir->SetValue(id_cell, 0);
curdir->SetValue(id_cell, 0);
}
if (face.size() == 5) {
vtkIdType pts[4];
pts[0] = o2n[face[1]];
pts[1] = o2n[face[2]];
pts[2] = o2n[face[3]];
pts[3] = o2n[face[4]];
vtkIdType id_cell = new_grid->InsertNextCell(VTK_QUAD, 4, pts);
cell_code->SetValue(id_cell, part_bc[face[0]]);
orgdir->SetValue(id_cell, 0);
voldir->SetValue(id_cell, 0);
curdir->SetValue(id_cell, 0);
}
}
if (m_Append) {
EG_BUG;
MeshPartition new_part(new_grid);
new_part.setAllCells();
m_Part.addPartition(new_part);
} else {
makeCopy(new_grid, m_Grid);
}
UpdateNodeIndex(m_Grid);
UpdateCellIndex(m_Grid);
// check and set the boundary names if required
int update_required = true;
QSet<int> old_bcs = GuiMainWindow::pointer()->getAllBoundaryCodes();
if (old_bcs.size() == part_name.size()) {
QSet<QString> old_names;
foreach (int bc, old_bcs) {
old_names.insert(GuiMainWindow::pointer()->getBC(bc).getName());
}
QSet<QString> new_names;
foreach (QString name, part_name) {
new_names.insert(name);
}
void GuiSetBoundaryCode::operate()
{
m_ButtonGroup->checkedId();
cout<<"buttongroup->checkedId()="<<m_ButtonGroup->checkedId()<<endl;
//save settings
QSettings local_qset("enGits","enGrid_GuisetBoundaryCode");
local_qset.setValue("FeatureAngle", m_Ui.doubleSpinBoxFeatureAngle->value());
local_qset.setValue("BoundaryCode", m_Ui.spinBoxBoundaryCode->value());
local_qset.setValue("PickMethod", m_ButtonGroup->checkedId());
SetBoundaryCode set_bc;
set_bc.setGrid(m_Grid);
set_bc.setAllSurfaceCells();
if (m_RadioButtonAuto->isChecked()) {
QSet <int> display_bcs;
GuiMainWindow::pointer()->getDisplayBoundaryCodes(display_bcs);
int bc = m_Ui.spinBoxBoundaryCode->value();
EG_VTKDCC(vtkIntArray, cell_code, m_Grid, "cell_code");
for (vtkIdType id_cell = 0; id_cell < m_Grid->GetNumberOfCells(); ++id_cell) {
bc = max(bc, cell_code->GetValue(id_cell));
if (display_bcs.contains(cell_code->GetValue(id_cell))) {
cell_code->SetValue(id_cell, 9999);
}
}
bool done = false;
do {
vtkIdType id_start = -1;
for (vtkIdType id_cell = 0; id_cell < m_Grid->GetNumberOfCells(); ++id_cell) {
if (cell_code->GetValue(id_cell) == 9999) {
id_start = id_cell;
break;
}
}
if (id_start == -1) {
done = true;
} else {
set_bc.setFeatureAngle(m_Ui.doubleSpinBoxFeatureAngle->value());
set_bc.setNewBC(bc);
set_bc.setProcessAll(false);
set_bc.setSelectAllVisible(false);
set_bc.setOnlyPickedCell(false);
set_bc.setOnlyPickedCellAndNeighbours(false);
set_bc.setStart(id_start);
QString bc_name = GuiMainWindow::pointer()->getBC(bc).getName();
if (bc_name == "unknown") {
bc_name.setNum(bc);
bc_name = "wall_" + bc_name.rightJustified(3, '0');
BoundaryCondition sym_bc(bc_name, "wall", bc);
GuiMainWindow::pointer()->setBC(bc, sym_bc);
}
set_bc();
++bc;
}
} while (!done);
} else {
if (0 <= mainWindow()->getPickedCell() && mainWindow()->getPickedCell() < GuiMainWindow::pointer()->getGrid()->GetNumberOfCells() ) {
set_bc.setFeatureAngle(m_Ui.doubleSpinBoxFeatureAngle->value());
set_bc.setNewBC(m_Ui.spinBoxBoundaryCode->value());
set_bc.setProcessAll(m_ButtonGroup->button(1)->isChecked());
set_bc.setSelectAllVisible(m_ButtonGroup->button(2)->isChecked());
set_bc.setOnlyPickedCell(m_ButtonGroup->button(3)->isChecked());
set_bc.setOnlyPickedCellAndNeighbours(m_ButtonGroup->button(4)->isChecked());
cout << "GuiMainWindow::getPickedCell()=" << mainWindow()->getPickedCell() << endl;
set_bc.setStart(mainWindow()->getPickedCell());
set_bc();
} else {
EG_ERR_RETURN("Please select a cell first.");
}
}
}
void MultiSolidAsciiStlReader::operate()
{
QFileInfo file_info(GuiMainWindow::pointer()->getFilename());
readInputFileName(file_info.completeBaseName() + ".stl");
if (isValid()) {
double tol = QInputDialog::getText(NULL, "enter STL tolerance", "tolerance", QLineEdit::Normal, "1e-10").toDouble();
QList<QString> buffer;
QList<QString> bc_name;
{
QFile file(getFileName());
if (!file.open(QFile::ReadOnly)) {
EG_ERR_RETURN("unable to open file");
}
QTextStream f(&file);
QString buf = "";
QString name = "unknown";
while (!f.atEnd()) {
QString line = f.readLine();
buf += line + "\n"; // endline??
if (line.left(8) == "endsolid") {
buffer.append(buf);
buf = "";
bc_name.append(name);
} else if (line.left(5) == "solid") {
name = line.right(line.size() - 6);
}
}
}
bool first = true;
int last_bc = 1;
foreach (QString buf, buffer) {
QString file_name = getFileName() + ".tmp";
{
QFile file(file_name);
if (!file.open(QFile::WriteOnly)) {
EG_ERR_RETURN("unable to open file\"" + file_name + "\" for writing");
}
QTextStream f(&file);
f << buf << endl;
}
StlReader stl;
stl.setTolerance(tol);
stl.setFileName(file_name);
EG_VTKSP(vtkUnstructuredGrid, grid);
stl.setGrid(grid);
stl.setMaximalCleaningIterations(3);
stl();
// @todo set boundary names
EG_VTKDCC(vtkIntArray, bc, grid, "cell_code");
for (vtkIdType id_cell = 0; id_cell < grid->GetNumberOfCells(); ++id_cell) {
bc->SetValue(id_cell, last_bc);
}
++last_bc;
if (first) {
first = false;
makeCopy(grid, m_Grid);
} else {
MeshPartition part1(m_Grid, true);
MeshPartition part2(grid, true);
part1.addPartition(part2);
}
}
last_bc = 1;
GuiMainWindow::pointer()->resetXmlDoc();
GuiMainWindow::pointer()->clearBCs();
foreach (QString name, bc_name) {
GuiMainWindow::pointer()->addBC(last_bc, BoundaryCondition(name, "patch"));
++last_bc;
}
void StlReader::operate()
{
QFileInfo file_info(GuiMainWindow::pointer()->getFilename());
QString file_name;
if (m_FileNameSet) {
file_name = m_FileName;
} else {
readInputFileName(file_info.completeBaseName() + ".stl");
if (isValid()) {
file_name = getFileName();
} else {
return;
}
}
EG_VTKSP(vtkSTLReader, stl);
stl->MergingOn();
stl->SetFileName(qPrintable(file_name));
stl->Update();
EG_VTKSP(vtkPolyData, poly);
poly->DeepCopy(stl->GetOutput());
poly->BuildCells();
double L = 1e99;
for (vtkIdType cellId = 0; cellId < poly->GetNumberOfCells(); ++cellId) {
vtkIdType *pts, Npts;
poly->GetCellPoints(cellId, Npts, pts);
for (int i = 0; i < Npts; ++i) {
vec3_t x1, x2;
poly->GetPoints()->GetPoint(pts[i], x1.data());
if (i == Npts - 1) {
poly->GetPoints()->GetPoint(pts[0], x2.data());
} else {
poly->GetPoints()->GetPoint(pts[i+1], x2.data());
}
L = min(L, (x1-x2).abs());
}
}
if (m_Tolerance < 0) {
m_Tolerance = QInputDialog::getText(NULL, "enter STL tolerance", "tolerance", QLineEdit::Normal, "1e-10").toDouble();
}
cout << "cleaning STL geometry:" << endl;
EG_VTKSP(vtkCleanPolyData, poly_clean);
EG_VTKSP(vtkFeatureEdges, topo_check);
double bounds[6];
poly->GetBounds(bounds);
poly_clean->ToleranceIsAbsoluteOn();
poly_clean->ConvertLinesToPointsOn();
poly_clean->ConvertPolysToLinesOn();
poly_clean->SetInputData(poly);
topo_check->SetInputConnection(poly_clean->GetOutputPort());
topo_check->BoundaryEdgesOn();
topo_check->ManifoldEdgesOff();
topo_check->FeatureEdgesOff();
topo_check->NonManifoldEdgesOn();
bool check_passed;
int count = 0;
do {
++count;
cout << " tolerance = " << m_Tolerance << endl;
poly_clean->SetAbsoluteTolerance(m_Tolerance);
topo_check->Update();
m_Tolerance *= 1.5;
check_passed = topo_check->GetOutput()->GetNumberOfPoints() == 0;
} while (m_Tolerance < 1 && !check_passed && count < m_MaxNumCleanIter);
if (check_passed) {
cout << "The STL geometry seems to be clean." << endl;
} else {
cout << "The STL geometry could not be cleaned." << endl;
}
// with a tolerance of " << 0.5*L << endl;
EG_VTKSP(vtkEgPolyDataToUnstructuredGridFilter, poly2ugrid);
poly2ugrid->SetInputConnection(poly_clean->GetOutputPort());
poly2ugrid->Update();
allocateGrid(m_Grid, poly2ugrid->GetOutput()->GetNumberOfCells(), poly2ugrid->GetOutput()->GetNumberOfPoints());
for (vtkIdType id_node = 0; id_node < poly2ugrid->GetOutput()->GetNumberOfPoints(); ++id_node) {
vec3_t x;
poly2ugrid->GetOutput()->GetPoints()->GetPoint(id_node, x.data());
m_Grid->GetPoints()->SetPoint(id_node, x.data());
}
for (vtkIdType id_cell = 0; id_cell < poly2ugrid->GetOutput()->GetNumberOfCells(); ++id_cell) {
vtkIdType N_pts, *pts;
vtkIdType type_cell = poly2ugrid->GetOutput()->GetCellType(id_cell);
poly2ugrid->GetOutput()->GetCellPoints(id_cell, N_pts, pts);
m_Grid->InsertNextCell(type_cell, N_pts, pts);
}
EG_VTKDCC(vtkIntArray, bc, m_Grid, "cell_code");
EG_VTKDCC(vtkIntArray, orgdir, m_Grid, "cell_orgdir");
EG_VTKDCC(vtkIntArray, voldir, m_Grid, "cell_voldir");
EG_VTKDCC(vtkIntArray, curdir, m_Grid, "cell_curdir");
for (vtkIdType id_cell = 0; id_cell < m_Grid->GetNumberOfCells(); ++id_cell) {
bc->SetValue(id_cell, 1);
orgdir->SetValue(id_cell, 0);
voldir->SetValue(id_cell, 0);
curdir->SetValue(id_cell, 0);
}
if (check_passed) {
CorrectSurfaceOrientation corr_surf;
corr_surf.setGrid(m_Grid);
corr_surf();
FixCadGeometry cad_fix;
cad_fix.setGrid(m_Grid);
cad_fix();
}
}
void TauWriter::operate()
{
try {
QFileInfo file_info(GuiMainWindow::pointer()->getFilename());
readOutputFileName(file_info.completeBaseName() + ".grid");
if (isValid()) {
QString file_name = getFileName();
NcFile *nc_file = new NcFile(file_name.toAscii(), NcFile::Replace);
if (!nc_file->is_valid()) {
EG_ERR_RETURN("unable to open NetCFD file for writing");
}
// point coordinates
size_t Np = m_Grid->GetNumberOfPoints();
vector<double> x(Np),y(Np),z(Np);
for (vtkIdType id_node = 0; id_node < m_Grid->GetNumberOfPoints(); ++id_node) {
vec3_t xv;
m_Grid->GetPoint(id_node, xv.data());
x[id_node] = xv[0];
y[id_node] = xv[1];
z[id_node] = xv[2];
}
NcDim *no_of_points = nc_file->add_dim("no_of_points", Np);
NcVar *points_xc = nc_file->add_var("points_xc", ncDouble, no_of_points);
NcVar *points_yc = nc_file->add_var("points_yc", ncDouble, no_of_points);
NcVar *points_zc = nc_file->add_var("points_zc", ncDouble, no_of_points);
points_xc->put(&x[0],Np);
points_yc->put(&y[0],Np);
points_zc->put(&z[0],Np);
// boundary faces
size_t Nbe = 0;;
size_t Nquad = 0;
size_t Ntri = 0;
for (vtkIdType id_cell = 0; id_cell < m_Grid->GetNumberOfCells(); ++id_cell) {
if (isSurface(id_cell, m_Grid)) {
++Nbe;
if (m_Grid->GetCellType(id_cell) == VTK_TRIANGLE) {
++Ntri;
} else if (m_Grid->GetCellType(id_cell) == VTK_QUAD) {
++Nquad;
} else {
EG_ERR_RETURN("unsupported boundary element type encountered");
}
}
}
NcDim *no_of_surfaceelements = nc_file->add_dim("no_of_surfaceelements", Nbe);
NcVar *boundarymarker_of_surfaces = nc_file->add_var("boundarymarker_of_surfaces", ncInt, no_of_surfaceelements);
vector<int> bm(Nbe,0), tri(3*Ntri), quad(4*Nquad);
int i_bm = 0;
QSet<int> bc_set = getAllBoundaryCodes(m_Grid);
QVector<int> bcs(bc_set.size());
qCopy(bc_set.begin(), bc_set.end(), bcs.begin());
EG_VTKDCC(vtkIntArray, cell_code, m_Grid, "cell_code");
if (Ntri) {
NcDim *no_of_surfacetriangles = nc_file->add_dim("no_of_surfacetriangles", Ntri);
NcDim *points_per_surfacetriangle = nc_file->add_dim("points_per_surfacetriangle", 3);
NcVar *points_of_surfacetriangles = nc_file->add_var("points_of_surfacetriangles", ncInt, no_of_surfacetriangles, points_per_surfacetriangle);
int i_tri = 0;
for (vtkIdType id_cell = 0; id_cell < m_Grid->GetNumberOfCells(); ++id_cell) {
if (isSurface(id_cell, m_Grid)) {
if (m_Grid->GetCellType(id_cell) == VTK_TRIANGLE) {
for (int i_bc = 0; i_bc < bcs.size(); ++i_bc) {
if (bcs[i_bc] == cell_code->GetValue(id_cell)) {
bm[i_bm] = i_bc+1;
break;
}
}
vtkIdType N_pts, *pts;
m_Grid->GetCellPoints(id_cell, N_pts, pts);
tri[i_tri + 0] = pts[0];
tri[i_tri + 1] = pts[1];
tri[i_tri + 2] = pts[2];
++i_bm;
i_tri += 3;
}
}
}
points_of_surfacetriangles->put(&tri[0],Ntri,3);
}
if (Nquad) {
NcDim *no_of_surfacequadrilaterals = nc_file->add_dim("no_of_surfacequadrilaterals",Nquad);
NcDim *points_per_surfacequadrilateral = nc_file->add_dim("points_per_surfacequadrilateral",4);
NcVar *points_of_surfacequadrilaterals = nc_file->add_var("points_of_surfacequadrilaterals",ncInt, no_of_surfacequadrilaterals, points_per_surfacequadrilateral);
int i_quad = 0;
for (vtkIdType id_cell = 0; id_cell < m_Grid->GetNumberOfCells(); ++id_cell) {
if (isSurface(id_cell, m_Grid)) {
if (m_Grid->GetCellType(id_cell) == VTK_QUAD) {
for (int i_bc = 0; i_bc < bcs.size(); ++i_bc) {
if (bcs[i_bc] == cell_code->GetValue(id_cell)) {
bm[i_bm] = i_bc+1;
break;
}
}
vtkIdType N_pts, *pts;
m_Grid->GetCellPoints(id_cell, N_pts, pts);
quad[i_quad + 0] = pts[0];
quad[i_quad + 1] = pts[1];
quad[i_quad + 2] = pts[2];
quad[i_quad + 3] = pts[3];
++i_bm;
i_quad += 4;
}
}
}
points_of_surfacequadrilaterals->put(&quad[0],Nquad,4);
}
boundarymarker_of_surfaces->put(&bm[0],Nbe);
NcDim *no_of_markers = nc_file->add_dim("no_of_markers", bcs.size());
int Ntet = 0;
int Npri = 0;
int Nhex = 0;
int Npyr = 0;
for (vtkIdType id_cell = 0; id_cell < m_Grid->GetNumberOfCells(); ++id_cell) {
if (m_Grid->GetCellType(id_cell) == VTK_TETRA) ++Ntet;
if (m_Grid->GetCellType(id_cell) == VTK_PYRAMID) ++Npyr;
if (m_Grid->GetCellType(id_cell) == VTK_WEDGE) ++Npri;
if (m_Grid->GetCellType(id_cell) == VTK_HEXAHEDRON) ++Nhex;
}
vector<int> tet(Ntet*4),pyr(Npyr*5),pri(Npri*6),hex(Nhex*8);
int i_tet = 0;
int i_pyr = 0;
int i_pri = 0;
int i_hex = 0;
if (Ntet) {
NcDim *no_of_tetraeders = nc_file->add_dim("no_of_tetraeders",Ntet);
NcDim *points_per_tetraeder = nc_file->add_dim("points_per_tetraeder",4);
NcVar *points_of_tetraeders = nc_file->add_var("points_of_tetraeders",ncInt, no_of_tetraeders, points_per_tetraeder);
for (vtkIdType id_cell = 0; id_cell < m_Grid->GetNumberOfCells(); ++id_cell) {
if (m_Grid->GetCellType(id_cell) == VTK_TETRA) {
vtkIdType *pts, N_pts;
m_Grid->GetCellPoints(id_cell, N_pts, pts);
tet[i_tet + 0] = pts[0];
tet[i_tet + 1] = pts[1];
tet[i_tet + 2] = pts[2];
tet[i_tet + 3] = pts[3];
i_tet += 4;
}
}
points_of_tetraeders->put(&tet[0],Ntet,4);
}
if (Npyr) {
NcDim *no_of_pyramids = nc_file->add_dim("no_of_pyramids",Npyr);
NcDim *points_per_pyramid = nc_file->add_dim("points_per_pyramid",5);
NcVar *points_of_pyramids = nc_file->add_var("points_of_pyramids",ncInt, no_of_pyramids, points_per_pyramid);
for (vtkIdType id_cell = 0; id_cell < m_Grid->GetNumberOfCells(); ++id_cell) {
if (m_Grid->GetCellType(id_cell) == VTK_PYRAMID) {
vtkIdType *pts, N_pts;
m_Grid->GetCellPoints(id_cell, N_pts, pts);
pyr[i_pyr + 0] = pts[0];
pyr[i_pyr + 1] = pts[1];
pyr[i_pyr + 2] = pts[2];
pyr[i_pyr + 3] = pts[3];
pyr[i_pyr + 4] = pts[4];
i_pyr += 5;
}
}
points_of_pyramids->put(&pyr[0],Npyr,5);
}
if (Npri) {
NcDim *no_of_prisms = nc_file->add_dim("no_of_prisms",Npri);
NcDim *points_per_prism = nc_file->add_dim("points_per_prism",6);
NcVar *points_of_prisms = nc_file->add_var("points_of_prisms",ncInt, no_of_prisms, points_per_prism);
for (vtkIdType id_cell = 0; id_cell < m_Grid->GetNumberOfCells(); ++id_cell) {
if (m_Grid->GetCellType(id_cell) == VTK_WEDGE) {
vtkIdType *pts, N_pts;
m_Grid->GetCellPoints(id_cell, N_pts, pts);
pri[i_pri + 0] = pts[0];
pri[i_pri + 1] = pts[2];
pri[i_pri + 2] = pts[1];
pri[i_pri + 3] = pts[3];
pri[i_pri + 4] = pts[5];
pri[i_pri + 5] = pts[4];
i_pri += 6;
}
}
points_of_prisms->put(&pri[0],Npri,6);
}
if (Nhex) {
NcDim *no_of_hexaeders = nc_file->add_dim("no_of_hexaeders",Nhex);
NcDim *points_per_hexaeder = nc_file->add_dim("points_per_hexaeder",8);
NcVar *points_of_hexaeders = nc_file->add_var("points_of_hexaeders",ncInt, no_of_hexaeders, points_per_hexaeder);
for (vtkIdType id_cell = 0; id_cell < m_Grid->GetNumberOfCells(); ++id_cell) {
if (m_Grid->GetCellType(id_cell) == VTK_HEXAHEDRON) {
vtkIdType *pts, N_pts;
m_Grid->GetCellPoints(id_cell, N_pts, pts);
hex[i_hex + 0] = pts[4];
hex[i_hex + 1] = pts[7];
hex[i_hex + 2] = pts[6];
hex[i_hex + 3] = pts[5];
hex[i_hex + 4] = pts[0];
hex[i_hex + 5] = pts[3];
hex[i_hex + 6] = pts[2];
hex[i_hex + 7] = pts[1];
i_hex += 8;
}
}
points_of_hexaeders->put(&hex[0],Nhex,8);
}
delete nc_file;
}
} catch (Error err) {
err.display();
}
}
void GuiNormalExtrusion::operate()
{
QSet<int> bcs;
getSelectedItems(m_Ui.listWidget, bcs);
EG_VTKDCC(vtkIntArray, cell_code, m_Grid, "cell_code");
QSet<int> volume_codes;
EG_FORALL_CELLS(id_cell, m_Grid) {
if (isSurface(id_cell, m_Grid)) {
if (bcs.contains(cell_code->GetValue(id_cell))) {
vtkIdType id_volume_cell = m_Part.getVolumeCell(id_cell);
if (id_volume_cell != -1) {
volume_codes.insert(cell_code->GetValue(id_volume_cell));
}
}
}
}
EG_VTKSP(vtkEgNormalExtrusion, extr);
QVector<double> y;
if (m_Ui.radioButtonSimple->isChecked()) {
y.resize(m_Ui.lineEditSimpleNumLayers->text().toInt() + 1);
double h = m_Ui.lineEditSimpleHeight->text().toDouble();
double f = m_Ui.lineEditSimpleIncrease->text().toDouble();
y[0] = 0.0;
for (int i = 1; i < y.size(); ++i) {
y[i] = y[i-1] + h;
h *= f;
}
} else if (m_Ui.radioButtonFixedHeights->isChecked()) {
y.resize(m_Ui.lineEditFixedHeightsNumLayers->text().toInt() + 1);
QVector<double> x(y.size());
for (int i = 0; i < x.size(); ++i) {
x[i] = i*1.0/(x.size() - 1);
}
mat3_t A;
clinit(A[0]) = pow(x[1],5.0), pow(x[1],3.0), x[1];
clinit(A[1]) = pow(x[x.size() - 2],5.0), pow(x[x.size() - 2],3.0), x[x.size() - 2];
clinit(A[2]) = pow(x[x.size() - 1],5.0), pow(x[x.size() - 1],3.0), x[x.size() - 1];
vec3_t h;
h[0] = m_Ui.lineEditFixedHeightsHeightFirst->text().toDouble();
h[2] = m_Ui.lineEditFixedHeightsTotalHeight->text().toDouble();
h[1] = h[2] - m_Ui.lineEditFixedHeightsHeightLast->text().toDouble();
mat3_t AI = A.inverse();
vec3_t coeff = AI*h;
for (int i = 0; i < y.size(); ++i) {
y[i] = coeff[0]*pow(x[i],5.0) + coeff[1]*pow(x[i],3.0) + coeff[2]*x[i];
if (i > 0) {
if (y[i] < y[i-1]) {
EG_ERR_RETURN("unable to compute layer heights");
}
}
}
}
extr->SetLayers(y);
if (m_Ui.radioButtonFixed->isChecked()) {
extr->SetNormal(vec3_t(m_Ui.lineEditFixedNX->text().toDouble(),
m_Ui.lineEditFixedNY->text().toDouble(),
m_Ui.lineEditFixedNZ->text().toDouble()));
double min_dist = m_Ui.lineEditFixedDist->text().toDouble();
if (min_dist <= 0) {
extr->SetFixed();
} else {
extr->SetPlanar();
extr->SetMinDist(min_dist);
}
}
if (m_Ui.radioButtonCylinder->isChecked()) {
extr->SetCylindrical();
extr->SetOrigin(vec3_t(m_Ui.lineEditCylinderX0->text().toDouble(),
m_Ui.lineEditCylinderY0->text().toDouble(),
m_Ui.lineEditCylinderZ0->text().toDouble()));
extr->SetAxis(vec3_t(m_Ui.lineEditCylinderNX->text().toDouble(),
m_Ui.lineEditCylinderNY->text().toDouble(),
m_Ui.lineEditCylinderNZ->text().toDouble()));
}
if (m_Ui.radioButtonRotation->isChecked()) {
extr->SetRotation();
extr->SetOrigin(vec3_t(m_Ui.lineEditCylinderX0->text().toDouble(),
m_Ui.lineEditCylinderY0->text().toDouble(),
m_Ui.lineEditCylinderZ0->text().toDouble()));
extr->SetAxis(vec3_t(m_Ui.lineEditCylinderNX->text().toDouble(),
m_Ui.lineEditCylinderNY->text().toDouble(),
m_Ui.lineEditCylinderNZ->text().toDouble()));
}
if (m_Ui.radioButtonNoRestrict->isChecked()) {
extr->SetRestrictNone();
}
if (m_Ui.radioButtonXY->isChecked()) {
extr->SetRestrictXY();
}
if (m_Ui.radioButtonXZ->isChecked()) {
extr->SetRestrictXZ();
}
if (m_Ui.radioButtonYZ->isChecked()) {
extr->SetRestrictYZ();
}
if (m_Ui.checkBoxNewVolume->isChecked()) {
extr->SetRemoveInternalFacesOff();
}
QList<VolumeDefinition> vols = GuiMainWindow::pointer()->getAllVols();
int vc = 1;
foreach (VolumeDefinition vol, vols) {
vc = max(vc, vol.getVC());
}
void BrlcadReader::processStlFile(QString file_name, bool append_to_list)
{
vtkSTLReader *stl = vtkSTLReader::New();
stl->MergingOn();
stl->SetFileName(file_name.toAscii().data());
stl->Update();
EG_VTKSP(vtkPolyData, poly);
poly->DeepCopy(stl->GetOutput());
poly->BuildCells();
double L = 1e99;
for (vtkIdType cellId = 0; cellId < poly->GetNumberOfCells(); ++cellId) {
vtkIdType *pts, Npts;
poly->GetCellPoints(cellId, Npts, pts);
for (int i = 0; i < Npts; ++i) {
vec3_t x1, x2;
poly->GetPoints()->GetPoint(pts[i], x1.data());
if (i == Npts - 1) {
poly->GetPoints()->GetPoint(pts[0], x2.data());
} else {
poly->GetPoints()->GetPoint(pts[i+1], x2.data());
}
L = min(L, (x1-x2).abs());
}
}
EG_VTKSP(vtkEgPolyDataToUnstructuredGridFilter, poly2ugrid);
poly2ugrid->SetInput(poly);
poly2ugrid->Update();
EG_VTKSP(vtkUnstructuredGrid, grid);
allocateGrid(grid, poly2ugrid->GetOutput()->GetNumberOfCells(), poly2ugrid->GetOutput()->GetNumberOfPoints());
for (vtkIdType id_node = 0; id_node < poly2ugrid->GetOutput()->GetNumberOfPoints(); ++id_node) {
vec3_t x;
poly2ugrid->GetOutput()->GetPoints()->GetPoint(id_node, x.data());
grid->GetPoints()->SetPoint(id_node, x.data());
}
for (vtkIdType id_cell = 0; id_cell < poly2ugrid->GetOutput()->GetNumberOfCells(); ++id_cell) {
vtkIdType N_pts, *pts;
vtkIdType type_cell = poly2ugrid->GetOutput()->GetCellType(id_cell);
poly2ugrid->GetOutput()->GetCellPoints(id_cell, N_pts, pts);
grid->InsertNextCell(type_cell, N_pts, pts);
}
EG_VTKDCC(vtkIntArray, cell_code, grid, "cell_code");
EG_VTKDCC(vtkIntArray, orgdir, grid, "cell_orgdir");
EG_VTKDCC(vtkIntArray, voldir, grid, "cell_voldir");
EG_VTKDCC(vtkIntArray, curdir, grid, "cell_curdir");
for (vtkIdType id_cell = 0; id_cell < grid->GetNumberOfCells(); ++id_cell) {
cell_code->SetValue(id_cell, 9999);
orgdir->SetValue(id_cell, 0);
voldir->SetValue(id_cell, 0);
curdir->SetValue(id_cell, 0);
}
if (append_to_list) {
SetBoundaryCode set_bc;
set_bc.setGrid(grid);
set_bc.setAllSurfaceCells();
int bc_max = 1;
bool done = false;
do {
vtkIdType id_start = -1;
for (vtkIdType id_cell = 0; id_cell < grid->GetNumberOfCells(); ++id_cell) {
if (cell_code->GetValue(id_cell) == 9999) {
id_start = id_cell;
break;
}
}
if (id_start == -1) {
done = true;
} else {
set_bc.setFeatureAngle(20.0);
set_bc.setBC(bc_max);
set_bc.setProcessAll(true);
set_bc.setSelectAllVisible(false);
set_bc.setOnlyPickedCell(false);
set_bc.setOnlyPickedCellAndNeighbours(false);
set_bc.setStart(id_start);
set_bc();
++bc_max;
}
} while (!done);
cout << "file: " << qPrintable(file_name) << endl;
for (int bc = 1; bc < bc_max; ++bc) {
QList<vtkIdType> cells;
for (vtkIdType id_cell = 0; id_cell < grid->GetNumberOfCells(); ++id_cell) {
if (cell_code->GetValue(id_cell) == bc) {
cells.append(id_cell);
}
}
vtkUnstructuredGrid *new_grid = vtkUnstructuredGrid::New();
QString bc_txt;
bc_txt.setNum(bc);
if (bc_max >= 10) {
bc_txt = bc_txt.rightJustified(2, '0');
}
QFileInfo file_info(file_name);
m_BCNames[new_grid] = file_info.baseName() + "." + bc_txt;
cout << " " << qPrintable(file_info.baseName() + "." + bc_txt) << endl;
makeCopy(grid, new_grid, cells);
m_Grids.append(new_grid);
}
} else {
makeCopy(grid, m_Grid);
}
}
void SimpleFoamWriter::createFaces()
{
l2g_t cells = getPartCells();
m_LFaces.clear();
EG_VTKDCC(vtkIntArray, cell_code, m_Grid, "cell_code");
m_BC = cell_code;
m_Eg2Of.fill(-1,cells.size());
int Nvol = 0;
foreach(int i_cells, cells) {
vtkIdType *pts;
vtkIdType Npts;
m_Grid->GetCellPoints(cells[i_cells], Npts, pts);
vtkIdType type_cell = m_Grid->GetCellType(cells[i_cells]);
vtkIdType id_cell = cells[i_cells];
// tetras
//
if (type_cell == VTK_TETRA) {
m_Eg2Of[id_cell] = Nvol++;
{
face_t F(3,id_cell,getNeigh(i_cells,0));
F.node[0] = pts[2]; F.node[1] = pts[1]; F.node[2] = pts[0];
addFace(F);
}
{
face_t F(3,id_cell,getNeigh(i_cells,1));
F.node[0] = pts[0]; F.node[1] = pts[1]; F.node[2] = pts[3];
addFace(F);
}
{
face_t F(3,id_cell,getNeigh(i_cells,2));
F.node[0] = pts[0]; F.node[1] = pts[3]; F.node[2] = pts[2];
addFace(F);
}
{
face_t F(3,id_cell,getNeigh(i_cells,3));
F.node[0] = pts[1]; F.node[1] = pts[2]; F.node[2] = pts[3];
addFace(F);
}
}
// prisms
//
if (type_cell == VTK_WEDGE) {
m_Eg2Of[id_cell] = Nvol++;
{
face_t F(3,id_cell,getNeigh(i_cells,0));
F.node[0] = pts[0]; F.node[1] = pts[1]; F.node[2] = pts[2];
addFace(F);
}
{
face_t F(3,id_cell,getNeigh(i_cells,1));
F.node[0] = pts[3]; F.node[1] = pts[5]; F.node[2] = pts[4];
addFace(F);
}
{
face_t F(4,id_cell,getNeigh(i_cells,2));
F.node[0] = pts[3]; F.node[1] = pts[4]; F.node[2] = pts[1]; F.node[3] = pts[0];
addFace(F);
}
{
face_t F(4,id_cell,getNeigh(i_cells,3));
F.node[0] = pts[1]; F.node[1] = pts[4]; F.node[2] = pts[5]; F.node[3] = pts[2];
addFace(F);
}
{
face_t F(4,id_cell,getNeigh(i_cells,4));
F.node[0] = pts[0]; F.node[1] = pts[2]; F.node[2] = pts[5]; F.node[3] = pts[3];
addFace(F);
}
}
// hexes
//
if (type_cell == VTK_HEXAHEDRON) {
m_Eg2Of[id_cell] = Nvol++;
{
face_t F(4,id_cell,getNeigh(i_cells,0),0);
F.node[0] = pts[3]; F.node[1] = pts[2]; F.node[2] = pts[1]; F.node[3] = pts[0];
addFace(F);
}
{
face_t F(4,id_cell,getNeigh(i_cells,1),0);
F.node[0] = pts[4]; F.node[1] = pts[5]; F.node[2] = pts[6]; F.node[3] = pts[7];
addFace(F);
}
{
face_t F(4,id_cell,getNeigh(i_cells,2),0);
F.node[0] = pts[0]; F.node[1] = pts[1]; F.node[2] = pts[5]; F.node[3] = pts[4];
addFace(F);
}
{
face_t F(4,id_cell,getNeigh(i_cells,3),0);
F.node[0] = pts[3]; F.node[1] = pts[7]; F.node[2] = pts[6]; F.node[3] = pts[2];
addFace(F);
}
{
face_t F(4,id_cell,getNeigh(i_cells,4),0);
F.node[0] = pts[0]; F.node[1] = pts[4]; F.node[2] = pts[7]; F.node[3] = pts[3];
addFace(F);
}
{
face_t F(4,id_cell,getNeigh(i_cells,5),0);
F.node[0] = pts[1]; F.node[1] = pts[2]; F.node[2] = pts[6]; F.node[3] = pts[5];
addFace(F);
}
}
}
