Edits to fix Chave when using GCC 8.

CMakeLists.txt

         set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fopenmp")
         set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fopenmp")
         set (CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -fopenmp")
-        add_definitions(-DLEMMAUSEOMP)
+        add_definitions(-DLEMMAUSEOMP) # -DEIGEN_DONT_VECTORIZE )
     else()
         find_package(OpenMP REQUIRED)
         set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${OpenMP_C_FLAGS}")
         set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${OpenMP_CXX_FLAGS}")
         set (CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${OpenMP_EXE_LINKER_FLAGS}")
-        add_definitions(-DLEMMAUSEOMP)
+        add_definitions(-DLEMMAUSEOMP) # -DEIGEN_DONT_VECTORIZE)
     endif()
 endif()
 

Modules/DCIP/CMakeLists.txt

 	"${CMAKE_CURRENT_SOURCE_DIR}/config/DCIPConfig.h.in"
 	"${PROJECT_BINARY_DIR}/include/DCIPConfig.h"
 	)
-install ( FILES  ${PROJECT_BINARY_DIR}/include/EMSchur3DConfig.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} )  

Modules/FDEM1D/include/GQChave.h

 	// =======================================================================
 	class GQChave : public HankelTransform {
 
+        EIGEN_MAKE_ALIGNED_OPERATOR_NEW
+
 		friend std::ostream &operator<<(std::ostream &stream, const GQChave &ob);
 		public:
 
  			void Bestrn( Real &BESR, Real &BESI, const int &iorder,
  					const int &NG, const Real &R,
  					const Real &RERR, const Real &AERR, const int &npcs,
- 					VectorXi &XSUM, int &NSUM, int &NEW,
+ 					const VectorXi& XSUM, int &NSUM, int &NEW,
  					int &IERR, int &NCNTRL, const Real &AORB,
 					KernelEM1DBase* Kernel);
 
 			/// CFCOR,CFCOI ARE REAL AND IMAGINARY VECTORS OF CONTINUED FRACTION
 			/// COEFFICIENTS
 			void CF(        Real& RESR, Real &RESI,
-							Eigen::Matrix<Real, 100, 1> &CFCOR,
-							Eigen::Matrix<Real, 100, 1> &CFCOI,
+							const VectorXr& CFCOR,
+							const VectorXr& CFCOI,
 							const int &N);
 
 
 			Eigen::Matrix<Real, Eigen::Dynamic, Eigen::Dynamic>  kern;
 
 			// Was Besval COMMON block
+            /*
 			Eigen::Matrix<Real, 100, 1> Xr;
 			Eigen::Matrix<Real, 100, 1> Xi;
 			Eigen::Matrix<Real, 100, 1> Dr;
 			Eigen::Matrix<Real, 100, 1> Si;
 			Eigen::Matrix<Real, 100, 1> Cfcor;
 			Eigen::Matrix<Real, 100, 1> Cfcoi;
+			*/
+
 
 		private:
 
+            Eigen::Matrix<Real, Eigen::Dynamic, 1> Xr;
+			Eigen::Matrix<Real, Eigen::Dynamic, 1> Xi;
+			Eigen::Matrix<Real, Eigen::Dynamic, 1> Dr;
+			Eigen::Matrix<Real, Eigen::Dynamic, 1> Di;
+			Eigen::Matrix<Real, Eigen::Dynamic, 1> Sr;
+			Eigen::Matrix<Real, Eigen::Dynamic, 1> Si;
+			Eigen::Matrix<Real, Eigen::Dynamic, 1> Cfcor;
+			Eigen::Matrix<Real, Eigen::Dynamic, 1> Cfcoi;
+
             /** ASCII string representation of the class name */
-            static constexpr auto CName = "FHTKey51";
+            static constexpr auto CName = "GQChave";
 
 	}; // -----  end of class  GQChave  -----
 

Modules/FDEM1D/include/KernelEM1DReflSpec.h

 
             // ====================  INQUIRY       =======================
 
-            virtual std::string GetName() {
+            virtual std::string GetName() const {
                 return CName;
             }
 

Modules/FDEM1D/src/DipoleSource.cpp

         switch (coordinate) {
             case (0):
                 return this->Location.x();
-                break;
+                //break; // implicit
             case (1):
                 return this->Location.y();
-                break;
+                //break; // implicit
             case (2):
                 return this->Location.z();
-                break;
+                //break; // implicit
             default:
                 throw  NonValidLocationCoordinate( );
         }

Modules/FDEM1D/src/GQChave.cpp

     GQChave::GQChave( const ctor_key& key ) : HankelTransform( key ) {
         //karg.resize(255, 100);
         //kern.resize(510, 100);
+        Xr.resize(100);
+        Xi.resize(100);
+        Dr.resize(100);
+        Di.resize(100);
+        Sr.resize(100);
+        Si.resize(100);
+        Cfcor.resize(100);
+        Cfcoi.resize(100);
     }
 
     GQChave::GQChave( const YAML::Node& node, const ctor_key& key ) : HankelTransform(node, key) {
         //this->karg.setZero();
         //this->kern.setZero();
 
+        //std::cout << "calling Besautn" << std::endl;
+
         Besautn(Besr, Besi, itype, nl, nu, rho, rerr, aerr, npcs, inew, wavef, Kernel);
 
         return Complex(Besr, Besi);
         int nsum(0);
 
         // Check for Rtud
+        //std::cout << "calling Bestrn" << std::endl;
         Bestrn(besr_1, besi_1, besselOrder, lowerGaussLimit, rho,
                         .1*relativeError, .1*absError,
                         numPieces, xsum, nsum, nw, ierr, ncntrl, aorb, Kernel);
     /////////////////////////////////////////////////////////////
     void GQChave::
         Bestrn(Real &BESR, Real &BESI, const int &IORDER,
-            const int &NG, const Real &rho,
-            const Real &RERR, const Real &AERR, const int &NPCS,
-            VectorXi &XSUM, int &NSUM, int &NEW,
-            int &IERR, int &NCNTRL, const Real &AORB, KernelEM1DBase* Kernel) {
-
-
+            const int& NG, const Real& rho,
+            const Real& RERR, const Real& AERR, const int& NPCS,
+            const VectorXi& XSUM, int& NSUM, int& NEW,
+            int& IERR, int& NCNTRL, const Real& AORB, KernelEM1DBase* Kernel) {
+
+        //std::cout << "Bestrn setZero " << NEW << std::endl;
+        //Xr.array() = 0.;
+        //Xi.array() = 0.;
         Xr.setZero();
         Xi.setZero();
         Dr.setZero();
         Cfcoi.setZero();
         Dr.setZero();
         Di.setZero();
+        //std::cout << "Bestrn wat " << NEW << std::endl;
 
         Dr(0) = (Real)(-1);
 
                 ++NPB;
             }
         }
+        //std::cout << "Bestrn NEW " << NEW << std::endl;
 
         // ENTRY POINT FOR PADE SUMMATION OF PARTIAL INTEGRANDS
         Real LASTR=0.e0;
 
     /////////////////////////////////////////////////////////////
     void GQChave::CF(Real& RESR, Real &RESI,
-                    Eigen::Matrix<Real, 100, 1> &CFCOR,
-                    Eigen::Matrix<Real, 100, 1> &CFCOI,
+                    const VectorXr& CFCOR,
+                    const VectorXr& CFCOI,
                     const int &N) {
 
         ////////////////////////////////////////////////
 
         Real BETA(0);
         switch (besselOrder) {
-
             case 0:
                 BETA=(nzero-.25e0)*PI;
                 return BETA-ZT1/BETA-ZT2/std::pow(BETA,3) -
             default:
                 throw 77;
         }
-        return 0.;
+        //return 0.;
     }