int UGFinalizeNoPCLFinalize()
{
EnableMemTracker(false);
ug::GetLogAssistant().flush_error_log();
if (outputProfileStats) {
UG_LOG(std::endl);
// output the profiled data.
PROFILER_UPDATE();
if(GetLogAssistant().is_output_process()) {
UG_LOG("\n");
#ifdef UG_PROFILER
UG_LOG(ug::GetProfileNode(NULL)->call_tree());
#else
PROFILER_OUTPUT();
#endif
}
#ifdef UG_PROFILER
//Shiny::ProfileManager::instance.destroy();
#endif
}
return 0;
}
ribi::trim::TriangleMeshBuilder::TriangleMeshBuilder(
const std::vector<boost::shared_ptr<Cell>>& cells,
const std::string& mesh_filename,
const std::function<ribi::foam::PatchFieldType(const std::string&)> boundary_to_patch_field_type_function
)
: m_cells(cells),
m_faces(SortByBoundary(ExtractFaces(cells))),
m_points(ExtractPoints(cells))
{
#ifndef NDEBUG
Test();
#endif
TRACE_FUNC();
PROFILE_FUNC();
for (const std::string& folder: GetAllFolders())
{
if (!ribi::fileio::IsFolder(folder))
{
ribi::fileio::CreateFolder(folder);
}
assert(ribi::fileio::IsFolder(folder));
}
//Remove cells with less than 8 faces or less than 8 faces with an owner
m_cells.erase(
std::remove_if(m_cells.begin(),m_cells.end(),
[](const boost::shared_ptr<Cell> cell)
{
const std::vector<boost::shared_ptr<Face>> faces { cell->GetFaces() };
assert(faces.size() == 8);
return std::count_if(faces.begin(),faces.end(),
[](const boost::shared_ptr<Face> face)
{
assert(face);
assert(face->GetOwner()); //Test: is this loop needed?
return face->GetOwner();
}
) < 8;
}
),
m_cells.end()
);
m_faces.erase(
std::remove_if(m_faces.begin(),m_faces.end(),
[](const boost::shared_ptr<const Face> face)
{
return !face->GetOwner();
}
),
m_faces.end()
);
//Remove cells with less than 8 faces or less than 8 faces with an owner
m_cells.erase(
std::remove_if(m_cells.begin(),m_cells.end(),
[](const boost::shared_ptr<Cell> cell)
{
const std::vector<boost::shared_ptr<Face>> faces { cell->GetFaces() };
assert(faces.size() == 8);
return std::count_if(faces.begin(),faces.end(),
[](const boost::shared_ptr<Face> face)
{
assert(face);
assert(face->GetOwner()); //Test: is this loop needed?
return face->GetOwner();
}
) < 8;
}
),
m_cells.end()
);
//Set all indices
{
const int n_cells = static_cast<int>(m_cells.size());
for (int i=0; i!=n_cells; ++i)
{
m_cells[i]->SetIndex(i);
}
const int n_faces = static_cast<int>(m_faces.size());
for (int i=0; i!=n_faces; ++i)
{
m_faces[i]->SetIndex(i);
}
const int n_points = static_cast<int>(m_points.size());
for (int i=0; i!=n_points; ++i)
{
m_points[i]->SetIndex(i);
}
}
//Check
#ifndef NDEBUG
{
const int cell_usecount = m_cells.empty() ? 0 : m_cells[0].use_count();
for (const auto& cell: m_cells)
{
assert(cell);
//TRACE(cell_usecount);
//TRACE(cell.use_count());
assert(cell.use_count() == cell_usecount && "Every Cell must have an equal use_count");
//All Cells must have existing indices
assert(cell->GetIndex() >= 0);
assert(cell->GetIndex() < static_cast<int>(m_cells.size()));
//const int face_usecount = cell->GetFaces().empty() ? 0 : cell->GetFaces()[0].use_count();
for (const auto& face: cell->GetFaces())
{
assert(face);
//TRACE(face_usecount);
//TRACE(face.use_count());
//assert(std::abs(face_usecount - face.use_count()) <= 1 && "Face are used once or twice");
//All Cells must exist of Faces with an existing index
assert(face->GetIndex() >= 0);
assert(face->GetIndex() < static_cast<int>(m_faces.size()));
//All Faces must have a Cell that owns them with an existing index
assert(face->GetOwner()->GetIndex() >= 0);
assert(face->GetOwner()->GetIndex() < static_cast<int>(m_cells.size()));
//All Faces must have either no Neighbout or a Neighbour with an existing index
assert(!face->GetNeighbour() || face->GetNeighbour()->GetIndex() >= 0);
assert(!face->GetNeighbour() || face->GetNeighbour()->GetIndex() < static_cast<int>(m_cells.size()));
for (const auto point: face->GetPoints())
{
assert(point);
//All Faces must exists of Points with an existing index
assert(point->GetIndex() >= 0);
assert(point->GetIndex() < static_cast<int>(m_points.size()));
}
}
}
}
#endif
const bool verbose = false;
if (verbose) std::cout << "Writing output...\n";
//Mesh
{
if (verbose) std::cout << "\tGenerating mesh (.ply)\n";
std::ofstream f(mesh_filename.c_str());
f << CreateHeader();
f << CreateNodes();
f << CreateFaces();
}
{
std::ofstream f(ribi::foam::Filenames().GetPoints().Get().c_str());
f << CreateOpenFoamHeader("vectorField","points","constant/polyMesh");
f << CreateOpenFoamNodes();
}
{
std::ofstream fp(ribi::foam::Filenames().GetFaces().Get().c_str());
fp << CreateOpenFoamHeader("faceList","faces","constant/polyMesh");
fp << CreateOpenFoamFaces();
}
{
const int n_cells = static_cast<int>(m_cells.size());
if (verbose) std::cout << "\tGenerating cells (" << n_cells << ")\n";
std::ofstream fo(ribi::foam::Filenames().GetOwner().Get().c_str());
std::ofstream fn(ribi::foam::Filenames().GetNeighbour().Get().c_str());
std::stringstream fs;
fs
<< "nPoints: " << m_points.size()
<< " nCells: " << m_cells.size()
<< " nFaces: " << m_faces.size()
;
fo << CreateOpenFoamHeader(
"labelList",
"owner",
"constant/polyMesh",
fs.str()
);
fn << CreateOpenFoamHeader(
"labelList",
"neighbour",
"constant/polyMesh",
fs.str()
);
const std::pair<std::string,std::string> p { CreateCells() };
const std::string& out_owner { p.first };
const std::string& out_neighbour { p.second};
fo << out_owner;
fn << out_neighbour;
}
{
std::ofstream f(ribi::foam::Filenames().GetBoundary().Get().c_str());
f << CreateBoundary(boundary_to_patch_field_type_function);
}
{
std::ofstream f(ribi::foam::Filenames().GetCase().Get().c_str());
//Need nothing to stream
}
{
//std::ofstream f(ribi::foam::Filenames().GetFvSchemes().Get().c_str());
//f << CreateOpenFoamFvSchemes();
}
{
//std::ofstream f(ribi::foam::Filenames().GetFvSolution().Get().c_str());
//f << CreateOpenFoamFvSolution();
}
{
std::ofstream f(ribi::foam::Filenames().GetVelocityField().Get().c_str());
f << CreateOpenFoamU();
}
{
//std::ofstream f(ribi::foam::Filenames().GetControlDict().Get().c_str());
//f << CreateOpenFoamControlDict();
}
PROFILER_UPDATE();
}
