PView *GMSH_BubblesPlugin::execute(PView *v)
{
double shrink = (double)BubblesOptions_Number[0].def;
std::string fileName = BubblesOptions_String[0].def;
FILE *fp = Fopen(fileName.c_str(), "w");
if(!fp){
Msg::Error("Could not open output file '%s'", fileName.c_str());
return v;
}
GModel *m = GModel::current();
int p = m->getMaxElementaryNumber(0) + 1;
int l = m->getMaxElementaryNumber(1) + 1;
int s = m->getMaxElementaryNumber(2) + 1;
int ll = s, ps = 1;
SBoundingBox3d bbox = m->bounds();
double lc = norm(SVector3(bbox.max(), bbox.min())) / 100;
fprintf(fp, "lc = %g;\n", lc);
for(GModel::viter vit = m->firstVertex(); vit != m->lastVertex(); vit++)
(*vit)->writeGEO(fp, "lc");
for(GModel::eiter eit = m->firstEdge(); eit != m->lastEdge(); eit++)
(*eit)->writeGEO(fp);
for(GModel::fiter fit = m->firstFace(); fit != m->lastFace(); fit++){
(*fit)->writeGEO(fp);
fprintf(fp, "Delete { Surface {%d}; }\n", (*fit)->tag());
int sbeg = s;
int llbeg = ll;
// compute vertex-to-triangle_barycenter map
std::map<MVertex*, std::vector<SPoint3> > v2t;
for(unsigned int i = 0; i < (*fit)->triangles.size(); i++)
for(int j = 0; j < 3; j++)
v2t[(*fit)->triangles[i]->getVertex(j)].push_back((*fit)->triangles[i]->barycenter());
// add boundary vertices in map to get cells "closer" to the boundary
for(std::map<MVertex*, std::vector<SPoint3> >::iterator it = v2t.begin();
it != v2t.end(); it++){
MVertex *v = it->first;
if(v->onWhat() && v->onWhat()->dim() < 2)
it->second.push_back(SPoint3(it->first->x(), it->first->y(), it->first->z()));
}
for(std::map<MVertex*, std::vector<SPoint3> >::iterator it = v2t.begin();
it != v2t.end(); it++){
if(it->second.size() > 2){
// get barycenter of cell boundary points and order them
SPoint3 bc;
for(unsigned int i = 0; i < it->second.size(); i++)
bc += it->second[i];
bc *= 1. / (double)it->second.size();
compareAngle comp(bc);
std::sort(it->second.begin(), it->second.end(), comp);
// shrink cells
if(shrink){
for(unsigned int i = 0; i < it->second.size(); i++){
double dir[3] = {it->second[i].x() - bc.x(),
it->second[i].y() - bc.y(),
it->second[i].z() - bc.z()};
it->second[i][0] -= shrink * dir[0];
it->second[i][1] -= shrink * dir[1];
it->second[i][2] -= shrink * dir[2];
}
}
// create b-spline bounded surface for each cell
int nump = it->second.size();
for(int i = 0; i < nump; i++){
SPoint3 &b(it->second[i]);
fprintf(fp, "Point(%d) = {%.16g, %.16g, %.16g, lc};\n", p++, b.x(), b.y(), b.z());
}
fprintf(fp, "BSpline(%d) = {", l++);
for(int i = nump - 1; i >= 0; i--)
fprintf(fp, "%d,", p - i - 1);
fprintf(fp, "%d};\n", p - nump);
fprintf(fp, "Line Loop(%d) = {%d};\n", ll++, l - 1);
fprintf(fp, "Plane Surface(%d) = {%d};\n", s++, ll - 1);
}
}
fprintf(fp, "Physical Surface(%d) = {%d:%d};\n", ps++, sbeg, s - 1);
fprintf(fp, "Plane Surface(%d) = {%d, %d:%d};\n", s++, (*fit)->tag(), llbeg, ll - 1);
fprintf(fp, "Physical Surface(%d) = {%d};\n", ps++, s - 1);
}
fclose(fp);
return v;
}
void GMSH_SimplePartitionPlugin::run()
{
#if defined(HAVE_MESH)
int numSlicesX = (int)SimplePartitionOptions_Number[0].def;
int numSlicesY = (int)SimplePartitionOptions_Number[1].def;
int numSlicesZ = (int)SimplePartitionOptions_Number[2].def;
int createTopology = (int)SimplePartitionOptions_Number[3].def;
std::vector<std::string> exprX(1), exprY(1), exprZ(1);
exprX[0] = SimplePartitionOptions_String[0].def;
exprY[0] = SimplePartitionOptions_String[1].def;
exprZ[0] = SimplePartitionOptions_String[2].def;
GModel *m = GModel::current();
if(!m->getNumMeshElements()){
Msg::Error("Plugin(SimplePartition) requires a mesh");
return;
}
if(numSlicesX < 1 || numSlicesY < 1 || numSlicesZ < 1){
Msg::Error("Number of slices should be strictly positive");
return;
}
m->unpartitionMesh();
SBoundingBox3d bbox = m->bounds();
double pminX = bbox.min()[0], pmaxX = bbox.max()[0];
double pminY = bbox.min()[1], pmaxY = bbox.max()[1];
double pminZ = bbox.min()[2], pmaxZ = bbox.max()[2];
std::vector<double> ppX(numSlicesX + 1);
std::vector<double> ppY(numSlicesY + 1);
std::vector<double> ppZ(numSlicesZ + 1);
std::vector<std::string> variables(1, "t");
std::vector<double> values(1), res(1);
{
mathEvaluator f(exprX, variables);
for(int p = 0; p <= numSlicesX; p++) {
double t = values[0] = (double)p / (double)numSlicesX;
if(f.eval(values, res)) t = res[0];
ppX[p] = pminX + t * (pmaxX - pminX);
}
}
bool emptyX = (ppX[0] == ppX[numSlicesX]);
{
mathEvaluator f(exprY, variables);
for(int p = 0; p <= numSlicesY; p++) {
double t = values[0] = (double)p / (double)numSlicesY;
if(f.eval(values, res)) t = res[0];
ppY[p] = pminY + t * (pmaxY - pminY);
}
}
bool emptyY = (ppY[0] == ppY[numSlicesY]);
{
mathEvaluator f(exprZ, variables);
for(int p = 0; p <= numSlicesZ; p++) {
double t = values[0] = (double)p / (double)numSlicesZ;
if(f.eval(values, res)) t = res[0];
ppZ[p] = pminZ + t * (pmaxZ - pminZ);
}
}
bool emptyZ = (ppZ[0] == ppZ[numSlicesZ]);
std::vector<GEntity *> entities;
m->getEntities(entities);
hashmap<MElement *, unsigned int> elmToPartition;
for(std::size_t i = 0; i < entities.size(); i++) {
GEntity *ge = entities[i];
for(std::size_t j = 0; j < ge->getNumMeshElements(); j++) {
MElement *e = ge->getMeshElement(j);
SPoint3 point = e->barycenter();
int part = 0;
for(int kx = 0; kx < numSlicesX; kx++) {
if(part) break;
for(int ky = 0; ky < numSlicesY; ky++) {
if(part) break;
for(int kz = 0; kz < numSlicesZ; kz++) {
if(part) break;
if((emptyX || (kx == 0 && ppX[0] == point[0]) ||
(ppX[kx] < point[0] && point[0] <= ppX[kx + 1])) &&
(emptyY || (ky == 0 && ppY[0] == point[1]) ||
(ppY[ky] < point[1] && point[1] <= ppY[ky + 1])) &&
(emptyZ || (kz == 0 && ppZ[0] == point[2]) ||
(ppZ[kz] < point[2] && point[2] <= ppZ[kz + 1]))){
part = kx * numSlicesY * numSlicesZ + ky * numSlicesZ + kz + 1;
elmToPartition.insert(std::pair<MElement *, unsigned int>(e, part));
e->setPartition(part); // this will be removed
}
}
}
}
}
}
opt_mesh_partition_create_topology(0, GMSH_SET | GMSH_GUI, createTopology);
int ier = PartitionUsingThisSplit(m, numSlicesX * numSlicesY * numSlicesZ,
elmToPartition);
if(!ier) {
opt_mesh_color_carousel(0, GMSH_SET | GMSH_GUI, 3.);
CTX::instance()->mesh.changed = ENT_ALL;
}
#else
Msg::Error("Gmsh must be compiled with Mesh support to partition meshes");
#endif
}
MarkeredSurface MarkeredSurfaceGeoGenerator::generate(string fileName, real size)
{
Engine& engine = Engine::getInstance();
LOG_INFO("Generating markered surface from Geo file " << fileName);
GmshSetOption("General", "Terminal", 1.0);
GmshSetOption("General", "Verbosity", engine.getGmshVerbosity());
GmshSetOption("General", "ExpertMode", 1.0);
GModel gmshModel;
gmshModel.setFactory("Gmsh");
gmshModel.readGEO(fileName);
float clmin, clmax;
if (size > 0)
{
clmin = size*0.8;
clmax = size*1.2;
}
else
{
auto _min = gmshModel.bounds().min();
auto _max = gmshModel.bounds().max();
auto d1 = _max.x() - _min.x();
auto d2 = _max.y() - _min.y();
auto d3 = _max.z() - _min.z();
if ((d1/d2 >= 0.8) && (d1/d2 <= 1.2) && (d1/d3 >= 0.8) && (d1/d3 <= 1.2))
{
auto d = gmshModel.bounds().diag();
clmin = d/80;
clmax = d/60;
}
else
{
auto d = min({d1, d2, d3});
clmin = d/10;
clmax = d/5;
}
}
GmshSetOption("Mesh", "CharacteristicLengthMin", clmin);
GmshSetOption("Mesh", "CharacteristicLengthMax", clmax);
gmshModel.mesh(2);
vector<GEntity*> entities;
gmshModel.getEntities(entities);
auto nverts = gmshModel.getNumMeshVertices();
vector<CalcNode> markers;
vector<TriangleFirstOrder> faces;
vector<int> regions;
int *newVertNums = new int[nverts+1];
for (int i = 0; i <= nverts; i++)
newVertNums[i] = -1;
MVertex* verts[3];
int nf = 0;
int nv = 0;
for (auto e: entities)
{
if (e->geomType() == GEntity::RuledSurface || e->geomType() == GEntity::Plane)
{
regions.push_back(e->getNumMeshElements());
for (unsigned int i = 0; i < e->getNumMeshElements(); i++)
{
auto elem = e->getMeshElement(i);
assert_eq(elem->getNumFaces(), 1);
auto face = elem->getFace(0);
for (int j = 0; j < 3; j++)
verts[j] = face.getVertex(j);
int v[3];
for (int j = 0; j < 3; j++)
{
if (newVertNums[verts[j]->getNum()] == -1)
{
newVertNums[verts[j]->getNum()] = nv;
markers.push_back(CalcNode(nv, vector3r(verts[j]->x(), verts[j]->y(), verts[j]->z())));
nv++;
}
v[j] = newVertNums[verts[j]->getNum()];
}
faces.push_back(TriangleFirstOrder(nf++, v));
}
}
}
assert_gt(markers.size(), 0);
assert_gt(faces.size(), 0);
delete[] newVertNums;
return MarkeredSurface(markers, faces, regions);
}