diff --git a/Cantera/src/kinetics/GRI_30_Kinetics.cpp b/Cantera/src/kinetics/GRI_30_Kinetics.cpp
index dd01e524d..1d5a1ba85 100644
--- a/Cantera/src/kinetics/GRI_30_Kinetics.cpp
+++ b/Cantera/src/kinetics/GRI_30_Kinetics.cpp
@@ -85,8 +85,8 @@ namespace Cantera {
     }
 
 
-    void GRI_30_Kinetics::update_rates(double t, double tlog, double* rf) {
-        double rt = 1.0/t;
+    void GRI_30_Kinetics::update_rates(doublereal t, doublereal tlog, doublereal * rf) {
+        doublereal rt = 1.0/t;
         rf[0] =  exp(25.5108 + -1 * tlog);
         rf[1] =  exp(26.9379 + -1 * tlog);
         rf[2] =  exp(3.65584 + 2.7 * tlog - 3150.48 * rt);
@@ -291,7 +291,7 @@ namespace Cantera {
     }
 
 
-    void GRI_30_Kinetics::update_kc(const double* a, double exp_c0, double* rkc) {
+    void GRI_30_Kinetics::update_kc(const doublereal * a, doublereal  exp_c0, doublereal * rkc) {
         rkc[0] = a[3]*exp_c0/(a[2]*a[2]);
         rkc[1] = a[4]*exp_c0/(a[1]*a[2]);
         rkc[2] = a[1]*a[4]/(a[0]*a[2]);
@@ -604,7 +604,7 @@ namespace Cantera {
     }
 
 
-    void GRI_30_Kinetics::get_wdot(const double* rop, double* wdot) {
+    void GRI_30_Kinetics::get_wdot(const doublereal * rop, doublereal * wdot) {
         wdot[0] =  - rop[2] + rop[7] + rop[38] + rop[39] + rop[40] + rop[41] + rop[44] + rop[46] + rop[48] + rop[50] + rop[52] + rop[54] + rop[57] + rop[59] + rop[64] + rop[67] + rop[68] + rop[72] + rop[74] + rop[76] + rop[77] + rop[79] - rop[82] - rop[83] - rop[125] - rop[135] + rop[136] - rop[145] - rop[171] + rop[173] + rop[190] + rop[196] + rop[201] + rop[208] + rop[213] - rop[220] + rop[265] + rop[275] + rop[276] + rop[283] + rop[287] - rop[288] + rop[292] + rop[298] + rop[299] + rop[308] + rop[313];
         wdot[1] =  - rop[1] + rop[2] + rop[5] + rop[6] + rop[8] + rop[9] + rop[13] + rop[20] + rop[23] + rop[27] - rop[32] - rop[33] - rop[34] - rop[35] - rop[36] - rop[37] - 2*rop[38] - 2*rop[39] - 2*rop[40] - 2*rop[41] - rop[42] - rop[43] - rop[44] - rop[45] - rop[46] - rop[47] - rop[48] - rop[49] - rop[50] - rop[51] - rop[52] - rop[53] - rop[54] - rop[55] - rop[56] - rop[57] - rop[58] - rop[59] - rop[60] - rop[61] - rop[62] - rop[64] - rop[65] - rop[66] - rop[67] - rop[68] - rop[69] - rop[70] - rop[71] - rop[72] - rop[73] - rop[74] - rop[75] - rop[76] - rop[77] - rop[78] - rop[79] - rop[80] + rop[83] + rop[89] + rop[90] + rop[91] + rop[93] + rop[98] + rop[105] + rop[106] + rop[107] + rop[122] + rop[123] + rop[125] + rop[126] + rop[127] + rop[128] + rop[129] + rop[132] + rop[134] + rop[135] + rop[137] + rop[143] + rop[145] + rop[148] + rop[158] + rop[165] + rop[166] + rop[171] + rop[179] - rop[182] - rop[188] + rop[189] - rop[190] + rop[191] + rop[195] + rop[198] + rop[200] - rop[201] + rop[203] + rop[204] - rop[208] - rop[211] - rop[213] + rop[217] + rop[220] - rop[222] + rop[223] + rop[229] + rop[230] + rop[233] + rop[234] - rop[236] + rop[246] + rop[248] + rop[250] + rop[251] + rop[253] + rop[256] + rop[259] - rop[260] - rop[264] - rop[265] - rop[270] - rop[271] + rop[274] - rop[276] + rop[283] + rop[284] + rop[285] + 2*rop[289] + 2*rop[291] - rop[298] - rop[299] - rop[303] + rop[304] - rop[307] - rop[308] - rop[313] - rop[319] - rop[320];
         wdot[2] =  - 2*rop[0] - rop[1] - rop[2] - rop[3] - rop[4] - rop[5] - rop[6] - rop[7] - rop[8] - rop[9] - rop[10] - rop[11] - rop[12] - rop[13] - rop[14] - rop[15] - rop[16] - rop[17] - rop[18] - rop[19] - rop[20] - rop[21] - rop[22] - rop[23] - rop[24] - rop[25] - rop[26] - rop[27] - rop[28] - rop[29] + rop[30] + rop[37] + rop[43] + rop[85] + rop[121] + rop[124] + rop[154] + rop[177] + rop[178] - rop[180] - rop[181] + rop[184] - rop[186] - rop[187] - rop[189] + rop[193] - rop[199] - rop[200] - rop[206] - rop[207] - rop[212] - rop[216] + rop[219] - rop[221] - rop[230] - rop[231] - rop[232] + rop[243] + rop[245] - rop[256] - rop[257] + rop[258] - rop[261] - rop[262] - rop[263] - rop[278] - rop[283] - rop[284] - rop[285] + rop[290] + rop[293] - rop[295] - rop[296] - rop[304] - rop[312] - rop[318];
@@ -661,7 +661,7 @@ namespace Cantera {
     }
 
 
-    void GRI_30_Kinetics::eval_ropnet(const double* c, const double* rf, const double* rkc, double* r) {
+    void GRI_30_Kinetics::eval_ropnet(const doublereal * c, const doublereal * rf, const doublereal * rkc, doublereal * r) {
         r[0] = rf[0] * (c[2] * c[2] - rkc[0] * c[3]);
         r[1] = rf[1] * (c[2] * c[1] - rkc[1] * c[4]);
         r[2] = rf[2] * (c[2] * c[0] - rkc[2] * c[1] * c[4]);
diff --git a/Cantera/src/kinetics/GRI_30_Kinetics.h b/Cantera/src/kinetics/GRI_30_Kinetics.h
index 094c61289..98494f1f2 100644
--- a/Cantera/src/kinetics/GRI_30_Kinetics.h
+++ b/Cantera/src/kinetics/GRI_30_Kinetics.h
@@ -42,10 +42,10 @@ namespace Cantera {
         void gri30_update_rates_T();
         void gri30_updateROP();
         void gri30_updateKc();
-        void get_wdot(const doublereal* rop, doublereal* wdot);
-        void update_kc(const double* grt, double c0, double* rkc);
-        void update_rates(double t, double tlog, double* rf);
-        void eval_ropnet(const double* c, const double* rf, const double* rkc, double* r);
+        void get_wdot(const doublereal * rop, doublereal * wdot);
+        void update_kc(const doublereal * grt, doublereal  c0, doublereal * rkc);
+        void update_rates(doublereal t, doublereal  tlog, doublereal * rf);
+        void eval_ropnet(const doublereal * c, const doublereal * rf, const doublereal * rkc, doublereal * r);
     };
 }
 
diff --git a/Cantera/src/kinetics/GasKineticsWriter.h b/Cantera/src/kinetics/GasKineticsWriter.h
index 88b07a213..ccfb8486c 100644
--- a/Cantera/src/kinetics/GasKineticsWriter.h
+++ b/Cantera/src/kinetics/GasKineticsWriter.h
@@ -63,7 +63,7 @@ namespace Cantera {
 
 		void writeGetNetProductionRates(std::ostream& s, int nsp, int nrxns) {
             int i, k;
-			s << "void get_wdot(const double* rop, double* wdot) {" << std::endl;
+			s << "void get_wdot(const doublereal * rop, doublereal * wdot) {" << std::endl;
             for (k = 0; k < nsp; k++) {
                 s << "  wdot[" << k << "] = ";
                 doublereal net;
@@ -94,8 +94,8 @@ namespace Cantera {
  
 		void writeUpdateKc(std::ostream& s, int nsp, int nrxns) {
             int i, k, n, nn, ir;
-            s << "void update_kc(const double* a, "
-                "double exp_c0, double* rkc) {" << endl;
+            s << "void update_kc(const doublereal * a, "
+                "doublereal exp_c0, doublereal* rkc) {" << endl;
             for (i = 0; i != m_nrev; i++) {
                 //if (isReversible(i)) {
                 ir = m_revindex[i];
@@ -134,8 +134,8 @@ namespace Cantera {
 
 		void writeEvalRopnet(std::ostream& s) {
             int i;
-            s << "void eval_ropnet(const double* c, "
-                "const double* rf, const double* rkc, double* r) {" << endl;
+            s << "void eval_ropnet(const doublereal* c, "
+                "const doublereal * rf, const doublereal * rkc, doublereal* r) {" << endl;
             for (i = 0; i < m_ii; i++) {
                 s << "  r[" << i << "] = rf[" << i << "] * (" 
                   << m_reactantWriter.mult(i);
@@ -151,8 +151,8 @@ namespace Cantera {
 
 
 		void writeUpdateRates(std::ostream& s) {
-            s << "void update_rates(double t, double tlog, double* rf) {" << endl;
-            s << "  double rt = 1.0/t;" << endl;
+            s << "void update_rates(doublereal t, doublereal tlog, doublereal * rf) {" << endl;
+            s << "  doublereal rt = 1.0/t;" << endl;
             m_rates.writeUpdate(s, "rf");
             s << "}" << endl;
         }
diff --git a/Cantera/src/kinetics/ImplicitChem.cpp b/Cantera/src/kinetics/ImplicitChem.cpp
index 5a05e2f76..58192ffb7 100644
--- a/Cantera/src/kinetics/ImplicitChem.cpp
+++ b/Cantera/src/kinetics/ImplicitChem.cpp
@@ -38,7 +38,7 @@ namespace Cantera {
 
     // overloaded method of FuncEval. Called by the integrator to
     // get the initial conditions.
-    void ImplicitChem::getInitialConditions(double t0, size_t leny, double* y) 
+    void ImplicitChem::getInitialConditions(doublereal t0, size_t leny, doublereal * y) 
     {
         m_thermo->getMassFractions(y);
         m_h0 = m_thermo->enthalpy_mass();
diff --git a/Cantera/src/kinetics/ImplicitSurfChem.cpp b/Cantera/src/kinetics/ImplicitSurfChem.cpp
index 28e82d45a..8334ae95f 100644
--- a/Cantera/src/kinetics/ImplicitSurfChem.cpp
+++ b/Cantera/src/kinetics/ImplicitSurfChem.cpp
@@ -132,8 +132,8 @@ namespace Cantera {
 
   // overloaded method of FuncEval. Called by the integrator to
   // get the initial conditions.
-  void ImplicitSurfChem::getInitialConditions(double t0, size_t lenc, 
-					      double* c) 
+  void ImplicitSurfChem::getInitialConditions(doublereal t0, size_t lenc, 
+					      doublereal * c) 
   {
     int loc = 0;
     for (int n = 0; n < m_nsurf; n++) {
@@ -234,7 +234,7 @@ namespace Cantera {
     /*
      * time scale - time over which to integrate equations
      */
-    double time_scale = timeScaleOverride;
+    doublereal time_scale = timeScaleOverride;
     /*
      *
      */
@@ -263,8 +263,8 @@ namespace Cantera {
     getConcSpecies(DATA_PTR(m_concSpecies));
     InterfaceKinetics *ik = m_vecKinPtrs[0];
     ThermoPhase &tp = ik->thermo(0);
-    double TKelvin = tp.temperature();
-    double PGas  = tp.pressure();
+    doublereal TKelvin = tp.temperature();
+    doublereal PGas  = tp.pressure();
     /*
      * Make sure that there is a common temperature and 
      * pressure for all ThermoPhase objects belonging to the
@@ -275,8 +275,8 @@ namespace Cantera {
       setCommonState_TP(TKelvin, PGas);
     }
 
-    double reltol = 1.0E-6;
-    double atol = 1.0E-20;
+    doublereal reltol = 1.0E-6;
+    doublereal atol = 1.0E-20;
 
     /*
      * Install a filter for negative concentrations. One of the 
@@ -379,7 +379,7 @@ namespace Cantera {
    *        Pressure    = Pascal
    */
   void ImplicitSurfChem::
-  setCommonState_TP(double TKelvin, double PresPa) {
+  setCommonState_TP(doublereal TKelvin, doublereal PresPa) {
     int nphases = m_nsurf;
     for (int ip = 0; ip < nphases; ip++) {
       ThermoPhase *TP_ptr = m_surf[ip];
diff --git a/Cantera/src/kinetics/ImplicitSurfChem.h b/Cantera/src/kinetics/ImplicitSurfChem.h
index adc0fcdce..4074f4de5 100644
--- a/Cantera/src/kinetics/ImplicitSurfChem.h
+++ b/Cantera/src/kinetics/ImplicitSurfChem.h
@@ -212,7 +212,7 @@ namespace Cantera {
      *  @param TKelvin input temperature (kelvin)
      *  @param PresPa   input pressure in pascal.
      */
-    void setCommonState_TP(double TKelvin, double PresPa);
+    void setCommonState_TP(doublereal TKelvin, doublereal PresPa);
 
 
     //! Returns a reference to the vector of pointers to the 
@@ -245,25 +245,25 @@ namespace Cantera {
      *          The lenth is equal to the sum of the number of surface
      *          sites in all the surface phases
      */
-    void updateState(doublereal* y);
+    void updateState(doublereal *y);
 
     //! vector of pointers to surface phases.
-    std::vector<SurfPhase*>            m_surf;
+    std::vector<SurfPhase*> m_surf;
 
     //! Vector of pointers to bulk phases
-    std::vector<ThermoPhase *>         m_bulkPhases;
+    std::vector<ThermoPhase *> m_bulkPhases;
 
     //! vector of pointers to InterfaceKinetics objects
-    std::vector<InterfaceKinetics*>    m_vecKinPtrs;
+    std::vector<InterfaceKinetics*> m_vecKinPtrs;
 
     //! Vector of number of species in each Surface Phase
-    vector_int                    m_nsp;
+    vector_int  m_nsp;
 
     //! index of the surface phase in each InterfaceKinetics object
-    vector_int                    m_surfindex;
+    vector_int m_surfindex;
 
     
-    vector_int                    m_specStartIndex;
+    vector_int m_specStartIndex;
 
     //! Total number of surface phases.
     /*!
diff --git a/Cantera/src/kinetics/InterfaceKinetics.cpp b/Cantera/src/kinetics/InterfaceKinetics.cpp
index 98df1c8fd..090b8585e 100644
--- a/Cantera/src/kinetics/InterfaceKinetics.cpp
+++ b/Cantera/src/kinetics/InterfaceKinetics.cpp
@@ -425,7 +425,7 @@ namespace Cantera {
      */
     doublereal eamod;
 #ifdef DEBUG_KIN_MODE
-    double ea;
+    doublereal ea;
 #endif
     int nct = m_beta.size();
     int irxn;
diff --git a/Cantera/src/kinetics/InterfaceKinetics.h b/Cantera/src/kinetics/InterfaceKinetics.h
index 08cc525e0..c1b0343a8 100644
--- a/Cantera/src/kinetics/InterfaceKinetics.h
+++ b/Cantera/src/kinetics/InterfaceKinetics.h
@@ -38,8 +38,9 @@ namespace Cantera {
   class ImplicitSurfChem;
 
 
-  /**
-   * Holds mechanism-specific data.
+  //! This class holds mechanism-specific data.
+  /*!
+   *
    */
   class InterfaceKineticsData {
   public:
@@ -47,9 +48,11 @@ namespace Cantera {
       m_ROP_ok(false),
       m_temp(0.0), m_logtemp(0.0)
     {}
+    //! Virtual destructor
     virtual ~InterfaceKineticsData(){}
 
-    doublereal m_logp0, m_logc0;
+    doublereal m_logp0;
+    doublereal m_logc0;
     array_fp m_ropf;
     array_fp m_ropr;
     array_fp m_ropnet;
diff --git a/Cantera/src/kinetics/ReactionPath.cpp b/Cantera/src/kinetics/ReactionPath.cpp
index af42f38a2..fc92869da 100644
--- a/Cantera/src/kinetics/ReactionPath.cpp
+++ b/Cantera/src/kinetics/ReactionPath.cpp
@@ -136,7 +136,7 @@ namespace Cantera {
 
     vector_int ReactionPathDiagram::reactions() {
         int i, npaths = nPaths();
-        double flmax = 0.0, flxratio;
+        doublereal flmax = 0.0, flxratio;
         Path* p;
         for (i = 0; i < npaths; i++) 
         {
@@ -163,7 +163,7 @@ namespace Cantera {
     }
 
     void ReactionPathDiagram::add(ReactionPathDiagram& d) {
-//        double f1, f2;
+//        doublereal f1, f2;
 //         int nnodes = nNodes();
 //         if (nnodes != d.nNodes()) {
 //             throw CanteraError("ReactionPathDiagram::add",
@@ -205,7 +205,7 @@ namespace Cantera {
     }
 
     void ReactionPathDiagram::writeData(ostream& s) {
-        double f1, f2;
+        doublereal f1, f2;
         int nnodes = nNodes();
         int i1, i2, k1, k2;
         s << title << endl;
@@ -275,7 +275,7 @@ namespace Cantera {
 
         int nnodes = nNodes();
         int kbegin, kend, i1, i2, k1, k2;
-        double flx;
+        doublereal flx;
 
         // draw paths representing net flows
         if (flow_type == NetFlow) 
diff --git a/Cantera/src/kinetics/ReactionPath.h b/Cantera/src/kinetics/ReactionPath.h
index f2ccf67d6..7cff095e7 100644
--- a/Cantera/src/kinetics/ReactionPath.h
+++ b/Cantera/src/kinetics/ReactionPath.h
@@ -70,15 +70,16 @@ namespace Cantera {
         /// add a path to or from this node
         void addPath(Path* path);
 
-        double outflow() {return m_out;}
-        double inflow() {return m_in;}
-        double netOutflow() {return m_out - m_in;}
+        doublereal outflow() {return m_out;}
+        doublereal inflow() {return m_in;}
+        doublereal netOutflow() {return m_out - m_in;}
         
         void printPaths();
 
         
     protected:
-        double m_in, m_out;
+        doublereal m_in;
+        doublereal m_out;
         path_list m_paths;
     };
 
@@ -216,10 +217,10 @@ namespace Cantera {
         doublereal x_size, y_size;
         std::string name, dot_options;
         flow_t flow_type;
-        double scale;
-        double arrow_width; 
+        doublereal scale;
+        doublereal arrow_width; 
         bool show_details;
-        double arrow_hue;
+        doublereal arrow_hue;
 
     protected:
 
diff --git a/Cantera/src/kinetics/RxnRates.h b/Cantera/src/kinetics/RxnRates.h
index 44f0c6a70..4e3d495ad 100644
--- a/Cantera/src/kinetics/RxnRates.h
+++ b/Cantera/src/kinetics/RxnRates.h
@@ -321,7 +321,7 @@ namespace Cantera {
     }
 
     doublereal updateRC(doublereal logT, doublereal recipT) const {
-      double lres = update(logT, recipT);
+      doublereal lres = update(logT, recipT);
       return exp(lres);
     }
         
diff --git a/Cantera/src/kinetics/importKinetics.cpp b/Cantera/src/kinetics/importKinetics.cpp
index fd6b5a1c4..e40a1df84 100644
--- a/Cantera/src/kinetics/importKinetics.cpp
+++ b/Cantera/src/kinetics/importKinetics.cpp
@@ -96,7 +96,7 @@ namespace Cantera {
   void checkRxnElementBalance(Kinetics& kin, 
 			      const ReactionData &rdata, doublereal errorTolerance) {
     int index, klocal, n, kp, kr, m, nel;
-    double kstoich;
+    doublereal kstoich;
 
     map<string, double> bal, balr, balp;
     bal.clear();
@@ -351,8 +351,8 @@ namespace Cantera {
     int ispKinetics = kin.kineticsSpeciesIndex(spname);
     int ispPhaseIndex = kin.speciesPhaseIndex(ispKinetics);
   
-    double ispMW = th.molecularWeights()[isp];
-    double sc;
+    doublereal ispMW = th.molecularWeights()[isp];
+    doublereal sc;
 
     // loop over the reactants
     for (int n = 0; n < nr; n++) {
@@ -760,9 +760,9 @@ namespace Cantera {
       int np = rdata.products.size();
       for (int i = 0; i < np; i++) {
 	int k = rdata.products[i];
-	double po = rdata.porder[i];
+	doublereal po = rdata.porder[i];
 	AssertTrace(po == rdata.pstoich[i]);
-	double chk = po - 1.0 * int(po);
+	doublereal chk = po - 1.0 * int(po);
 	if (chk != 0.0) {
           /*
            *   put in a check here that k is a single species phase.
@@ -779,9 +779,9 @@ namespace Cantera {
       int nr = rdata.reactants.size();
       for (int i = 0; i < nr; i++) {
 	int k = rdata.reactants[i];
-	double ro = rdata.rorder[i];
+	doublereal ro = rdata.rorder[i];
 	AssertTrace(ro == rdata.rstoich[i]);
-	double chk = ro - 1.0 * int(ro);
+	doublereal chk = ro - 1.0 * int(ro);
 	if (chk != 0.0) {
           /*
            *   put in a check here that k is a single species phase.
diff --git a/Cantera/src/kinetics/solveSP.cpp b/Cantera/src/kinetics/solveSP.cpp
index a44757365..660e1dd05 100644
--- a/Cantera/src/kinetics/solveSP.cpp
+++ b/Cantera/src/kinetics/solveSP.cpp
@@ -30,17 +30,17 @@ namespace Cantera {
      *       STATIC ROUTINES DEFINED IN THIS FILE
      ***************************************************************************/
 
-    static double calc_damping(double *x, double *dx, int dim, int *);
-    static double calcWeightedNorm(const double [], const double dx[], int);
+    static doublereal calc_damping(doublereal *x, doublereal *dx, int dim, int *);
+    static doublereal calcWeightedNorm(const doublereal [], const doublereal dx[], int);
 
     /***************************************************************************
      *                    LAPACK PROTOTYPES
      ***************************************************************************/
     //#define FSUB_TYPE void
     // extern "C" {
-    //  extern FSUB_TYPE dgetrf_(int *, int *, double *, int *, int [], int *);
-    // extern FSUB_TYPE dgetrs_(char *, int *, int *, double *, int *, int [],
-    //			     double [], int *, int *, unsigned int);
+    //  extern FSUB_TYPE dgetrf_(int *, int *, doublereal *, int *, int [], int *);
+    // extern FSUB_TYPE dgetrs_(char *, int *, int *, doublereal *, int *, int [],
+    //			     doublereal [], int *, int *, unsigned int);
     // }
     /*****************************************************************************
      *   PROTOTYPES and PREPROC DIRECTIVES FOR MISC. ROUTINES 
@@ -208,10 +208,10 @@ namespace Cantera {
      * surface species production rate = 0 and that the bulk fractions are
      * proportional to their production rates. 
      */
-    int solveSP::solveSurfProb(int ifunc, double time_scale, double TKelvin, 
-        double PGas, double reltol, double abstol)
+    int solveSP::solveSurfProb(int ifunc, doublereal time_scale, doublereal TKelvin, 
+        doublereal PGas, doublereal reltol, doublereal abstol)
     {
-        double EXTRA_ACCURACY = 0.001;
+        doublereal EXTRA_ACCURACY = 0.001;
         if (ifunc == SFLUX_JACOBIAN) {
             EXTRA_ACCURACY *= 0.001;
         }
@@ -220,24 +220,24 @@ namespace Cantera {
         int label_t=-1; /* Species IDs for time control */
         int label_d; /* Species IDs for damping control */
         int        label_t_old=-1;
-        double     label_factor = 1.0;
+        doublereal     label_factor = 1.0;
         int iter=0; // iteration number on numlinear solver
         int iter_max=1000; // maximum number of nonlinear iterations
         int nrhs=1;
-        double deltaT = 1.0E-10; // Delta time step
-        double damp=1.0, tmp;
+        doublereal deltaT = 1.0E-10; // Delta time step
+        doublereal damp=1.0, tmp;
         //  Weighted L2 norm of the residual.  Currently, this is only
         //  used for IO purposes. It doesn't control convergence.
         //  Therefore, it is turned off when DEBUG_SOLVESP isn't defined.
-        double  resid_norm;
-        double inv_t = 0.0;
-        double t_real = 0.0, update_norm = 1.0E6;
+        doublereal  resid_norm;
+        doublereal inv_t = 0.0;
+        doublereal t_real = 0.0, update_norm = 1.0E6;
 
         bool do_time = false, not_converged = true;
 
 #ifdef DEBUG_SOLVESP
 #ifdef DEBUG_SOLVESP_TIME
-        double         t1;
+        doublereal         t1;
 #endif
 #else
         if (m_ioflag > 1) {
@@ -548,7 +548,7 @@ namespace Cantera {
     /*
      * Update the surface states of the surface phases.
      */
-    void solveSP::updateState(const double *CSolnSP) {
+    void solveSP::updateState(const doublereal *CSolnSP) {
         int loc = 0;
         for (int n = 0; n < m_numSurfPhases; n++) {
             m_ptrsSurfPhase[n]->setConcentrations(CSolnSP + loc);
@@ -565,7 +565,7 @@ namespace Cantera {
     /*
      * Update the mole fractions for phases which are part of the equation set
      */
-    void solveSP::updateMFSolnSP(double *XMolSolnSP) {
+    void solveSP::updateMFSolnSP(doublereal *XMolSolnSP) {
         for (int isp = 0; isp < m_numSurfPhases; isp++) {
             int keqnStart = m_eqnIndexStartSolnPhase[isp];
             m_ptrsSurfPhase[isp]->getMoleFractions(XMolSolnSP + keqnStart);
@@ -582,7 +582,7 @@ namespace Cantera {
      * Update the mole fractions for phases which are part of a single
      * interfacial kinetics object
      */
-    void solveSP::updateMFKinSpecies(double *XMolKinSpecies, int isp) {
+    void solveSP::updateMFKinSpecies(doublereal *XMolKinSpecies, int isp) {
         InterfaceKinetics *m_kin = m_objects[isp];
         int nph = m_kin->nPhases();
         for (int iph = 0; iph < nph; iph++) {
@@ -596,11 +596,11 @@ namespace Cantera {
      * Update the vector that keeps track of the largest species in each
      * surface phase.
      */
-    void solveSP::evalSurfLarge(const double *CSolnSP) {
+    void solveSP::evalSurfLarge(const doublereal *CSolnSP) {
         int kindexSP = 0;
         for (int isp = 0; isp < m_numSurfPhases; isp++) {
             int nsp = m_nSpeciesSurfPhase[isp];
-            double Clarge = CSolnSP[kindexSP];
+            doublereal Clarge = CSolnSP[kindexSP];
             m_spSurfLarge[isp] = 0;
             kindexSP++;
             for (int k = 1; k < nsp; k++, kindexSP++) {
@@ -622,14 +622,14 @@ namespace Cantera {
      *   This routine uses the m_numEqn1 and m_netProductionRatesSave vectors
      *   as temporary internal storage.
      */
-    void solveSP::fun_eval(double* resid, const double *CSoln, 
-        const double *CSolnOld,  const bool do_time,
-        const double deltaT)
+    void solveSP::fun_eval(doublereal * resid, const doublereal *CSoln, 
+        const doublereal *CSolnOld,  const bool do_time,
+        const doublereal deltaT)
     {
         int isp, nsp, kstart, k, kindexSP, kins, kspecial;
-        double lenScale = 1.0E-9;
-        double sd = 0.0;
-        double grRate;
+        doublereal lenScale = 1.0E-9;
+        doublereal sd = 0.0;
+        doublereal grRate;
         if (m_numSurfPhases > 0) {
             /*
              * update the surface concentrations with the input surface 
@@ -690,7 +690,7 @@ namespace Cantera {
             if (m_bulkFunc == BULK_DEPOSITION) {
                 kindexSP = m_numTotSurfSpecies;
                 for (isp = 0; isp < m_numBulkPhasesSS; isp++) {
-                    double *XBlk = DATA_PTR(m_numEqn1);
+                    doublereal *XBlk = DATA_PTR(m_numEqn1);
                     //ThermoPhase *THptr = m_bulkPhasePtrs[isp];
                     //THptr->getMoleFractions(XBlk);
                     nsp = m_nSpeciesSurfPhase[isp];
@@ -743,14 +743,14 @@ namespace Cantera {
      *   This routine uses the m_numEqn2 vector
      *   as temporary internal storage.
      */
-    void solveSP::resjac_eval(std::vector<double*> &JacCol,
-        double resid[], double CSoln[], 
-        const double CSolnOld[], const bool do_time, 
-        const double deltaT)
+    void solveSP::resjac_eval(std::vector<doublereal *> &JacCol,
+        doublereal resid[], doublereal CSoln[], 
+        const doublereal CSolnOld[], const bool do_time, 
+        const doublereal deltaT)
     {
         int kColIndex = 0, nsp, jsp, i, kCol;
-        double dc, cSave, sd;
-        double *col_j;
+        doublereal dc, cSave, sd;
+        doublereal *col_j;
         /*
          * Calculate the residual
          */
@@ -798,7 +798,7 @@ namespace Cantera {
 
 #define APPROACH 0.80
 
-    static double calc_damping(double x[], double dxneg[], int dim, int *label)
+    static doublereal calc_damping(doublereal x[], doublereal dxneg[], int dim, int *label)
 
         /* This function calculates a damping factor for the Newton iteration update
          * vector, dxneg, to insure that all site and bulk fractions, x, remain
@@ -813,8 +813,8 @@ namespace Cantera {
 
     {
         int       i;
-        double    damp = 1.0, xnew, xtop, xbot;
-        static double damp_old = 1.0;
+        doublereal    damp = 1.0, xnew, xtop, xbot;
+        static doublereal damp_old = 1.0;
 
         *label = -1;
 
@@ -873,9 +873,9 @@ namespace Cantera {
      *    This function calculates the norm  of an update, dx[], 
      *    based on the weighted values of x.
      */
-    static double calcWeightedNorm(const double wtX[], const double dx[], int dim) {
-        double norm = 0.0;
-        double tmp;
+    static doublereal calcWeightedNorm(const doublereal wtX[], const doublereal dx[], int dim) {
+        doublereal norm = 0.0;
+        doublereal tmp;
         if (dim == 0) return 0.0;
         for (int i = 0; i < dim; i++) {
             tmp = dx[i] / wtX[i];
@@ -889,12 +889,12 @@ namespace Cantera {
      * concentration unknowns and the residual unknowns.
      *
      */
-    void solveSP::calcWeights(double wtSpecies[], double wtResid[],
-        const Array2D &Jac, const double CSoln[],
-        const double abstol, const double reltol)
+    void solveSP::calcWeights(doublereal wtSpecies[], doublereal wtResid[],
+        const Array2D &Jac, const doublereal CSoln[],
+        const doublereal abstol, const doublereal reltol)
     {
         int k, jcol, kindex, isp, nsp;
-        double sd;
+        doublereal sd;
         /*
          * First calculate the weighting factor for the concentrations of
          * the surface species and bulk species.
@@ -941,13 +941,13 @@ namespace Cantera {
      *
      *     Maximum time step set to time_scale.
      */
-    double solveSP::
-    calc_t(double netProdRateSolnSP[], double XMolSolnSP[],
-        int *label, int *label_old, double *label_factor, int ioflag)
+    doublereal solveSP::
+    calc_t(doublereal netProdRateSolnSP[], doublereal XMolSolnSP[],
+        int *label, int *label_old, doublereal *label_factor, int ioflag)
     {
         int  k, isp, nsp, kstart;
-        double   inv_timeScale = 1.0E-10;
-        double sden, tmp;
+        doublereal   inv_timeScale = 1.0E-10;
+        doublereal sden, tmp;
         int kindexSP = 0;
         *label = 0;
         int ispSpecial = 0;
@@ -1025,8 +1025,8 @@ namespace Cantera {
      */
 #ifdef DEBUG_SOLVESP
     void solveSP::printResJac(int ioflag, int neq, const Array2D &Jac,
-        double resid[], double wtRes[],
-        double norm)
+        doublereal resid[], doublereal wtRes[],
+        doublereal norm)
     {
         int i, j, isp, nsp, irowKSI, irowISP;
         int kstartKSI;
@@ -1085,11 +1085,11 @@ namespace Cantera {
     /*
      * Optional printing at the start of the solveSP problem
      */
-    void solveSP::print_header(int ioflag, int ifunc, double time_scale, 
-        int damping, double reltol, double abstol,  
-        double TKelvin,
-        double PGas, double netProdRate[],
-        double XMolKinSpecies[]) {
+    void solveSP::print_header(int ioflag, int ifunc, doublereal time_scale, 
+        int damping, doublereal reltol, doublereal abstol,  
+        doublereal TKelvin,
+        doublereal PGas, doublereal netProdRate[],
+        doublereal XMolKinSpecies[]) {
         if (ioflag) {
             printf("\n================================ SOLVESP CALL SETUP "
                 "========================================\n");
@@ -1194,13 +1194,13 @@ namespace Cantera {
         }
     } 
 
-    void solveSP::printIteration(int ioflag, double damp, int label_d,
+    void solveSP::printIteration(int ioflag, doublereal damp, int label_d,
         int label_t,
-        double inv_t, double t_real, int iter,
-        double update_norm, double resid_norm,
-        double netProdRate[], double CSolnSP[],
-        double resid[], double XMolSolnSP[],
-        double wtSpecies[], int dim, bool do_time)
+        doublereal inv_t, doublereal t_real, int iter,
+        doublereal update_norm, doublereal resid_norm,
+        doublereal netProdRate[], doublereal CSolnSP[],
+        doublereal resid[], doublereal XMolSolnSP[],
+        doublereal wtSpecies[], int dim, bool do_time)
     {
         int i, k;
         string nm;
@@ -1278,14 +1278,14 @@ namespace Cantera {
     } /* printIteration */
 
 
-    void solveSP::printFinal(int ioflag, double damp, int label_d, int label_t,
-        double inv_t, double t_real, int iter,
-        double update_norm, double resid_norm,
-        double netProdRateKinSpecies[], const double CSolnSP[],
-        const double resid[], double XMolSolnSP[],
-        const double wtSpecies[], const double wtRes[],
+    void solveSP::printFinal(int ioflag, doublereal damp, int label_d, int label_t,
+        doublereal inv_t, doublereal t_real, int iter,
+        doublereal update_norm, doublereal resid_norm,
+        doublereal netProdRateKinSpecies[], const doublereal CSolnSP[],
+        const doublereal resid[], doublereal XMolSolnSP[],
+        const doublereal wtSpecies[], const doublereal wtRes[],
         int dim, bool do_time,
-        double TKelvin, double PGas)
+        doublereal TKelvin, doublereal PGas)
     {
         int i, k;
         string nm;
@@ -1363,7 +1363,7 @@ namespace Cantera {
             }
             printf("---------------------------------------------------------------"
                 "---------------------------------------------\n");
-            double *XMolKinSpecies = DATA_PTR(m_numEqn2);
+            doublereal *XMolKinSpecies = DATA_PTR(m_numEqn2);
             kindexSP = 0;
             for (int isp = 0; isp < m_numSurfPhases; isp++) {
                 InterfaceKinetics *m_kin = m_objects[isp];
@@ -1417,7 +1417,7 @@ namespace Cantera {
 
 #ifdef DEBUG_SOLVESP
     void solveSP::
-    printIterationHeader(int ioflag, double damp,double inv_t, double t_real,
+    printIterationHeader(int ioflag, doublereal damp,doublereal inv_t, doublereal t_real,
         int iter, bool do_time)
     {
         if (ioflag > 1) {
diff --git a/Cantera/src/kinetics/solveSP.h b/Cantera/src/kinetics/solveSP.h
index f4d679d3e..d47113175 100644
--- a/Cantera/src/kinetics/solveSP.h
+++ b/Cantera/src/kinetics/solveSP.h
@@ -249,45 +249,45 @@ namespace Cantera {
      *          Note the actual converged solution is returned as part of the
      *          internal state of the InterfaceKinetics objects.
      */
-    int solveSurfProb(int ifunc, double time_scale, double TKelvin, 
-		      double PGas, double reltol, double abstol);
+    int solveSurfProb(int ifunc, doublereal time_scale, doublereal TKelvin, 
+		      doublereal PGas, doublereal reltol, doublereal abstol);
 
   private:
 
     //! Printing routine that gets called at the start of every
     //! invocation
-    void print_header(int ioflag, int ifunc, double time_scale,
-		      int damping, double reltol, double abstol,
-		      double TKelvin, double PGas, double netProdRate[],
-		      double XMolKinSpecies[]);
+    void print_header(int ioflag, int ifunc, doublereal time_scale,
+		      int damping, doublereal reltol, doublereal abstol,
+		      doublereal TKelvin, doublereal PGas, doublereal netProdRate[],
+		      doublereal XMolKinSpecies[]);
 
 #ifdef DEBUG_SOLVESP
 
     void printResJac(int ioflag, int neq, const Array2D &Jac,
-		     double resid[], double wtResid[], double norm);
+		     doublereal resid[], doublereal wtResid[], doublereal norm);
 #endif
 
     //! Printing routine that gets called after every iteration
-    void printIteration(int ioflag, double damp, int label_d, int label_t,
-			double inv_t, double t_real, int iter,
-			double update_norm, double resid_norm,
-			double netProdRate[], double CSolnSP[],
-			double resid[], double XMolSolnSP[],
-			double wtSpecies[], int dim, bool do_time);
+    void printIteration(int ioflag, doublereal damp, int label_d, int label_t,
+			doublereal inv_t, doublereal t_real, int iter,
+			doublereal update_norm, doublereal resid_norm,
+			doublereal netProdRate[], doublereal CSolnSP[],
+			doublereal resid[], doublereal XMolSolnSP[],
+			doublereal wtSpecies[], int dim, bool do_time);
 
 
     //! Print a summary of the solution
     /*!
      *
      */
-    void printFinal(int ioflag, double damp, int label_d, int label_t,
-		    double inv_t, double t_real, int iter,
-		    double update_norm, double resid_norm,
-		    double netProdRateKinSpecies[], const double CSolnSP[],
-		    const double resid[], double XMolSolnSP[], 
-		    const double wtSpecies[], const double wtRes[],
+    void printFinal(int ioflag, doublereal damp, int label_d, int label_t,
+		    doublereal inv_t, doublereal t_real, int iter,
+		    doublereal update_norm, doublereal resid_norm,
+		    doublereal netProdRateKinSpecies[], const doublereal CSolnSP[],
+		    const doublereal resid[], doublereal XMolSolnSP[], 
+		    const doublereal wtSpecies[], const doublereal wtRes[],
 		    int dim, bool do_time,
-		    double TKelvin, double PGas);
+		    doublereal TKelvin, doublereal PGas);
     
     //! Calculate a conservative delta T to use in a pseudo-steady state
     //! algorithm
@@ -320,9 +320,9 @@ namespace Cantera {
      *
      *    @return  Returns the 1. /  delta T to be used on the next step
      */
-    double calc_t(double netProdRateSolnSP[], double XMolSolnSP[],
+    doublereal calc_t(doublereal netProdRateSolnSP[], doublereal XMolSolnSP[],
 		  int *label, int *label_old,
-		  double *label_factor, int ioflag);
+		  doublereal *label_factor, int ioflag);
 
     //! Calculate the solution and residual weights
     /*!
@@ -335,9 +335,9 @@ namespace Cantera {
      *  @param abstol     Absolute error tolerance
      *  @param reltol     Relative error tolerance     
      */
-    void calcWeights(double wtSpecies[], double wtResid[],
-		     const Array2D &Jac, const double CSolnSP[], 
-		     const double abstol, const double reltol);
+    void calcWeights(doublereal wtSpecies[], doublereal wtResid[],
+		     const Array2D &Jac, const doublereal CSolnSP[], 
+		     const doublereal abstol, const doublereal reltol);
 
 #ifdef DEBUG_SOLVESP
     //! Utility routine to print a header for high lvls of debugging
@@ -350,22 +350,22 @@ namespace Cantera {
      *  @param do_time boolean indicating whether time stepping is taking
      *                 place
      */
-    void printIterationHeader(int ioflag, double damp,
-			      double inv_t, double t_real, int iter,
+    void printIterationHeader(int ioflag, doublereal damp,
+			      doublereal inv_t, doublereal t_real, int iter,
 			      bool do_time);
 #endif
 
     /**
      * Update the surface states of the surface phases.
      */
-    void updateState(const double* cSurfSpec);
+    void updateState(const doublereal *cSurfSpec);
 
     //! Update mole fraction vector consisting of unknowns in surface problem 
     /*!
      * @param XMolSolnSP  Vector of mole fractions for the unknowns in the
      *                    surface problem.
      */
-    void updateMFSolnSP(double *XMolSolnSP);
+    void updateMFSolnSP(doublereal * XMolSolnSP);
 
     //! Update the mole fraction vector for a specific kinetic species vector
     //! corresponding to one InterfaceKinetics object
@@ -376,7 +376,7 @@ namespace Cantera {
      *                  phases in the InterfaceKinetics object
      * @param isp       ID of the InterfaceKinetics Object.
      */
-    void updateMFKinSpecies(double *XMolKinSp, int isp);
+    void updateMFKinSpecies(doublereal *XMolKinSp, int isp);
    
 
     //! Update the vector that keeps track of the largest species in each
@@ -385,7 +385,7 @@ namespace Cantera {
      * @param CsolnSP Vector of the current values of the surface concentrations
      *                in all of the surface species.
      */
-    void evalSurfLarge(const double *CSolnSP);
+    void evalSurfLarge(const doublereal *CSolnSP);
      
     //! Main Function evalulation
     /*!
@@ -398,8 +398,8 @@ namespace Cantera {
      *  @param do_time Calculate a time dependent residual
      *  @param deltaT  Delta time for time dependent problem. 
      */
-    void  fun_eval(double* resid, const double *CSolnSP, 
-		   const double *CSolnOldSP,  const bool do_time, const double deltaT);
+    void  fun_eval(doublereal* resid, const doublereal *CSolnSP, 
+		   const doublereal *CSolnOldSP,  const bool do_time, const doublereal deltaT);
 
     //! Main routine that calculates the current residual and Jacobian 
     /*!
@@ -414,10 +414,10 @@ namespace Cantera {
      *  @param do_time Calculate a time dependent residual
      *  @param deltaT  Delta time for time dependent problem. 
      */
-    void resjac_eval(std::vector<double*>& JacCol, double* resid, 
-		     double *CSolnSP, 
-		     const double *CSolnSPOld,  const bool do_time, 
-		     const double deltaT);
+    void resjac_eval(std::vector<doublereal *>& JacCol, doublereal * resid, 
+		     doublereal *CSolnSP, 
+		     const doublereal *CSolnSPOld,  const bool do_time, 
+		     const doublereal deltaT);
     
     //!   Pointer to the manager of the implicit surface chemistry
     //!   problem
@@ -581,10 +581,10 @@ namespace Cantera {
     /*!
      *   units are (kmol/m2)
      */
-    double m_atol;
+    doublereal m_atol;
     
     //! m_rtol is the relative error tolerance.
-    double m_rtol;
+    doublereal m_rtol;
   
     //! maximum value of the time step
     /*!
@@ -669,7 +669,7 @@ namespace Cantera {
      *   The "dim" by "dim" computed Jacobian matrix for the
      *   local Newton's method.
      */
-    std::vector<double *> m_JacCol;
+    std::vector<doublereal *> m_JacCol;
 
     //! Jacobian
     /*!