yade-dev team mailing list archive

[Robert Caulk <1666339@xxxxxxxxxxxxxxxxxx>]

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