Merge branch 'master' of https://lemma.codes/Lemma

CMake/SuperBuild.cmake

 else()
     message( STATUS "Eigen WAS NOT FOUND ${eigen_DIR}" )
         ExternalProject_Add(EIGEN
-	    GIT_REPOSITORY "https://github.com/eigenteam/eigen-git-mirror.git"
-	    UPDATE_COMMAND "" 
+	    GIT_REPOSITORY "https://gitlab.com/libeigen/eigen.git"
+        UPDATE_COMMAND "" 
 	    GIT_TAG "3.3.7" #"default"
    	    PREFIX ${CMAKE_CURRENT_BINARY_DIR}/external/eigen
    	    CMAKE_ARGS -DCMAKE_INSTALL_PREFIX:PATH=${CMAKE_INSTALL_PREFIX}
     message( STATUS "YAML-CPP was found ${yaml-cpp_FOUND}" )
 else()
     message( STATUS "YAML-CPP WAS NOT FOUND, BUILDING" )
+
     ExternalProject_Add(YAML_CPP
-        GIT_REPOSITORY  "https://github.com/jbeder/yaml-cpp.git"
-        GIT_TAG "master" # "yaml-cpp-0.6.2", # "master" 
+        GIT_REPOSITORY  "https://github.com/jbeder/yaml-cpp.git" 
+        GIT_TAG  "yaml-cpp-0.6.2"  # "master" 
         UPDATE_COMMAND ""
         PATCH_COMMAND ""
         PREFIX ${CMAKE_CURRENT_BINARY_DIR}/external/yaml-cpp
                    -DCMAKE_TOOLCHAIN_FILE=${CMAKE_TOOLCHAIN_FILE}
                    -DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER} 
                    -DCMAKE_C_COMPILER=${CMAKE_C_COMPILER} 
+                   -DCMAKE_CXX_STANDARD=14
+                   -DCMAKE_CXX_STANDARD_REQUIRED=ON
+                   -DCMAKE_CXX_EXTENSIONS=OFF
     )
 endif()
 

CMakeLists.txt

 #            "Please create a separate binary directory and run CMake there.")
 #    endif()
 
-    find_package (yaml-cpp 0.6         PATHS ${CMAKE_INSTALL_PREFIX}  NO_DEFAULT_PATH) # Serialisation of classes 
-    find_package (Eigen3   3.3         PATHS ${CMAKE_INSTALL_PREFIX}  NO_DEFAULT_PATH) # Matrix/Vector & Math
+    find_package (yaml-cpp 0.6    PATHS ${CMAKE_INSTALL_PREFIX}  NO_DEFAULT_PATH) # Serialisation of classes 
+    find_package (Eigen3   3.3    PATHS ${CMAKE_INSTALL_PREFIX}  NO_DEFAULT_PATH) # Matrix/Vector & Math
 
     if (LEMMA_PYTHON3_BINDINGS)
         find_package(pybind11 PATHS ${CMAKE_INSTALL_PREFIX} NO_DEFAULT_PATH)           # Python 3 bindings
     message ( STATUS "Missing hard dependencies have been found, these will be downloaded any compiled." )
     message ( STATUS "This necessitates a two step build." )
     message ( STATUS "Build these packages first...THEN RERUN CMAKE!" )
-    project (SUPERBUILD NONE)
+    project (SUPERBUILD NONE) 
   	# execute the superbuild (this script will be invoked again without the
-  	# USE_SUPERBUILD option this time)
-  	include (CMake/SuperBuild.cmake)
+  	# USE_SUPERBUILD option this time) 
+    include (CMake/SuperBuild.cmake)
   	return()                      # stop processing this file further
 else()
 	#project (Blah)               # <-- YOUR PROJECT NAME HERE
 			add_definitions(-DHAVE_BOOST_SPECIAL_FUNCTIONS)
 		endif()
 	endif()
-	find_path( HAVE_BOOST_PROGRESS "boost/progress.hpp" ) 
-		if(HAVE_BOOST_PROGRESS)
-		add_definitions(-DHAVE_BOOST_PROGRESS)
-	endif()
 endif()
 
 if (LEMMA_PYTHON3_BINDINGS)
 if (LEMMA_USE_OPENMP)
 
     if(APPLE)
-        if(CMAKE_C_COMPILER_ID MATCHES "Clang")
-            set(OpenMP_C "${CMAKE_C_COMPILER}")
-            set(OpenMP_C_FLAGS "-fopenmp=libomp -Wno-unused-command-line-argument")
-            set(OpenMP_C_LIB_NAMES "libomp" "libgomp" "libiomp5")
-            set(OpenMP_libomp_LIBRARY ${OpenMP_C_LIB_NAMES})
-            set(OpenMP_libgomp_LIBRARY ${OpenMP_C_LIB_NAMES})
-            set(OpenMP_libiomp5_LIBRARY ${OpenMP_C_LIB_NAMES})
-        endif()
+        #if(CMAKE_C_COMPILER_ID MATCHES "Clang")
+        #    set(OpenMP_C "${CMAKE_C_COMPILER}")
+        #    set(OpenMP_C_FLAGS "-fopenmp=libomp -Wno-unused-command-line-argument")
+        #    set(OpenMP_C_LIB_NAMES "libomp" "libgomp" "libiomp5")
+        #    set(OpenMP_libomp_LIBRARY ${OpenMP_C_LIB_NAMES})
+        #    set(OpenMP_libgomp_LIBRARY ${OpenMP_C_LIB_NAMES})
+        #    set(OpenMP_libiomp5_LIBRARY ${OpenMP_C_LIB_NAMES})
+        #endif()
         if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+            find_library( libiomp5 NAMES  libiomp5.dylib PATHS "/anaconda3/lib/" REQUIRED )
             set(OpenMP_CXX "${CMAKE_CXX_COMPILER}")
-            set(OpenMP_CXX_FLAGS "-fopenmp=libomp -Wno-unused-command-line-argument")
-            set(OpenMP_CXX_LIB_NAMES "libomp" "libgomp" "libiomp5")
-            set(OpenMP_libomp_LIBRARY ${OpenMP_CXX_LIB_NAMES})
-            set(OpenMP_libgomp_LIBRARY ${OpenMP_CXX_LIB_NAMES})
-            set(OpenMP_libiomp5_LIBRARY ${OpenMP_CXX_LIB_NAMES})
+            set(OpenMP_CXX_FLAGS "-fopenmp=libiomp5 -Wno-unused-command-line-argument")
+            set(OpenMP_CXX_LIB_NAMES "libiomp5") #"libomp" "libgomp" "libiomp5")
+            #set(OpenMP_libomp_LIBRARY ${OpenMP_CXX_LIB_NAMES})
+            #set(OpenMP_libgomp_LIBRARY ${OpenMP_CXX_LIB_NAMES})
+            set(OpenMP_libiomp5_LIBRARY libiomp5 )# ${OpenMP_CXX_LIB_NAMES})
+            set(OpenMP_LIBRARIES  libiomp5)
+            link_directories("/anaconda3/lib")
+    #        find_package(OpenMP REQUIRED)
     #         set(OpenMP_CXX_FLAGS "-Xpreprocessor -fopenmp -I/usr/local/opt/libomp/include")
     #         " -DOpenMP_CXX_LIB_NAMES=\"omp\" -DOpenMP_omp_LIBRARY=/usr/local/opt/libomp/lib/libomp.dylib ")
     #         set(OpenMP_CXX_LIB_NAMES "omp") # "libgomp" "libiomp5")

Modules/DCIP/CMakeLists.txt

-# Configure EMSchur3D 
-set(DCIP_VERSION_MAJOR "0")
-set(DCIP_VERSION_MINOR "0")
-set(DCIP_VERSION_PATCH "1")
-set(DCIP_VERSION "\"${DCIP_VERSION_MAJOR}.${DCIP_VERSION_MINOR}.${DCIP_VERSION_PATCH}\"")
-set(DCIP_VERSION_NOQUOTES "${DCIP_VERSION_MAJOR}.${DCIP_VERSION_MINOR}.${DCIP_VERSION_PATCH}")
-
 option ( LEMMA_MODULE_DCIP TRUE )
 
-configure_file (
+if (LEMMA_MODULE_DCIP) 
+
+	# Configure DCIP 
+	set(DCIP_VERSION_MAJOR "0")
+	set(DCIP_VERSION_MINOR "0")
+	set(DCIP_VERSION_PATCH "1")
+	set(DCIP_VERSION "\"${DCIP_VERSION_MAJOR}.${DCIP_VERSION_MINOR}.${DCIP_VERSION_PATCH}\"")
+	set(DCIP_VERSION_NOQUOTES "${DCIP_VERSION_MAJOR}.${DCIP_VERSION_MINOR}.${DCIP_VERSION_PATCH}")
+
+
+	configure_file (
 	"${CMAKE_CURRENT_SOURCE_DIR}/config/DCIPConfig.h.in"
 	"${PROJECT_BINARY_DIR}/include/DCIPConfig.h"
 	)
-install ( FILES  ${PROJECT_BINARY_DIR}/include/DCIPConfig.h   DESTINATION ${CMAKE_INSTALL_PREFIX}/include/Lemma/ )
+
+	install ( FILES  ${PROJECT_BINARY_DIR}/include/DCIPConfig.h   DESTINATION ${CMAKE_INSTALL_PREFIX}/include/Lemma/ )
 
 	add_subdirectory("src")
 	add_library( dcip ${DCIPSOURCE} )  
 	#if (LEMMA_BUILD_EXAMPLES)
 	#	add_subdirectory(examples)
 	#endif()
+
+endif()

Modules/FDEM1D/CMakeLists.txt

 
 # Linking
 target_link_libraries(fdem1d "lemmacore")
+target_link_libraries(fdem1d ${YAML_CPP_LIBRARIES}) 
 
 if ( KIHA_EM1D )
 	target_link_libraries(fdem1d "kihaem1d")

Modules/FDEM1D/include/EMEarth1D.h

 #include "QWEKey.h"
 #include "CubicSplineInterpolator.h"
 
-#ifdef HAVE_BOOST_PROGRESS
-#include "boost/progress.hpp"
-#endif
+#include "ProgressBar.h"
 
 namespace Lemma {
 

Modules/FDEM1D/include/FHT.h

     const Eigen::Matrix<Real, Eigen::Dynamic, 3>  FHT<FHTKONG241>::WT;
     template<>
     const Eigen::Matrix<Real, Eigen::Dynamic, 3>  FHT<IRONS>::WT;
+    // Clang wants generic declaration
+    template < HANKELTRANSFORMTYPE Type >
+    const Eigen::Matrix<Real, Eigen::Dynamic, 3>  FHT< Type >::WT;
 #endif
 
     template < HANKELTRANSFORMTYPE Type >

Modules/FDEM1D/python/CMakeLists.txt

 add_library(pyFDEM1D MODULE pyFDEM1D.cpp)
 target_link_libraries(pyFDEM1D PRIVATE pybind11::module lemmacore fdem1d )
 set_target_properties(pyFDEM1D PROPERTIES PREFIX "${PYTHON_MODULE_PREFIX}"
-                                       SUFFIX "${PYTHON_MODULE_EXTENSION}"
-                                                      OUTPUT_NAME "FDEM1D"
+	SUFFIX "${PYTHON_MODULE_EXTENSION}"
+    OUTPUT_NAME "FDEM1D"
+	CXX_STANDARD 14 
+	CXX_STANDARD_REQUIRED ON
 )
 
 install(TARGETS pyFDEM1D

Modules/FDEM1D/src/EMEarth1D.cpp

     EMEarth1D::EMEarth1D( const ctor_key& key ) : LemmaObject( key ),
             Dipole(nullptr), Earth(nullptr), Receivers(nullptr), Antenna(nullptr),
             FieldsToCalculate(BOTH), HankelType(ANDERSON801), icalcinner(0), icalc(0)
-        //#ifdef HAVE_BOOST_PROGRESS
-        //    , disp(0)
-        //#endif
         {
     }
 
 
     void EMEarth1D::CalculateWireAntennaFields(bool progressbar) {
 
-        #ifdef HAVE_BOOST_PROGRESS
-        boost::progress_display *disp;
-        #endif
-
         if (Earth == nullptr) {
             throw NullEarth();
         }
             if ( Antenna->IsHorizontallyPlanar() && ( HankelType == ANDERSON801 || HankelType == FHTKEY201  || HankelType==FHTKEY101 ||
                                                       HankelType == FHTKEY51    || HankelType == FHTKONG61  || HankelType == FHTKONG121 ||
                                                       HankelType == FHTKONG241  || HankelType == IRONS )) {
-                #ifdef HAVE_BOOST_PROGRESS
+                std::unique_ptr<ProgressBar> mdisp;
                 if (progressbar) {
-                    disp = new boost::progress_display( Receivers->GetNumberOfPoints()*Antenna->GetNumberOfFrequencies() );
+                    mdisp = std::make_unique< ProgressBar >( Receivers->GetNumberOfPoints()*Antenna->GetNumberOfFrequencies() );
                 }
-                #endif
+
                 for (int ifreq=0; ifreq<Antenna->GetNumberOfFrequencies();++ifreq) {
                     Real wavef = 2.*PI* Antenna->GetFrequency(ifreq);
                     #ifdef LEMMAUSEOMP
                     #endif
                     for (int irec=0; irec<Receivers->GetNumberOfPoints(); ++irec) {
                         SolveLaggedTxRxPair(irec, Hankel.get(), wavef, ifreq, AntCopy.get());
-                        #ifdef HAVE_BOOST_PROGRESS
-                        if (progressbar) ++(*disp);
-                        #endif
+                        if (progressbar) {
+                            ++ *mdisp;
+                        }
                     }
-                    #pragma omp barrier
                     #ifdef LEMMAUSEOMP
+                    #pragma omp barrier
                     }
                     #endif
                 }
+
+
             } else if (Receivers->GetNumberOfPoints() > Antenna->GetNumberOfFrequencies()) {
 
-                //std::cout << "freq parallel #1" << std::endl;
                 //** Progress display bar for long calculations */
-                #ifdef HAVE_BOOST_PROGRESS
+                std::unique_ptr<ProgressBar> mdisp;
                 if (progressbar) {
-                    disp = new boost::progress_display( Receivers->GetNumberOfPoints()*Antenna->GetNumberOfFrequencies() );
+                    mdisp = std::make_unique< ProgressBar > ( Receivers->GetNumberOfPoints()*Antenna->GetNumberOfFrequencies() );
                 }
-                #endif
+
                 // parallelise across receivers
                 #ifdef LEMMAUSEOMP
                 #pragma omp parallel
                     // thread.
                     auto AntCopy = static_cast<PolygonalWireAntenna*>(Antenna.get())->ClonePA();
                     auto Hankel = HankelTransformFactory::NewSP( HankelType );
-/*
-                    std::shared_ptr<HankelTransform> Hankel;
-                    switch (HankelType) {
-                        case ANDERSON801:
-                            Hankel = FHTAnderson801::NewSP();
-                            break;
-                        case CHAVE:
-                            Hankel = GQChave::NewSP();
-                            break;
-                        case FHTKEY201:
-                            Hankel = FHTKey201::NewSP();
-                            break;
-                        case FHTKEY101:
-                            Hankel = FHTKey101::NewSP();
-                            break;
-                        case FHTKEY51:
-                            Hankel = FHTKey51::NewSP();
-                            break;
-                        case FHTKONG61:
-                            Hankel = FHT<FHTKONG61>::NewSP();
-                            break;
-                        case FHTKONG121:
-                            Hankel = FHT<FHTKONG121>::NewSP();
-                            break;
-                        case QWEKEY:
-                            std::cout << "QWEKEY" << std::endl;
-                            Hankel = QWEKey::NewSP();
-                            break;
-                        default:
-                            std::cerr << "Hankel transform cannot be created\n";
-                            exit(EXIT_FAILURE);
-                    }
-*/
-                    //for (int irec=tid; irec<Receivers->GetNumberOfPoints(); irec+=nthreads) {
+
                     #ifdef LEMMAUSEOMP
                     #pragma omp for schedule(static, 1) //nowait
                     #endif
                         //std::cout << "Normal Path\n";
                         //std::cout << Receivers->GetHfield(0, irec) << std::endl;
                         //if (irec == 1) exit(0);
-                        #ifdef HAVE_BOOST_PROGRESS
-                        if (progressbar) ++(*disp);
-                        #endif
+                        if (progressbar) {
+                            ++ *mdisp;
+                        }
                     } // receiver loop
                 } // OMP_PARALLEL BLOCK
             } else if (Antenna->GetNumberOfFrequencies() > 8) {
                         #endif
                         { // OpenMP Parallel Block
 
-                            std::shared_ptr<HankelTransform> Hankel;
-                            switch (HankelType) {
-                                case ANDERSON801:
-                                    Hankel = FHTAnderson801::NewSP();
-                                    break;
-                                case CHAVE:
-                                    Hankel = GQChave::NewSP();
-                                    break;
-                                case FHTKEY201:
-                                    Hankel = FHTKey201::NewSP();
-                                    break;
-                                case FHTKEY101:
-                                    Hankel = FHTKey101::NewSP();
-                                    break;
-                                case FHTKEY51:
-                                    Hankel = FHTKey51::NewSP();
-                                    break;
-                                case QWEKEY:
-                                    Hankel = QWEKey::NewSP();
-                                    break;
-                                default:
-                                    std::cerr << "Hankel transform cannot be created\n";
-                                    exit(EXIT_FAILURE);
-                            }
+                            auto Hankel = HankelTransformFactory::NewSP( HankelType );
                             #ifdef LEMMAUSEOMP
                             #pragma omp for schedule(static, 1)
                             #endif
                             } // frequency loop
                         } // OMP_PARALLEL BLOCK
                     } // mask loop
-                    #ifdef HAVE_BOOST_PROGRESS
                     //if (Receivers->GetNumberOfPoints() > 100) {
-                    //    ++ disp;
+                    //    ++ mdisp;
                     //}
-                    #endif
                 } // receiver loop
-                //std::cout << "End freq parallel " << std::endl;
             } // Frequency Parallel
               else {
-                //std::cout << "parallel across #3 " << std::endl;
+                //std::cout << "parallel across transmitter dipoles " << std::endl;
                 for (int irec=0; irec<Receivers->GetNumberOfPoints(); ++irec) {
                     if (!Receivers->GetMask(irec)) {
-
                         static_cast<PolygonalWireAntenna*>(Antenna.get())->ApproximateWithElectricDipoles(Receivers->GetLocation(irec));
 //                         std::cout << "Not Masked " << std::endl;
 //                         std::cout << "n Freqs " << Antenna->GetNumberOfFrequencies() << std::endl;
 //                             std::cout << "NO DIPOLES!!!!!!!!!!!!!!!!!!!!!!!!!!\n";
 // //                            std::cout << "rec location " << Receivers->GetLocation(irec) << std::endl;
 // //                        }
-
                         #ifdef LEMMAUSEOMP
                         #pragma omp parallel
                         #endif
                         { // OpenMP Parallel Block
-                            std::shared_ptr<HankelTransform> Hankel;
-                            switch (HankelType) {
-                                case ANDERSON801:
-                                    Hankel = FHTAnderson801::NewSP();
-                                    break;
-                                case CHAVE:
-                                    Hankel = GQChave::NewSP();
-                                    break;
-                                case FHTKEY201:
-                                    Hankel = FHTKey201::NewSP();
-                                    break;
-                                case FHTKEY101:
-                                    Hankel = FHTKey101::NewSP();
-                                    break;
-                                case FHTKEY51:
-                                    Hankel = FHTKey51::NewSP();
-                                    break;
-                                case QWEKEY:
-                                    Hankel = QWEKey::NewSP();
-                                    break;
-                                default:
-                                    std::cerr << "Hankel transform cannot be created\n";
-                                    exit(EXIT_FAILURE);
-                            }
+                            auto Hankel = HankelTransformFactory::NewSP( HankelType );
                             for (int ifreq=0; ifreq<Antenna->GetNumberOfFrequencies(); ++ifreq) {
                                 #ifdef LEMMAUSEOMP
                                 #pragma omp for schedule(static, 1)
                             } // frequency loop
                         } // OMP_PARALLEL BLOCK
                     } // mask loop
-                    #ifdef HAVE_BOOST_PROGRESS
                     //if (Receivers->GetNumberOfPoints() > 100) {
                     //    ++ disp;
                     //}
-                    #endif
                 } // receiver loop
            } // Polygonal parallel logic
         } else {
             this->Dipole = nullptr;
         }
 
-        #ifdef HAVE_BOOST_PROGRESS
-        if (progressbar) {
-            delete disp;
-        }
-        #endif
     }
 
     #ifdef KIHALEE_EM1D

Modules/FDEM1D/src/PolygonalWireAntenna.cpp

 		    std::vector< std::shared_ptr<DipoleSource> >       xDipoles;
 
 		    // loop over all segments
-		    for (int iseg=0; iseg<NumberOfPoints-1; ++iseg) {
+		    int iseg;
+            for (iseg=0; iseg<NumberOfPoints-1; ++iseg) {
 			    InterpolateLineSegment(Points.col(iseg), Points.col(iseg+1), rp, xDipoles);
 		    }
+
+            // Check to see if the loop is closed, if not, assume its grounded on ends,
+            if ( (Points.col(0)-Points.col(iseg)).norm() > 1e-3 ) {
+                xDipoles[0]->SetType(GROUNDEDELECTRICDIPOLE);
+                xDipoles.back()->SetType(GROUNDEDELECTRICDIPOLE);
+            }
+
             Dipoles = std::move(xDipoles);
             rRepeat = rp;
 

Modules/LemmaCore/CMakeLists.txt

 target_link_libraries (lemmacore Eigen3::Eigen)
 #target_link_libraries (lemmacore CxxTest)
 target_link_libraries (lemmacore ${YAML_CPP_LIBRARIES}) 
+target_link_libraries (lemmacore ${YAML_CPP_LIBRARY}) 
 
 # Linking
 if ( LEMMA_VTK6_SUPPORT OR LEMMA_VTK7_SUPPORT OR LEMMA_VTK8_SUPPORT ) 

Modules/LemmaCore/include/ProgressBar.h

+#ifndef PROGRESS_BAR_H
+#define PROGRESS_BAR_H
+
+#include <string>
+
+/**
+ * RAII implementation of a progress bar.
+ * available from https://stackoverflow.com/questions/46717885/make-boostprogress-display-work-when-more-information-is-being-printed-to-the
+ */
+class ProgressBar
+{
+public:
+    /**
+     * Constructor.
+     * It takes two values: the expected number of iterations whose progress we
+     * want to monitor and an initial message to be displayed on top of the bar
+     * (which can be updated with updateLastPrintedMessage()).
+     */
+    ProgressBar(
+            uint32_t expectedIterations, const std::string& initialMessage="");
+
+    /**
+     * Destructor to guarantee RAII.
+     */
+    ~ProgressBar();
+
+    // Make the object non-copyable
+    ProgressBar(const ProgressBar& o) = delete;
+    ProgressBar& operator=(const ProgressBar& o) = delete;
+
+    /**
+     * Must be invoked when the progress bar is no longer needed to restore the
+     * position of the cursor to the end of the output.
+     * It is automatically invoked when the object is destroyed.
+     */
+    void endProgressBar();
+
+    /**
+     * Prints a new message under the last printed message, without overwriting
+     * it. This moves the progress bar down to be placed under the newly
+     * written message.
+     */
+    void printNewMessage(const std::string& message);
+
+    /**
+     * Prints a message while the progress bar is on the screen on top on the
+     * last printed message. Since the cursor is right at the beginning of the
+     * progress bar, it moves the cursor up by one line before printing, and
+     * then returns it to its original position.
+     */
+    void updateLastPrintedMessage(const std::string& message);
+
+    /**
+     * Overloaded prefix operator, used to indicate that the has been a new
+     * iteration.
+     */
+    void operator++();
+
+private:
+    unsigned int mTotalIterations;
+    unsigned int mNumberOfTicks;
+    bool mEnded;
+    size_t mLengthOfLastPrintedMessage;
+};
+
+#endif /* PROGRESS_BAR_H */
+

Modules/LemmaCore/src/CMakeLists.txt

 set (SOURCE 
 	${SOURCE}
+	${CMAKE_CURRENT_SOURCE_DIR}/ProgressBar.cpp                # external to Lemma
 	${CMAKE_CURRENT_SOURCE_DIR}/helper.cpp
 	${CMAKE_CURRENT_SOURCE_DIR}/LemmaObject.cpp
 	${CMAKE_CURRENT_SOURCE_DIR}/ASCIIParser.cpp                # key 

Modules/LemmaCore/src/ProgressBar.cpp

+#include "ProgressBar.h"
+#include <iostream>
+#include <iomanip>
+#include <sstream>
+
+#define LENGTH_OF_PROGRESS_BAR 55
+#define PERCENTAGE_BIN_SIZE (100.0/LENGTH_OF_PROGRESS_BAR)
+
+namespace
+{
+    std::string generateProgressBar(unsigned int percentage)
+    {
+        const int progress = static_cast<int>(percentage/PERCENTAGE_BIN_SIZE);
+        std::ostringstream ss;
+        ss << " " << std::setw(3) << std::right << percentage << "% ";
+        std::string bar("[" + std::string(LENGTH_OF_PROGRESS_BAR-2, ' ') + "]");
+
+        unsigned int numberOfSymbols = std::min(
+                std::max(0, progress - 1),
+                LENGTH_OF_PROGRESS_BAR - 2);
+
+        bar.replace(1, numberOfSymbols, std::string(numberOfSymbols, '|'));
+
+        ss << bar;
+        return ss.str();
+    }
+}
+
+ProgressBar::ProgressBar(
+            uint32_t expectedIterations, const std::string& initialMessage)
+    : mTotalIterations(expectedIterations),
+      mNumberOfTicks(0),
+      mEnded(false)
+{
+    std::cout << initialMessage << "\n";
+    mLengthOfLastPrintedMessage = initialMessage.size();
+    std::cout << generateProgressBar(0) << "\r" << std::flush;
+}
+
+ProgressBar::~ProgressBar()
+{
+    endProgressBar();
+}
+
+void ProgressBar::operator++()
+{
+
+    if (mEnded)
+    {
+        throw std::runtime_error(
+                "Attempted to use progress bar after having terminated it");
+    }
+
+    mNumberOfTicks = std::min(mTotalIterations, mNumberOfTicks+1);
+    const unsigned int percentage = static_cast<unsigned int>(
+            mNumberOfTicks*100.0/mTotalIterations);
+
+    #ifdef LEMMAUSEOMP
+    #pragma omp critical
+    #endif
+    std::cout << generateProgressBar(percentage) << "\r" << std::flush;
+
+}
+
+void ProgressBar::printNewMessage(const std::string& message)
+{
+    if (mEnded)
+    {
+        throw std::runtime_error(
+                "Attempted to use progress bar after having terminated it");
+    }
+
+    std::cout << "\r"
+        << std::left
+        << std::setw(LENGTH_OF_PROGRESS_BAR + 6)
+        << message << "\n";
+    mLengthOfLastPrintedMessage = message.size();
+    const unsigned int percentage = static_cast<unsigned int>(
+            mNumberOfTicks*100.0/mTotalIterations);
+
+    std::cout << generateProgressBar(percentage) << "\r" << std::flush;
+
+}
+
+void ProgressBar::updateLastPrintedMessage(const std::string& message)
+{
+    if (mEnded)
+    {
+        throw std::runtime_error(
+                "Attempted to use progress bar after having terminated it");
+    }
+
+    std::cout << "\r\033[F"
+        << std::left
+        << std::setw(mLengthOfLastPrintedMessage)
+        << message << "\n";
+    mLengthOfLastPrintedMessage = message.size();
+}
+
+void ProgressBar::endProgressBar()
+{
+    if (!mEnded)
+    {
+        std::cout << std::string(2, '\n');
+    }
+    mEnded = true;
+}
+

python/publish.sh

 rm -rf build dist clean pyLemma.egg.info
 python setup.py build
 python setup.py bdist_wheel
-auditwheel repair ./dist/pyLemma*.whl -w ./clean
-twine upload clean/*
+#auditwheel repair ./dist/pyLemma*.whl -w ./clean
+#twine upload build/* #clean/*
 
 #rm -rf dist
 #python setup.py build

python/setup.py

 from setuptools.dist import Distribution
 import sys
 
-if sys.version_info < (3,0):
-  sys.exit('Sorry, Python < 3.0 is not supported')
+if sys.version_info < (3,6):
+  sys.exit('Sorry, Python < 3.6 is not supported')
 
 class BinaryDistribution(Distribution):
     """Distribution which always forces a binary package with platform name"""
 
 setup(
   name             = 'pyLemma',
-  version          = '0.0.11', 
+  version          = '0.0.13', 
   author           = 'Trevor Irons and others',
   author_email     = 'Trevor.Irons@lemmasoftware.org',
   description      = 'A short description of the app/lib',