Cleaning up MSVC compiler warnings

Modules/FDEM1D/include/FHT.h

 
         // lambda needs to be expanded to include lagged results
         VectorXr lambda = (VectorXr(WT.rows()+nlag) << WT.col(0).array()/rho, VectorXr::Zero(nlag)).finished();
-        for (int ilam =WT.rows(); ilam< nlag+WT.rows(); ++ilam) {
+        for (Index ilam = WT.rows(); ilam< nlag+WT.rows(); ++ilam) {
             lambda(ilam) = lambda(ilam-1)/GetABSER();
         }
 

Modules/FDEM1D/include/HankelTransformFactory.h

                     return FHT<IRONS>::NewSP();
                 default:
                     std::cerr << "HankelTransformFactory only works with defined types\n";
+                    return FHTAnderson801::NewSP(); // dummy return 
             }
-
         }
 
         /**

Modules/FDEM1D/include/KernelEM1DBase.h

 
             virtual void SetMode(const EMMODE& mode)=0;
 
-            int GetManagerIndex() const {
+            Index GetManagerIndex() const {
                 return this->managerIdx;
             }
 
             // ====================  DATA MEMBERS  =========================
 
             /** Where does this kernel live on the vector managed by the manager */
-            int  managerIdx;
+            Index  managerIdx;
 
         private:
 

Modules/FDEM1D/include/WireAntenna.h

               * returns number of dipoles used to approximate this
               * loop
 			  */
-            int GetNumberOfDipoles();
+            size_t GetNumberOfDipoles();
 
 			/**
               * @return the number of frequencies of this wire loop.

Modules/FDEM1D/src/AEMSurveyReader.cpp

         int nb = Parser->ReadInts(1)[0];  // number of locations
         for (int ib=0; ib<nb; ++ib) {
             std::vector<Real> rvals = Parser->ReadReals(6); // position and moment
-            int bp = Parser->GetFileLocation(  );
+	    std::streamoff bp = Parser->GetFileLocation(  );
             Parser->JumpToLocation( 0 );
             //std::vector<int> ivals = Parser->ReadInts(1);   // number of frequencies
             int nf = Parser->ReadInts(1)[0];   // number of frequencies
             for (int isc=0; isc<nf; ++isc) {
                 Survey->Sources.push_back(DipoleSource::NewSP());
-                int cnt = Survey->Sources.size() - 1; //
+                size_t cnt = Survey->Sources.size() - 1; //
                 // and now set it
                 Survey->Sources[cnt]->SetNumberOfFrequencies(1);
                 Survey->Sources[cnt]->SetFrequency(0, Parser->ReadReals(1)[0]);

Modules/FDEM1D/src/DipoleSource.cpp

   @file
   @author   Trevor Irons
   @date     12/02/2009
-  @version  $Id: dipolesource.cpp 203 2015-01-09 21:19:04Z tirons $
  **/
 
 #include "DipoleSource.h"
     }
 
     int DipoleSource::GetNumberOfFrequencies() {
-        return this->Freqs.size();
+        return (int)(this->Freqs.size());
     }
 
     void DipoleSource::SetNumberOfFrequencies(const int &nfreq){

Modules/FDEM1D/src/GQChave.cpp

         np  = 0; // TI, zero based indexing
 
         int  NPB   = 1; // 0?
-        int  L     = 0; // TODO, should be 0?
+        int  L     = 0; 
         Real B     = 0.;
         Real A     = 0.;
         Real SUMR  = 0.;
                     LASTI=XSUMI;
                 }
             }
-            while (ZeroJ(NPB,IORDER) > XSUM(NSUM*rho)) {
+	    // TODO, evaluate this case triggering cerr, as well as sttement below
+            //while ( ZeroJ(NPB,IORDER) > XSUM(NSUM*rho)) {
+            while ( ZeroJ(NPB,IORDER) > XSUM( (int)(NSUM*rho) )) {
                 ++NPB;
             }
         }

Modules/FDEM1D/src/WireAntenna.cpp

   @file
   @author   Trevor Irons
   @date     12/16/2009
-  @version  $Id: wireantenna.cpp 199 2014-12-29 19:25:20Z tirons $
  **/
 
 #include "WireAntenna.h"
     }
 
     int WireAntenna::GetNumberOfFrequencies() {
-        return Freqs.size();
+        return (int)(Freqs.size());  // Index to int
     }
 
     Vector3Xr WireAntenna::GetPoints() {
 
     // ====================  INQUIRY       =======================
 
-    int WireAntenna::GetNumberOfDipoles() {
-        return Dipoles.size();
+    size_t WireAntenna::GetNumberOfDipoles() {
+        return Dipoles.size();  // size_t to int
     }
 
     std::shared_ptr<DipoleSource> WireAntenna::GetDipoleSource(const int &dip) {

Modules/LemmaCore/include/ASCIIParser.h

 /**
  * @file
  * @date      09/23/2013 02:31:24 PM
- * @version   $Id$
  * @author    Trevor Irons (ti)
- * @email     Trevor.Irons@xri-geo.com
- * @copyright Copyright (c) 2013, Trevor Irons
+ * @email     Trevor.Irons@LemmaSoftware.org
+ * @copyright Copyright (c) 2013, 2018 Trevor Irons
  */
 
 #ifndef  ASCIIPARSER_INC
     /**
      * @param[in] loc is the point in the file to jump to. Uses seekg
      */
-    void JumpToLocation(const int& loc);
+    void JumpToLocation(const std::streamoff& loc);
 
     // ====================  ACCESS        =======================
 
     /**
      * @return the current position in the file, as reported by istream::tellg
      */
-    int GetFileLocation();
+    std::streamoff GetFileLocation();
 
     /** Returns the name of the underlying class, similiar to Python's type */
     virtual std::string GetName() const;

Modules/LemmaCore/include/CubicSplineInterpolator.h

     SplineSet( ) {
     }
 
-    SplineSet(const int&n) {
+    SplineSet(const Index& n) {
         a = VectorXr::Zero(n+1);
         b = VectorXr::Zero(n);
         c = VectorXr::Zero(n+1);
 
     /** Finds the interval of knots in spline to use for integration.
      */
-    int Interval(const Real& x);
+    Index Interval(const Real& x);
 
     private:
 
 
     SplineSet Spline;
 
-    int ilo;
+    Index ilo;
 
     int mflag;
 

Modules/LemmaCore/include/lemma.h

         /// A 3 component Eigen vector of Reals
         typedef Eigen::Matrix<Real, 3, 1> Vector3r;
 
-        /// A 3 X Dynamic Component Eigen matrix of Reals
+        typedef Eigen::Matrix<Real, Eigen::Dynamic, 1>::Index Index;
+        
+	/// A 3 X Dynamic Component Eigen matrix of Reals
         typedef Eigen::Matrix<Real, 3, Eigen::Dynamic> Vector3Xr;
 
         /// Variable length Eigen vector of Reals

Modules/LemmaCore/src/ASCIIParser.cpp

 /**
  * @file
  * @date      09/23/2013 02:33:41 PM
- * @version   $Id$
  * @author    Trevor Irons (ti)
- * @email     Trevor.Irons@xri-geo.com
- * @copyright Copyright (c) 2013, Trevor Irons
+ * @email     Trevor.Irons@Lemmasoftware.org
+ * @copyright Copyright (c) 2013,2018 Trevor Irons
  */
 
 #include "ASCIIParser.h"
     // ====================  FRIEND METHODS  =====================
 
     std::ostream &operator << (std::ostream &stream, const ASCIIParser &ob) {
-        stream << ob.Serialize()  << "\n---\n"; // End of doc
+        stream << ob.Serialize()  << "\n"; 
         return stream;
     }
 
     //       Class:  ASCIIParser
     //      Method:  GetFileLocation
     //--------------------------------------------------------------------------------------
-    int ASCIIParser::GetFileLocation (  ) {
+    std::streamoff ASCIIParser::GetFileLocation (  ) {
         return input.tellg();
     }		// -----  end of method ASCIIParser::GetFileLocation  -----
 
     //       Class:  ASCIIParser
     //      Method:  JumpToLocation
     //--------------------------------------------------------------------------------------
-    void ASCIIParser::JumpToLocation ( const int& loc ) {
+    void ASCIIParser::JumpToLocation ( const std::streamoff& loc ) {
         input.seekg( loc );
         return ;
     }		// -----  end of method ASCIIParser::JumpToLocation  -----

Modules/LemmaCore/src/CubicSplineInterpolator.cpp

     //--------------------------------------------------------------------------------------
     void CubicSplineInterpolator::SetKnots ( const VectorXr& x, const VectorXr& y ) {
 
-        int n = x.size()-1;
+        //int n = x.size()-1;
+        Index n = x.size()-1;
 
         Spline = SplineSet(n);
 
         Spline.a = y;
         Spline.x = x;
         VectorXr h = VectorXr::Zero(n);
-        for(int i=0; i<n; ++i)
+        for(Index i=0; i<n; ++i)
             h(i) = Spline.x(i+1)-Spline.x(i);
 
         VectorXr alpha(n-1);
-        for(int i=1; i<n-1; ++i)
+        for(Index i=1; i<n-1; ++i)
             alpha(i) =  3.*(Spline.a[i+1]-Spline.a[i])/h[i] - 3.*(Spline.a[i]-Spline.a[i-1])/h[i-1] ;
 
         VectorXr l = VectorXr::Zero(n+1);
         mu[0] = 0;
         z[0] = 0;
 
-        for(int i = 1; i < n-1; ++i) {
+        for(Index i = 1; i < n-1; ++i) {
             l[i] = 2 *(Spline.x[i+1]-Spline.x[i-1])-h[i-1]*mu[i-1];
             mu[i] = h[i]/l[i];
             z[i] = (alpha[i]-h[i-1]*z[i-1])/l[i];
         l[n] = 1;
         z[n] = 0;
 
-        for(int j = n-1; j >= 0; --j) {
+        for(Index j = n-1; j >= 0; --j) {
             Spline.c[j] = z[j] - mu[j] * Spline.c[j+1];
             Spline.b[j] = (Spline.a[j+1]-Spline.a[j])/h[j]-h[j]*(Spline.c[j+1]+2*Spline.c[j])/3;
             Spline.d[j] = (Spline.c[j+1]-Spline.c[j])/3/h[j];
     //--------------------------------------------------------------------------------------
     Real CubicSplineInterpolator::Integrate ( const Real& x0, const Real& x1 ) {
 
-
-        int i0 = Interval(x0);
-        int i1 = Interval(x1);
+        Index i0 = Interval(x0);
+        Index i1 = Interval(x1);
 
         Real h0 = x0 - Spline.x(i0);
         if (mflag == -1) h0 = 0;
 
         // Include integrals over intervening intervals.
         if (i1 > i0) {
-            for (int i=i0; i<i1-1; ++i) {
+            for (Index i=i0; i<i1-1; ++i) {
                 Real h = Spline.x(i+1) - Spline.x(i);
                 cubint +=  (((Spline.d(i)*h/4.0 + Spline.c(i) )*h/3.0 +
                               Spline.b(i))*h/2.0 + Spline.a(i) )*h;
     //       Class:  CubicSplineInterpolator
     //      Method:  Interval
     //--------------------------------------------------------------------------------------
-    int CubicSplineInterpolator::Interval ( const Real& x ) {
+    Index CubicSplineInterpolator::Interval ( const Real& x ) {
 
         std::cerr << "ENTERING CubicSplineInterpolator::Inverval. Known bugs here"  << std::endl;
-        int nx = Spline.x.size() - 2; // TODO check if this is correct or just -1
+        Index nx = Spline.x.size() - 2; // TODO check if this is correct or just -1
         // when x not in range
         if (x <= Spline.x(0) || nx <= 1 ) {
             mflag = -1;
 
         mflag = 0;
         if (ilo >= nx) ilo = nx-1;
-        int ihi = ilo+1;
+        Index ihi = ilo+1;
 
         // if x is already in the interval
         if ( x<Spline.x(ihi) && x >= Spline.x(ilo) ) {
         }
 
         if (x <= Spline.x(ilo)) { // decrease ilo to capture
-            int istep = 1;
-            for (int ix=1; ix<nx; ++ix) {
+            Index istep = 1;
+            for (Index ix=1; ix<nx; ++ix) {
                 ihi = ilo;
                 ilo = ihi - istep;
-                ilo = std::max(1, ilo);
+                ilo = std::max(Index(1), ilo);
                 if (x >= Spline.x(ilo) || ilo == 1) break;
                 istep *= 2;
             }
         } else if (x >= Spline.x(ihi)) { // increase ihi to capture
-            int istep = 1;
-            for (int ix=1; ix<nx; ++ix) {
+            Index istep = 1;
+            for (Index ix=1; ix<nx; ++ix) {
                 ilo = ihi;
                 ihi = ilo + istep;
                 ihi = std::min(ihi, nx);
 
         // Now Spline.x(ilo) <= x < Spline.x(ihi) --> Narrow the interval.
         //std::cout << "WIDE INTERVAL " << Spline.x(ilo) << "\t" << x << "\t" << Spline.x(ihi) << std::endl;
-        for (int ix=1; ix<nx; ++ix) {
-            int middle = (ilo+ihi) / 2;
+        for (Index ix=1; ix<nx; ++ix) {
+            Index middle = (ilo+ihi) / 2;
             if (middle == ilo) break;
             if (x < Spline.x(middle)) {
                 ihi = middle;

Modules/LemmaCore/src/RectilinearGrid.cpp

 namespace Lemma {
 
     std::ostream &operator << (std::ostream &stream, const RectilinearGrid &ob) {
-        stream << ob.Serialize()  << "\n---\n"; // End of doc
+        stream << ob.Serialize()  << "\n"; 
         return stream;
     }
 
 
     void RectilinearGrid::SetSpacing (const VectorXr &idx, const VectorXr &idy,
                 const VectorXr &idz) {
-        nx = idx.size();
-        ny = idy.size();
-        nz = idz.size();
+        // MSVC doens't allow static_cast here
+        //nx = std::static_cast<int>( idx.size() );
+        //ny = std::static_cast<int>( idy.size() );
+        //nz = std::static_cast<int>( idz.size() );
+        nx = (int)( idx.size() );
+        ny = (int)( idy.size() );
+        nz = (int)( idz.size() );
         dx = idx;
         dy = idy;
         dz = idz;

Modules/LemmaCore/src/WindowFilter.cpp

   @file
   @author   Trevor Irons
   @date     07/20/2010
-  @version  $Id: windowfilter.cpp 87 2013-09-05 22:44:05Z tirons $
  **/
 
 #include "WindowFilter.h"
         std::cout << "Window nyquist " << Nyquist << std::endl;
         std::cout << "Window Nw  " << Nw << std::endl;
         Real  df      = (Nyquist)/((Real)(Nw)); // df Hz per bin
-        Width         = Bandwidth/df;
+        Width         = (int)(std::round(Bandwidth/df));
         Coefficients.resize(Width);
         switch (Type) {
             case HAMMING: