First, thank you Bruno for the tips and please excuse my developing understanding of C++, CGAL, and YADE source.
>If your idea was correct the current code would not work at all, you >need to include in the picture the fact that this same code actually >works for us without problem. I should mention that the attached mwe.py is my attempt at creating the most basic DFNflow model possible by avoiding any special cases that may extend beyond the original functionality. Since you mention that this code does work fine for you guys, it is possible that my input script contains an error. Bug update: >Could you output more data on the crashing facet? Which are the vertices >connected to it, etc. It may ring a bell about which special case need >to be handled differently. The crash occurs no matter which facet is currently being used to declare cell1 and cell2. Based on my debugging, the crash occurs even when the facet maps to nonfictitious cells. The problem occurs in the declaration of cell1 (which should simply grab the cellhandle of the facet using "facet->first"). Instead, it is declaring some junky values within cell1 despite facet1 pointing to a perfectly normal cell. Once the junky cellhandle is passed to CGAL, it throws the error. So I've managed to fix the problem by dereferencing the circulator to obtain the facet, and then grabbing the cellhandle from the facet directly [1]. It appears to do exactly what the original code is doing, but in a more verbose manner. However, cell1 is no longer filled with junk values and I am no longer getting a segmentation fault. Obviously, this is strange since the original code was already working for other people, but this fix suggests that it should not be. Since I've already associated this bug with the compiler optimization level, it might be possible that my compiler is optimizing the code differently than it was intended to when this was written in 2014. Also, I will continue to investigate my input script for possible mistakes. [1] void DFNFlowEngine::trickPermeability(RTriangulation::Facet_circulator& facet, Real aperture, Real residualAperture) { const RTriangulation::Facet& currentFacet = *facet; // seems verbose but facet->first was declaring a junk cell and crashing program const RTriangulation& Tri = solver->T[solver->currentTes].Triangulation(); const CellHandle& cell1 = currentFacet.first; const CellHandle& cell2 = currentFacet.first->neighbor(currentFacet.second); if ( Tri.is_infinite(cell1) || Tri.is_infinite(cell2)) cerr<<"Infinite cell found in trickPermeability, should be handled somehow, maybe"<<endl; cell1->info().kNorm()[currentFacet.second]=cell2->info().kNorm()[Tri.mirror_index(cell1, currentFacet.second)] = pow((aperture+residualAperture),3)/ -- You received this bug notification because you are a member of Yade developers, which is subscribed to Yade. https://bugs.launchpad.net/bugs/1666339 Title: DFNflow crashes for compiled trunk but not non-optimized debug compiled trunk Status in Yade: New Bug description: Distro: Xenial 16.04LTS Yade Version: yade-2017-0207.git-11c276f Compilation: default compilation with debug flags and '#define DFNFLOW' uncommented in DFNFlow.cpp Summary: DFNFlowEngine crashes for compiled yade-2017-0207.git-11c276f sources. The segmentation fault also occurs for a debug compiled version and yields the attached core dump. Interestingly, the DFNFlowEngine does not crash for a non-optimized debug compilation of the same sources. Description of failure: According to the core dump, the failure can be traced back to DFNFlow.cpp:176, where it is checking if the cell is inifinite (although I have also had it fail at the permeability assignment directly below line 176 for a modified version of DFNflow.cpp). DFNFlow.cpp: 176: if ( Tri.is_infinite(cell1) || Tri.is_infinite(cell2)) cerr<<"Infinite cell found in trickPermeability, should be handled somehow, maybe"<<endl; 177: cell1->info().kNorm()[facet->second]=cell2->info().kNorm()[Tri.mirror_index(cell1, facet- >second)] = pow((aperture+residualAperture),3)/(12*viscosity); I am unsure why this line is causing a crash in the optimized-debug compiled code, but not the non-optimized-debug compiled code. My optimized-debug compiled executable is simply built with the flag -DDEBUG=ON. My non-optimized debug compiled code uses an edited CMakeLists.txt to avoid optimization: IF(CMAKE_COMPILER_IS_GNUCC) SET(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -O0") SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -O0") ENDIF(CMAKE_COMPILER_IS_GNUCC) The attached zip contains: mwe.py // input script liteSpecimen2mm.spheres // packing file jointSurf.stl // stl for smooth joint coreDump2.txt // core dump after executing mwe.py with optimized debug compiled yade Any assistance with this bug is greatly appreciated. To manage notifications about this bug go to: https://bugs.launchpad.net/yade/+bug/1666339/+subscriptions _______________________________________________ Mailing list: https://launchpad.net/~yade-dev Post to : yade-dev@lists.launchpad.net Unsubscribe : https://launchpad.net/~yade-dev More help : https://help.launchpad.net/ListHelp