netgen/libsrc/meshing/basegeom.cpp

143 lines
3.5 KiB
C++
Raw Normal View History

2010-03-23 17:52:07 +05:00
#include <mystdlib.h>
#include "meshing.hpp"
namespace netgen
{
2013-02-06 18:55:20 +06:00
DLL_HEADER GeometryRegisterArray geometryregister;
2019-07-09 13:39:16 +05:00
//DLL_HEADER NgArray<GeometryRegister*> geometryregister;
2011-01-11 01:18:01 +05:00
GeometryRegister :: ~GeometryRegister()
{ ; }
void NetgenGeometry :: OptimizeSurface(Mesh& mesh, const MeshingParameters& mparam)
{
const auto savetask = multithread.task;
multithread.task = "Optimizing surface";
static Timer timer_opt2d("Optimization 2D");
RegionTimer reg(timer_opt2d);
auto meshopt = GetMeshOptimizer();
for(auto i : Range(mparam.optsteps2d))
{
PrintMessage(2, "Optimization step ", i);
for(auto optstep : mparam.optimize2d)
{
switch(optstep)
{
case 's':
meshopt->EdgeSwapping(mesh, 0);
break;
case 'S':
meshopt->EdgeSwapping(mesh, 1);
break;
case 'm':
meshopt->ImproveMesh(mesh, mparam);
break;
case 'c':
meshopt->CombineImprove (mesh);
break;
}
}
}
mesh.CalcSurfacesOfNode();
mesh.Compress();
multithread.task = savetask;
}
shared_ptr<NetgenGeometry> GeometryRegisterArray :: LoadFromMeshFile (istream & ist) const
{
for (int i = 0; i < Size(); i++)
{
NetgenGeometry * hgeom = (*this)[i]->LoadFromMeshFile (ist);
if (hgeom)
return shared_ptr<NetgenGeometry>(hgeom);
}
return nullptr;
}
2011-01-11 01:18:01 +05:00
2010-03-23 17:52:07 +05:00
int NetgenGeometry :: GenerateMesh (shared_ptr<Mesh> & mesh, MeshingParameters & mparam)
2010-03-23 17:52:07 +05:00
{
2019-10-02 20:20:13 +05:00
multithread.percent = 0;
2010-03-23 17:52:07 +05:00
2019-10-02 20:20:13 +05:00
if(mparam.perfstepsstart <= MESHCONST_ANALYSE)
2010-03-23 17:52:07 +05:00
{
2019-10-02 20:20:13 +05:00
if(!mesh)
mesh = make_shared<Mesh>();
mesh->geomtype = GetGeomType();
Analyse(*mesh, mparam);
}
2010-03-23 17:52:07 +05:00
2019-10-02 20:20:13 +05:00
if(multithread.terminate || mparam.perfstepsend <= MESHCONST_ANALYSE)
return 0;
if(mparam.perfstepsstart <= MESHCONST_MESHEDGES)
FindEdges(*mesh, mparam);
if(multithread.terminate || mparam.perfstepsend <= MESHCONST_MESHEDGES)
return 0;
if (mparam.perfstepsstart <= MESHCONST_MESHSURFACE)
{
MeshSurface(*mesh, mparam);
mesh->CalcSurfacesOfNode();
2010-03-23 17:52:07 +05:00
}
2019-10-02 20:20:13 +05:00
if (multithread.terminate || mparam.perfstepsend <= MESHCONST_MESHSURFACE)
return 0;
if (mparam.perfstepsstart <= MESHCONST_OPTSURFACE)
OptimizeSurface(*mesh, mparam);
if (multithread.terminate || mparam.perfstepsend <= MESHCONST_OPTSURFACE)
return 0;
2010-03-23 17:52:07 +05:00
2019-10-02 20:20:13 +05:00
if(mparam.perfstepsstart <= MESHCONST_MESHVOLUME)
{
multithread.task = "Volume meshing";
MESHING3_RESULT res = MeshVolume (mparam, *mesh);
if (res != MESHING3_OK) return 1;
if (multithread.terminate) return 0;
RemoveIllegalElements (*mesh);
if (multithread.terminate) return 0;
MeshQuality3d (*mesh);
}
if (multithread.terminate || mparam.perfstepsend <= MESHCONST_MESHVOLUME)
2010-03-23 17:52:07 +05:00
return 0;
2019-10-02 20:20:13 +05:00
2010-03-23 17:52:07 +05:00
if (mparam.perfstepsstart <= MESHCONST_OPTVOLUME)
2010-03-23 17:52:07 +05:00
{
multithread.task = "Volume optimization";
OptimizeVolume (mparam, *mesh);
if (multithread.terminate) return 0;
}
2019-10-02 20:20:13 +05:00
FinalizeMesh(*mesh);
2010-03-23 17:52:07 +05:00
return 0;
2019-10-02 20:20:13 +05:00
}
2010-03-23 17:52:07 +05:00
const Refinement & NetgenGeometry :: GetRefinement () const
{
return *new Refinement;;
}
2011-01-11 01:18:01 +05:00
void NetgenGeometry :: Save (string filename) const
{
throw NgException("Cannot save geometry - no geometry available");
}
2018-12-14 16:01:58 +05:00
static RegisterClassForArchive<NetgenGeometry> regnggeo;
2010-03-23 17:52:07 +05:00
}