MESHING3_RESULT OptimizeVolume (MeshingParameters & mp,
Mesh & mesh3d)
// const CSGeometry * geometry)
{
int i;
PrintMessage (1, "Volume Optimization");
/*
if (!mesh3d.PureTetMesh())
return MESHING3_OK;
*/
// (*mycout) << "optstring = " << mp.optimize3d << endl;
/*
const char * optstr = globflags.GetStringFlag ("optimize3d", "cmh");
int optsteps = int (globflags.GetNumFlag ("optsteps3d", 2));
*/
mesh3d.CalcSurfacesOfNode();
for (i = 1; i <= mp.optsteps3d; i++)
{
if (multithread.terminate)
break;
MeshOptimize3d optmesh(mp);
// teterrpow = mp.opterrpow;
// for (size_t j = 1; j <= strlen(mp.optimize3d); j++)
for (size_t j = 1; j <= mp.optimize3d.length(); j++)
{
if (multithread.terminate)
break;
switch (mp.optimize3d[j-1])
{
case 'c': optmesh.CombineImprove(mesh3d, OPT_REST); break;
case 'd': optmesh.SplitImprove(mesh3d); break;
case 's': optmesh.SwapImprove(mesh3d); break;
// case 'u': optmesh.SwapImproveSurface(mesh3d); break;
case 't': optmesh.SwapImprove2(mesh3d); break;
#ifdef SOLIDGEOM
case 'm': mesh3d.ImproveMesh(*geometry); break;
case 'M': mesh3d.ImproveMesh(*geometry); break;
#else
case 'm': mesh3d.ImproveMesh(mp); break;
case 'M': mesh3d.ImproveMesh(mp); break;
#endif
case 'j': mesh3d.ImproveMeshJacobian(mp); break;
}
}
mesh3d.mglevels = 1;
MeshQuality3d (mesh3d);
}
return MESHING3_OK;
}
DLL_HEADER void Optimize2d (Mesh & mesh, MeshingParameters & mp)
{
static int timer = NgProfiler::CreateTimer ("optimize2d");
NgProfiler::RegionTimer reg(timer);
mesh.CalcSurfacesOfNode();
const char * optstr = mp.optimize2d.c_str();
int optsteps = mp.optsteps2d;
for (int i = 1; i <= optsteps; i++)
for (size_t j = 1; j <= strlen(optstr); j++)
{
if (multithread.terminate) break;
switch (optstr[j-1])
{
case 's':
{ // topological swap
MeshOptimize2d meshopt;
meshopt.SetMetricWeight (mp.elsizeweight);
meshopt.EdgeSwapping (mesh, 0);
break;
}
case 'S':
{ // metric swap
MeshOptimize2d meshopt;
meshopt.SetMetricWeight (mp.elsizeweight);
meshopt.EdgeSwapping (mesh, 1);
break;
}
case 'm':
{
MeshOptimize2d meshopt;
meshopt.SetMetricWeight (mp.elsizeweight);
meshopt.ImproveMesh(mesh, mp);
break;
}
case 'c':
{
MeshOptimize2d meshopt;
meshopt.SetMetricWeight (mp.elsizeweight);
meshopt.CombineImprove(mesh);
break;
}
default:
cerr << "Optimization code " << optstr[j-1] << " not defined" << endl;
}
}
}
// Mesh the edges and add Face descriptors to prepare for surface meshing
DLL_HEADER Ng_Result Ng_OCC_GenerateSurfaceMesh (Ng_OCC_Geometry * geom,
Ng_Mesh * mesh,
Ng_Meshing_Parameters * mp)
{
int numpoints = 0;
OCCGeometry * occgeom = (OCCGeometry*)geom;
Mesh * me = (Mesh*)mesh;
// Set the internal meshing parameters structure from the nglib meshing
// parameters structure
mp->Transfer_Parameters();
// Only go into surface meshing if the face descriptors have already been added
if(!me->GetNFD())
return NG_ERROR;
numpoints = me->GetNP();
// Initially set up only for surface meshing without any optimisation
int perfstepsend = MESHCONST_MESHSURFACE;
// Check and if required, enable surface mesh optimisation step
if(mp->optsurfmeshenable)
{
perfstepsend = MESHCONST_OPTSURFACE;
}
OCCMeshSurface(*occgeom, *me, perfstepsend);
me->CalcSurfacesOfNode();
if(me->GetNP() <= numpoints)
return NG_ERROR;
if(me->GetNSE() <= 0)
return NG_ERROR;
return NG_OK;
}
void RemoveIllegalElements (Mesh & mesh3d)
{
int it = 10;
int nillegal, oldn;
PrintMessage (1, "Remove Illegal Elements");
// return, if non-pure tet-mesh
/*
if (!mesh3d.PureTetMesh())
return;
*/
mesh3d.CalcSurfacesOfNode();
nillegal = mesh3d.MarkIllegalElements();
MeshingParameters dummymp;
MeshOptimize3d optmesh(dummymp);
while (nillegal && (it--) > 0)
{
if (multithread.terminate)
break;
PrintMessage (5, nillegal, " illegal tets");
optmesh.SplitImprove (mesh3d, OPT_LEGAL);
mesh3d.MarkIllegalElements(); // test
optmesh.SwapImprove (mesh3d, OPT_LEGAL);
mesh3d.MarkIllegalElements(); // test
optmesh.SwapImprove2 (mesh3d, OPT_LEGAL);
oldn = nillegal;
nillegal = mesh3d.MarkIllegalElements();
if (oldn != nillegal)
it = 10;
}
PrintMessage (5, nillegal, " illegal tets");
}
void RepairBisection(Mesh & mesh, Array<ElementIndex> & bad_elements,
const BitArray & isnewpoint, const Refinement & refinement,
const Array<double> & pure_badness,
double max_worsening, const bool uselocalworsening,
const Array< Array<int,PointIndex::BASE>* > & idmaps)
{
ostringstream ostrstr;
const int maxtrials = 100;
//bool doit;
//cout << "DOIT: " << flush;
//cin >> doit;
int ne = mesh.GetNE();
int np = mesh.GetNP();
int numbadneighbours = 3;
const int numtopimprove = 3;
PrintMessage(1,"repairing");
PushStatus("Repair Bisection");
Array<Point<3>* > should(np);
Array<Point<3>* > can(np);
Array<Vec<3>* > nv(np);
for(int i=0; i<np; i++)
{
nv[i] = new Vec<3>;
should[i] = new Point<3>;
can[i] = new Point<3>;
}
BitArray isboundarypoint(np),isedgepoint(np);
isboundarypoint.Clear();
isedgepoint.Clear();
for(int i = 1; i <= mesh.GetNSeg(); i++)
{
const Segment & seg = mesh.LineSegment(i);
isedgepoint.Set(seg[0]);
isedgepoint.Set(seg[1]);
}
Array<int> surfaceindex(np);
surfaceindex = -1;
for (int i = 1; i <= mesh.GetNSE(); i++)
{
const Element2d & sel = mesh.SurfaceElement(i);
for (int j = 1; j <= sel.GetNP(); j++)
if(!isedgepoint.Test(sel.PNum(j)))
{
isboundarypoint.Set(sel.PNum(j));
surfaceindex[sel.PNum(j) - PointIndex::BASE] =
mesh.GetFaceDescriptor(sel.GetIndex()).SurfNr();
}
}
Validate(mesh,bad_elements,pure_badness,
((uselocalworsening) ? (0.8*(max_worsening-1.) + 1.) : (0.1*(max_worsening-1.) + 1.)),
uselocalworsening); // -> larger working area
BitArray working_elements(ne);
BitArray working_points(np);
GetWorkingArea(working_elements,working_points,mesh,bad_elements,numbadneighbours);
//working_elements.Set();
//working_points.Set();
ostrstr.str("");
ostrstr << "worsening: " <<
Validate(mesh,bad_elements,pure_badness,max_worsening,uselocalworsening);
PrintMessage(4,ostrstr.str());
int auxnum=0;
for(int i=1; i<=np; i++)
if(working_points.Test(i))
auxnum++;
ostrstr.str("");
ostrstr << "Percentage working points: " << 100.*double(auxnum)/np;
PrintMessage(5,ostrstr.str());
BitArray isworkingboundary(np);
for(int i=1; i<=np; i++)
if(working_points.Test(i) && isboundarypoint.Test(i))
isworkingboundary.Set(i);
else
isworkingboundary.Clear(i);
for(int i=0; i<np; i++)
*should[i] = mesh.Point(i+1);
for(int i=0; i<np; i++)
{
if(isnewpoint.Test(i+PointIndex::BASE) &&
//working_points.Test(i+PointIndex::BASE) &&
mesh.mlbetweennodes[i+PointIndex::BASE][0] > 0)
*can[i] = Center(*can[mesh.mlbetweennodes[i+PointIndex::BASE][0]-PointIndex::BASE],
*can[mesh.mlbetweennodes[i+PointIndex::BASE][1]-PointIndex::BASE]);
else
*can[i] = mesh.Point(i+1);
}
int cnttrials = 1;
double lamedge = 0.5;
double lamface = 0.5;
double facokedge = 0;
double facokface = 0;
double factryedge;
double factryface = 0;
double oldlamedge,oldlamface;
MeshOptimize2d * optimizer2d = refinement.Get2dOptimizer();
if(!optimizer2d)
{
cerr << "No 2D Optimizer!" << endl;
return;
}
while ((facokedge < 1.-1e-8 || facokface < 1.-1e-8) &&
cnttrials < maxtrials &&
multithread.terminate != 1)
{
(*testout) << " facokedge " << facokedge << " facokface " << facokface << " cnttrials " << cnttrials << endl
<< " perc. " << 95. * max2( min2(facokedge,facokface),
double(cnttrials)/double(maxtrials)) << endl;
SetThreadPercent(95. * max2( min2(facokedge,facokface),
double(cnttrials)/double(maxtrials)));
ostrstr.str("");
ostrstr << "max. worsening " << max_worsening;
PrintMessage(5,ostrstr.str());
oldlamedge = lamedge;
lamedge *= 6;
if (lamedge > 2)
lamedge = 2;
if(1==1 || facokedge < 1.-1e-8)
{
for(int i=0; i<nv.Size(); i++)
*nv[i] = Vec<3>(0,0,0);
for (int i = 1; i <= mesh.GetNSE(); i++)
{
const Element2d & sel = mesh.SurfaceElement(i);
Vec<3> auxvec = Cross(mesh.Point(sel.PNum(2))-mesh.Point(sel.PNum(1)),
mesh.Point(sel.PNum(3))-mesh.Point(sel.PNum(1)));
auxvec.Normalize();
for (int j = 1; j <= sel.GetNP(); j++)
if(!isedgepoint.Test(sel.PNum(j)))
*nv[sel.PNum(j) - PointIndex::BASE] += auxvec;
}
for(int i=0; i<nv.Size(); i++)
nv[i]->Normalize();
do // move edges
{
lamedge *= 0.5;
cnttrials++;
if(cnttrials % 10 == 0)
max_worsening *= 1.1;
factryedge = lamedge + (1.-lamedge) * facokedge;
ostrstr.str("");
ostrstr << "lamedge = " << lamedge << ", trying: " << factryedge;
PrintMessage(5,ostrstr.str());
for (int i = 1; i <= np; i++)
{
if (isedgepoint.Test(i))
{
for (int j = 0; j < 3; j++)
mesh.Point(i)(j) =
lamedge * (*should.Get(i))(j) +
(1.-lamedge) * (*can.Get(i))(j);
}
else
mesh.Point(i) = *can.Get(i);
}
if(facokedge < 1.-1e-8)
{
ostrstr.str("");
ostrstr << "worsening: " <<
Validate(mesh,bad_elements,pure_badness,max_worsening,uselocalworsening);
PrintMessage(5,ostrstr.str());
}
else
Validate(mesh,bad_elements,pure_badness,-1,uselocalworsening);
ostrstr.str("");
ostrstr << bad_elements.Size() << " bad elements";
PrintMessage(5,ostrstr.str());
}
while (bad_elements.Size() > 0 &&
cnttrials < maxtrials &&
multithread.terminate != 1);
}
if(cnttrials < maxtrials &&
multithread.terminate != 1)
{
facokedge = factryedge;
// smooth faces
mesh.CalcSurfacesOfNode();
MeshingParameters dummymp;
mesh.ImproveMeshJacobianOnSurface(dummymp,isworkingboundary,nv,OPT_QUALITY, &idmaps);
for (int i = 1; i <= np; i++)
*can.Elem(i) = mesh.Point(i);
if(optimizer2d)
optimizer2d->ProjectBoundaryPoints(surfaceindex,can,should);
}
oldlamface = lamface;
lamface *= 6;
if (lamface > 2)
lamface = 2;
if(cnttrials < maxtrials &&
multithread.terminate != 1)
{
do // move faces
{
lamface *= 0.5;
cnttrials++;
if(cnttrials % 10 == 0)
max_worsening *= 1.1;
factryface = lamface + (1.-lamface) * facokface;
ostrstr.str("");
ostrstr << "lamface = " << lamface << ", trying: " << factryface;
PrintMessage(5,ostrstr.str());
for (int i = 1; i <= np; i++)
{
if (isboundarypoint.Test(i))
{
for (int j = 0; j < 3; j++)
mesh.Point(i)(j) =
lamface * (*should.Get(i))(j) +
(1.-lamface) * (*can.Get(i))(j);
}
else
mesh.Point(i) = *can.Get(i);
}
ostrstr.str("");
ostrstr << "worsening: " <<
Validate(mesh,bad_elements,pure_badness,max_worsening,uselocalworsening);
PrintMessage(5,ostrstr.str());
ostrstr.str("");
ostrstr << bad_elements.Size() << " bad elements";
PrintMessage(5,ostrstr.str());
}
while (bad_elements.Size() > 0 &&
cnttrials < maxtrials &&
multithread.terminate != 1);
}
if(cnttrials < maxtrials &&
multithread.terminate != 1)
{
facokface = factryface;
// smooth interior
mesh.CalcSurfacesOfNode();
MeshingParameters dummymp;
mesh.ImproveMeshJacobian (dummymp, OPT_QUALITY,&working_points);
//mesh.ImproveMeshJacobian (OPT_WORSTCASE,&working_points);
for (int i = 1; i <= np; i++)
*can.Elem(i) = mesh.Point(i);
}
//!
if((facokedge < 1.-1e-8 || facokface < 1.-1e-8) &&
cnttrials < maxtrials &&
multithread.terminate != 1)
{
MeshingParameters dummymp;
MeshOptimize3d optmesh(dummymp);
for(int i=0; i<numtopimprove; i++)
{
optmesh.SwapImproveSurface(mesh,OPT_QUALITY,&working_elements,&idmaps);
optmesh.SwapImprove(mesh,OPT_QUALITY,&working_elements);
}
// mesh.mglevels = 1;
ne = mesh.GetNE();
working_elements.SetSize(ne);
for (int i = 1; i <= np; i++)
mesh.Point(i) = *should.Elem(i);
Validate(mesh,bad_elements,pure_badness,
((uselocalworsening) ? (0.8*(max_worsening-1.) + 1.) : (0.1*(max_worsening-1.) + 1.)),
uselocalworsening);
if(lamedge < oldlamedge || lamface < oldlamface)
numbadneighbours++;
GetWorkingArea(working_elements,working_points,mesh,bad_elements,numbadneighbours);
for(int i=1; i<=np; i++)
if(working_points.Test(i) && isboundarypoint.Test(i))
isworkingboundary.Set(i);
else
isworkingboundary.Clear(i);
auxnum=0;
for(int i=1; i<=np; i++)
if(working_points.Test(i))
auxnum++;
ostrstr.str("");
ostrstr << "Percentage working points: " << 100.*double(auxnum)/np;
PrintMessage(5,ostrstr.str());
for (int i = 1; i <= np; i++)
mesh.Point(i) = *can.Elem(i);
}
//!
}
MeshingParameters dummymp;
MeshOptimize3d optmesh(dummymp);
for(int i=0; i<numtopimprove && multithread.terminate != 1; i++)
{
optmesh.SwapImproveSurface(mesh,OPT_QUALITY,NULL,&idmaps);
optmesh.SwapImprove(mesh,OPT_QUALITY);
//mesh.UpdateTopology();
}
mesh.UpdateTopology();
/*
if(cnttrials < 100)
{
nv = Vec3d(0,0,0);
for (int i = 1; i <= mesh.GetNSE(); i++)
{
const Element2d & sel = mesh.SurfaceElement(i);
Vec3d auxvec = Cross(mesh.Point(sel.PNum(2))-mesh.Point(sel.PNum(1)),
mesh.Point(sel.PNum(3))-mesh.Point(sel.PNum(1)));
auxvec.Normalize();
for (int j = 1; j <= sel.GetNP(); j++)
if(!isedgepoint.Test(sel.PNum(j)))
nv[sel.PNum(j) - PointIndex::BASE] += auxvec;
}
for(int i=0; i<nv.Size(); i++)
nv[i].Normalize();
mesh.ImproveMeshJacobianOnSurface(isboundarypoint,nv,OPT_QUALITY);
mesh.CalcSurfacesOfNode();
// smooth interior
for (int i = 1; i <= np; i++)
if(isboundarypoint.Test(i))
can.Elem(i) = mesh.Point(i);
if(optimizer2d)
optimizer2d->ProjectBoundaryPoints(surfaceindex,can,should);
for (int i = 1; i <= np; i++)
if(isboundarypoint.Test(i))
for(int j=1; j<=3; j++)
mesh.Point(i).X(j) = should.Get(i).X(j);
}
*/
if(cnttrials == maxtrials)
{
for (int i = 1; i <= np; i++)
mesh.Point(i) = *should.Get(i);
Validate(mesh,bad_elements,pure_badness,max_worsening,uselocalworsening);
for(int i=0; i<bad_elements.Size(); i++)
{
ostrstr.str("");
ostrstr << "bad element:" << endl
<< mesh[bad_elements[i]][0] << ": " << mesh.Point(mesh[bad_elements[i]][0]) << endl
<< mesh[bad_elements[i]][1] << ": " << mesh.Point(mesh[bad_elements[i]][1]) << endl
<< mesh[bad_elements[i]][2] << ": " << mesh.Point(mesh[bad_elements[i]][2]) << endl
<< mesh[bad_elements[i]][3] << ": " << mesh.Point(mesh[bad_elements[i]][3]);
PrintMessage(5,ostrstr.str());
}
for (int i = 1; i <= np; i++)
mesh.Point(i) = *can.Get(i);
}
for(int i=0; i<np; i++)
{
delete nv[i];
delete can[i];
delete should[i];
}
PopStatus();
}
// extern double teterrpow;
MESHING3_RESULT MeshVolume (MeshingParameters & mp, Mesh& mesh3d)
{
int oldne;
int meshed;
Array<INDEX_2> connectednodes;
if (&mesh3d.LocalHFunction() == NULL) mesh3d.CalcLocalH(mp.grading);
mesh3d.Compress();
// mesh3d.PrintMemInfo (cout);
if (mp.checkoverlappingboundary)
if (mesh3d.CheckOverlappingBoundary())
throw NgException ("Stop meshing since boundary mesh is overlapping");
int nonconsist = 0;
for (int k = 1; k <= mesh3d.GetNDomains(); k++)
{
PrintMessage (3, "Check subdomain ", k, " / ", mesh3d.GetNDomains());
mesh3d.FindOpenElements(k);
/*
bool res = mesh3d.CheckOverlappingBoundary();
if (res)
{
PrintError ("Surface is overlapping !!");
nonconsist = 1;
}
*/
bool res = (mesh3d.CheckConsistentBoundary() != 0);
if (res)
{
PrintError ("Surface mesh not consistent");
nonconsist = 1;
}
}
if (nonconsist)
{
PrintError ("Stop meshing since surface mesh not consistent");
throw NgException ("Stop meshing since surface mesh not consistent");
}
double globmaxh = mp.maxh;
for (int k = 1; k <= mesh3d.GetNDomains(); k++)
{
if (multithread.terminate)
break;
PrintMessage (2, "");
PrintMessage (1, "Meshing subdomain ", k, " of ", mesh3d.GetNDomains());
(*testout) << "Meshing subdomain " << k << endl;
mp.maxh = min2 (globmaxh, mesh3d.MaxHDomain(k));
mesh3d.CalcSurfacesOfNode();
mesh3d.FindOpenElements(k);
if (!mesh3d.GetNOpenElements())
continue;
Box<3> domain_bbox( Box<3>::EMPTY_BOX );
for (SurfaceElementIndex sei = 0; sei < mesh3d.GetNSE(); sei++)
{
const Element2d & el = mesh3d[sei];
if (el.IsDeleted() ) continue;
if (mesh3d.GetFaceDescriptor(el.GetIndex()).DomainIn() == k ||
mesh3d.GetFaceDescriptor(el.GetIndex()).DomainOut() == k)
for (int j = 0; j < el.GetNP(); j++)
domain_bbox.Add (mesh3d[el[j]]);
}
domain_bbox.Increase (0.01 * domain_bbox.Diam());
for (int qstep = 1; qstep <= 3; qstep++)
{
// cout << "openquads = " << mesh3d.HasOpenQuads() << endl;
if (mesh3d.HasOpenQuads())
{
string rulefile = ngdir;
const char ** rulep = NULL;
switch (qstep)
{
case 1:
rulefile += "/rules/prisms2.rls";
rulep = prismrules2;
break;
case 2: // connect pyramid to triangle
rulefile += "/rules/pyramids2.rls";
rulep = pyramidrules2;
break;
case 3: // connect to vis-a-vis point
rulefile += "/rules/pyramids.rls";
rulep = pyramidrules;
break;
}
// Meshing3 meshing(rulefile);
Meshing3 meshing(rulep);
MeshingParameters mpquad = mp;
mpquad.giveuptol = 15;
mpquad.baseelnp = 4;
mpquad.starshapeclass = 1000;
mpquad.check_impossible = qstep == 1; // for prisms only (air domain in trafo)
for (PointIndex pi = mesh3d.Points().Begin(); pi < mesh3d.Points().End(); pi++)
meshing.AddPoint (mesh3d[pi], pi);
mesh3d.GetIdentifications().GetPairs (0, connectednodes);
for (int i = 1; i <= connectednodes.Size(); i++)
meshing.AddConnectedPair (connectednodes.Get(i));
for (int i = 1; i <= mesh3d.GetNOpenElements(); i++)
{
Element2d hel = mesh3d.OpenElement(i);
meshing.AddBoundaryElement (hel);
}
oldne = mesh3d.GetNE();
meshing.GenerateMesh (mesh3d, mpquad);
for (int i = oldne + 1; i <= mesh3d.GetNE(); i++)
mesh3d.VolumeElement(i).SetIndex (k);
(*testout)
<< "mesh has " << mesh3d.GetNE() << " prism/pyramid elements" << endl;
mesh3d.FindOpenElements(k);
}
}
if (mesh3d.HasOpenQuads())
{
PrintSysError ("mesh has still open quads");
throw NgException ("Stop meshing since too many attempts");
// return MESHING3_GIVEUP;
}
if (mp.delaunay && mesh3d.GetNOpenElements())
{
Meshing3 meshing((const char**)NULL);
mesh3d.FindOpenElements(k);
/*
for (PointIndex pi = mesh3d.Points().Begin(); pi < mesh3d.Points().End(); pi++)
meshing.AddPoint (mesh3d[pi], pi);
*/
for (PointIndex pi : mesh3d.Points().Range())
meshing.AddPoint (mesh3d[pi], pi);
for (int i = 1; i <= mesh3d.GetNOpenElements(); i++)
meshing.AddBoundaryElement (mesh3d.OpenElement(i));
oldne = mesh3d.GetNE();
meshing.Delaunay (mesh3d, k, mp);
for (int i = oldne + 1; i <= mesh3d.GetNE(); i++)
mesh3d.VolumeElement(i).SetIndex (k);
PrintMessage (3, mesh3d.GetNP(), " points, ",
mesh3d.GetNE(), " elements");
}
int cntsteps = 0;
if (mesh3d.GetNOpenElements())
do
{
if (multithread.terminate)
break;
mesh3d.FindOpenElements(k);
PrintMessage (5, mesh3d.GetNOpenElements(), " open faces");
cntsteps++;
if (cntsteps > mp.maxoutersteps)
throw NgException ("Stop meshing since too many attempts");
string rulefile = ngdir + "/tetra.rls";
PrintMessage (1, "start tetmeshing");
// Meshing3 meshing(rulefile);
Meshing3 meshing(tetrules);
Array<int, PointIndex::BASE> glob2loc(mesh3d.GetNP());
glob2loc = -1;
for (PointIndex pi = mesh3d.Points().Begin(); pi < mesh3d.Points().End(); pi++)
if (domain_bbox.IsIn (mesh3d[pi]))
glob2loc[pi] =
meshing.AddPoint (mesh3d[pi], pi);
for (int i = 1; i <= mesh3d.GetNOpenElements(); i++)
{
Element2d hel = mesh3d.OpenElement(i);
for (int j = 0; j < hel.GetNP(); j++)
hel[j] = glob2loc[hel[j]];
meshing.AddBoundaryElement (hel);
// meshing.AddBoundaryElement (mesh3d.OpenElement(i));
}
oldne = mesh3d.GetNE();
mp.giveuptol = 15 + 10 * cntsteps;
mp.sloppy = 5;
meshing.GenerateMesh (mesh3d, mp);
for (ElementIndex ei = oldne; ei < mesh3d.GetNE(); ei++)
mesh3d[ei].SetIndex (k);
mesh3d.CalcSurfacesOfNode();
mesh3d.FindOpenElements(k);
// teterrpow = 2;
if (mesh3d.GetNOpenElements() != 0)
{
meshed = 0;
PrintMessage (5, mesh3d.GetNOpenElements(), " open faces found");
MeshOptimize3d optmesh(mp);
const char * optstr = "mcmstmcmstmcmstmcm";
for (size_t j = 1; j <= strlen(optstr); j++)
{
mesh3d.CalcSurfacesOfNode();
mesh3d.FreeOpenElementsEnvironment(2);
mesh3d.CalcSurfacesOfNode();
switch (optstr[j-1])
{
case 'c': optmesh.CombineImprove(mesh3d, OPT_REST); break;
case 'd': optmesh.SplitImprove(mesh3d, OPT_REST); break;
case 's': optmesh.SwapImprove(mesh3d, OPT_REST); break;
case 't': optmesh.SwapImprove2(mesh3d, OPT_REST); break;
case 'm': mesh3d.ImproveMesh(mp, OPT_REST); break;
}
}
mesh3d.FindOpenElements(k);
PrintMessage (3, "Call remove problem");
RemoveProblem (mesh3d, k);
mesh3d.FindOpenElements(k);
}
else
{
meshed = 1;
PrintMessage (1, "Success !");
}
}
while (!meshed);
PrintMessage (1, mesh3d.GetNP(), " points, ",
mesh3d.GetNE(), " elements");
}
mp.maxh = globmaxh;
MeshQuality3d (mesh3d);
return MESHING3_OK;
}
void Refinement ::
ValidateRefinedMesh (Mesh & mesh,
Array<INDEX_2> & parents)
{
// int i, j, k;
// homotopy method
int ne = mesh.GetNE();
int cnttrials = 100;
int wrongels = 0;
for (int i = 1; i <= ne; i++)
if (mesh.VolumeElement(i).CalcJacobianBadness (mesh.Points()) > 1e10)
{
wrongels++;
mesh.VolumeElement(i).flags.badel = 1;
}
else
mesh.VolumeElement(i).flags.badel = 0;
double facok = 0;
double factry;
BitArray illegalels(ne);
illegalels.Clear();
if (wrongels)
{
cout << "WARNING: " << wrongels << " illegal element(s) found" << endl;
int np = mesh.GetNP();
Array<Point<3> > should(np);
Array<Point<3> > can(np);
for (int i = 1; i <= np; i++)
{
should.Elem(i) = can.Elem(i) = mesh.Point(i);
}
for (int i = 1; i <= parents.Size(); i++)
{
if (parents.Get(i).I1())
can.Elem(i) = Center (can.Elem(parents.Get(i).I1()),
can.Elem(parents.Get(i).I2()));
}
BitArray boundp(np);
boundp.Clear();
for (int i = 1; i <= mesh.GetNSE(); i++)
{
const Element2d & sel = mesh.SurfaceElement(i);
for (int j = 1; j <= sel.GetNP(); j++)
boundp.Set(sel.PNum(j));
}
(*testout) << "bpoints:" << endl;
for (int i = 1; i <= np; i++)
if (boundp.Test(i))
(*testout) << i << endl;
double lam = 0.5;
while (facok < 1-1e-8 && cnttrials > 0)
{
lam *= 4;
if (lam > 2) lam = 2;
do
{
// cout << "trials: " << cnttrials << endl;
lam *= 0.5;
cnttrials--;
cout << "lam = " << lam << endl;
factry = lam + (1-lam) * facok;
cout << "trying: " << factry << endl;
for (int i = 1; i <= np; i++)
if (boundp.Test(i))
{
for (int j = 0; j < 3; j++)
mesh.Point(i)(j) =
lam * should.Get(i)(j) +
(1-lam) * can.Get(i)(j);
}
else
mesh.Point(i) = Point<3> (can.Get(i));
// (*testout) << "bad els: " << endl;
wrongels = 0;
for (int i = 1; i <= ne; i++)
{
if (!illegalels.Test(i) &&
mesh.VolumeElement(i).
CalcJacobianBadness(mesh.Points()) > 1e10)
{
wrongels++;
Element & el = mesh.VolumeElement(i);
el.flags.badel = 1;
if (lam < 1e-4)
illegalels.Set(i);
/*
(*testout) << i << ": ";
for (j = 1; j <= el.GetNP(); j++)
(*testout) << el.PNum(j) << " ";
(*testout) << endl;
*/
}
else
mesh.VolumeElement(i).flags.badel = 0;
}
cout << "wrongels = " << wrongels << endl;
}
while (wrongels && cnttrials > 0);
mesh.CalcSurfacesOfNode();
MeshingParameters dummymp;
mesh.ImproveMeshJacobian (dummymp, OPT_WORSTCASE);
facok = factry;
for (int i = 1; i <= np; i++)
can.Elem(i) = mesh.Point(i);
}
}
for (int i = 1; i <= ne; i++)
{
if (illegalels.Test(i))
{
cout << "illegal element: " << i << endl;
mesh.VolumeElement(i).flags.badel = 1;
}
else
mesh.VolumeElement(i).flags.badel = 0;
}
/*
if (cnttrials <= 0)
{
cerr << "ERROR: Sorry, illegal elements:" << endl;
}
*/
}
