Fixed templated FHT class compilation issues with forward declarations

Modules/FDEM1D/examples/Hantenna.cpp

 #if defined(__clang__)
 	/* Clang/LLVM. ---------------------------------------------- */
     const char* compiler = "clang";
+    const char* ver = __VERSION__;
 #elif defined(__ICC) || defined(__INTEL_COMPILER)
 	/* Intel ICC/ICPC. ------------------------------------------ */
     const char* compiler = "icpc";

Modules/FDEM1D/include/FHT.h

 
     }; // -----  end of class  FHT  ----
 
+    // Forward declarations
+    template<>
+    const Eigen::Matrix<Real, Eigen::Dynamic, 3>  FHT<FHTKEY201>::WT;
+    template<>
+    const Eigen::Matrix<Real, Eigen::Dynamic, 3>  FHT<FHTKEY101>::WT;
+    template<>
+    const Eigen::Matrix<Real, Eigen::Dynamic, 3>  FHT<FHTKEY51>::WT;
 
     template < HANKELTRANSFORMTYPE Type >
     Complex FHT<Type>::Zgauss(const int& ii, const Lemma::EMMODE& mode, const int& jj, const Real& val,
         return WT(0,0)/WT(1,0);
     }
 
-    /* specializations could provide slighly better performance */
+    /* specializations could provide slighly better performance by reducing divides */
 //     template < >
 //     Real FHT< FHTKEY201 >::GetABSER() {
 //         return WT(0,0)/WT(1,0);

Modules/FDEM1D/include/HankelTransformFactory.h

                     //return FHTKey201::NewSP();
                     return FHT<FHTKEY201>::NewSP();
                 case FHTKEY101:
-                    return FHTKey101::NewSP();
+                    return FHT<FHTKEY101>::NewSP();
+                    //return FHTKey101::NewSP();
                 case FHTKEY51:
-                    return FHTKey51::NewSP();
+                    return FHT<FHTKEY51>::NewSP();
+                    //return FHTKey51::NewSP();
                 case CHAVE:
                     return GQChave::NewSP();
                 case QWEKEY:

Modules/FDEM1D/src/DipoleSource.cpp

                             }
                             break;
                         case H:
-                            std::cout << "Fuck me gently with a chainsaw..." << std::endl;
-                            //std::cout << f.cols() << "\t" << f.rows() << std::endl;
-                            //std::cout << "kern" <<  KernelManager->GetRAWKernel(ik[5]);
-                            //std::cout << "Inputs\t" << TM << "\t" << rho << "\t" << wavef << "\t" << ik[5] << "\t" << KernelManager->GetRAWKernel(ik[5])<< std::endl;
-                            //Hankel->Zgauss(5, TM, 0, rho, wavef, nullptr);
                             f(5) = Hankel->Zgauss(5, TM, 0, rho, wavef, KernelManager->GetRAWKernel(ik[5]));
                             f(6) = Hankel->Zgauss(6, TM, 1, rho, wavef, KernelManager->GetRAWKernel(ik[6]));
                             f(7) = Hankel->Zgauss(7, TE, 0, rho, wavef, KernelManager->GetRAWKernel(ik[7]))*KernelManager->GetRAWKernel(ik[7])->GetZs()/KernelManager->GetRAWKernel(ik[7])->GetZm();
                             f(8) = Hankel->Zgauss(8, TE, 1, rho, wavef, KernelManager->GetRAWKernel(ik[8]))*KernelManager->GetRAWKernel(ik[8])->GetZs()/KernelManager->GetRAWKernel(ik[8])->GetZm();
                             f(9) = Hankel->Zgauss(9, TE, 1, rho, wavef, KernelManager->GetRAWKernel(ik[9]))*KernelManager->GetRAWKernel(ik[9])->GetZs()/KernelManager->GetRAWKernel(ik[9])->GetZm();
-                            std::cout << "HARDER!!!!" << std::endl;
                             if (std::abs(Pol[1]) > 0) {
                                 this->Receivers->AppendHfield(ifreq, irec,
                                         Pol[1]*QPI*(sps*f(5)+c2p*f(6)/rho-cps*f(7)+c2p*f(8)/rho)*Moment,
                                     Pol[0]*Moment*QPI*sp*f(9) );
                                 // Analytic whole space solution
                             }
-                            //std::cout << "ahhhhhh!!!!!!!!!" << std::endl;
                             break;
 
                         case BOTH:

Modules/FDEM1D/src/FHT.cpp

 namespace Lemma {
 
     template<>
-    FHT<FHTKEY201>::FHT( const ctor_key& key ) : HankelTransform(key)
-    {
-
-    }
-
-    template<>
     const Eigen::Matrix<Real, Eigen::Dynamic, 3>  FHT<FHTKEY201>::WT =
         ( Eigen::Matrix<Real, 201, 3>()   <<
         // Base                   J0                      J1