initial import

Cantera/README.txt

@@ -1,9 +1,11 @@
 
-This directory contains the source for Cantera and its various language interfaces.
+This directory contains the source for Cantera and its various
+language interfaces.
 
-clib    -  the library of C-callable functions used by the Python and Matlab interfaces.
+clib - the library of C-callable functions used by the Python and
+       Matlab interfaces.
 cxx     -  files that are only required for C++ application programs.
 matlab  -  the Cantera Matlab toolbox
 python  -  the Cantera Python package
-src     -  the Cantera kernel
+src     -  the Cantera kernel, used by Cantera in all its forms
 

Cantera/cxx/include/Cantera.h

@@ -0,0 +1,25 @@
+
+#ifndef CANTERA_H_INCL
+#define CANTERA_H_INCL
+
+namespace std{}
+using namespace std;
+
+// definitions
+#include "kernel/ct_defs.h"
+
+// some useful functions
+#include "kernel/global.h"
+
+// the CanteraError exception class
+#include "kernel/ctexceptions.h"
+
+using namespace Cantera;
+
+#endif
+
+
+
+
+
+

Cantera/cxx/include/GRI30.h

@@ -0,0 +1,43 @@
+#ifndef CXX_IDEALGASMIX
+#define CXX_IDEALGASMIX
+
+#include <string>
+
+#include "kernel/IdealGasPhase.h"
+#include "kernel/GRI_30_Kinetics.h"
+#include "kernel/importCTML.h"
+
+namespace Cantera {
+
+    class GRI30 : 
+        public IdealGasPhase, public GRI_30_Kinetics
+    {
+    public:
+        GRI30() : m_ok(false), m_r(0) {
+            m_r = get_XML_File("gri30.xml");
+            m_ok = buildSolutionFromXML(*m_r, "gri30", "phase", this, this);
+            if (!m_ok) throw CanteraError("GRI30",
+                "buildSolutionFromXML returned false");
+        }
+
+
+        virtual ~GRI30() {}
+
+        bool operator!() { return !m_ok;}
+        bool ready() { return m_ok; }
+        friend ostream& operator<<(ostream& s, GRI30& mix) {
+            string r = report(mix, true);
+            s << r;
+            return s;
+        }
+
+    protected:
+        bool m_ok;
+        XML_Node* m_r;
+
+    private:
+    };
+}
+
+
+#endif

Cantera/cxx/include/IdealGasMix.h

@@ -0,0 +1,49 @@
+#ifndef CXX_IDEALGASMIX
+#define CXX_IDEALGASMIX
+
+#include <string>
+
+#include "kernel/IdealGasPhase.h"
+#include "kernel/GasKinetics.h"
+#include "kernel/importCTML.h"
+
+namespace Cantera {
+
+    class IdealGasMix : 
+        public IdealGasPhase, public GasKinetics
+    {
+    public:
+        IdealGasMix(string infile, string id="") : m_ok(false), m_r(0) {
+            
+        m_r = get_XML_File(infile); 
+        if (id == "-") id = "";
+        m_ok = buildSolutionFromXML(*m_r, id, "phase", this, this);
+        if (!m_ok) throw CanteraError("IdealGasMix",
+            "buildSolutionFromXML returned false");
+        }
+
+
+        IdealGasMix(XML_Node& root, string id) : m_ok(false), m_r(0) {
+            m_ok = buildSolutionFromXML(root, id, "phase", this, this);
+        }
+        
+        virtual ~IdealGasMix() {}
+
+        bool operator!() { return !m_ok;}
+        bool ready() { return m_ok; }
+        friend ostream& operator<<(ostream& s, IdealGasMix& mix) {
+            string r = report(mix, true);
+            s << r;
+            return s;
+        }
+
+    protected:
+        bool m_ok;
+        XML_Node* m_r;
+
+    private:
+    };
+}
+
+
+#endif

Cantera/cxx/include/Interface.h

@@ -0,0 +1,47 @@
+#ifndef CXX_INTERFACE
+#define CXX_INTERFACE
+
+#include <string>
+
+#include "kernel/SurfPhase.h"
+#include "kernel/InterfaceKinetics.h"
+#include "kernel/importCTML.h"
+
+namespace Cantera {
+
+    class Interface : 
+        public SurfPhase, public InterfaceKinetics
+    {
+    public:
+        Interface(string infile, string id, vector<ThermoPhase*> phases) 
+            : m_ok(false), m_r(0) {
+
+            m_r = get_XML_File(infile); 
+            if (id == "-") id = "";
+
+            XML_Node* x = get_XML_Node("#"+id, m_r);
+            if (!x)                 
+                throw CanteraError("Interface","error in get_XML_Node");
+
+            importPhase(*x, this);
+            phases.push_back(this);
+            importKinetics(*x, phases, this);
+            m_ok = true;
+        }
+
+
+        virtual ~Interface() {}
+
+        bool operator!() { return !m_ok;}
+        bool ready() { return m_ok; }
+
+    protected:
+        bool m_ok;
+        XML_Node* m_r;
+
+    private:
+    };
+}
+
+
+#endif

Cantera/cxx/include/equilibrium.h

@@ -0,0 +1,9 @@
+/*
+ * header file providing support for chemical equilibrium.
+ */
+#ifndef CT_EQUIL_INCL
+#define CT_EQUIL_INCL
+#include "kernel/ChemEquil.h"
+#endif
+  
+

Cantera/cxx/include/integrators.h

@@ -0,0 +1,6 @@
+#ifndef CT_INTEG_H_INCL
+#define CT_INTEG_H_INCL
+
+#include "kernel/CVode.h"
+
+#endif

Cantera/cxx/include/kinetics.h

@@ -0,0 +1,320 @@
+/**
+ * @file Kinetics.h
+ *
+ * $Author$
+ * $Revision$
+ * $Date$
+ */
+
+// Copyright 2001  California Institute of Technology
+
+/**
+ * @defgroup kineticsGroup Kinetics
+ */
+
+#ifndef CT_KINETICS_H
+#define CT_KINETICS_H
+
+#include "ctexceptions.h"
+//#include "Phase.h"
+#include "ThermoPhase.h"
+
+namespace Cantera {
+
+    class ReactionData;
+
+    /**
+     * Public interface for kinetics managers. This class serves as a
+     * base class to derive 'kinetics managers', which are classes
+     * that manage homogeneous chemistry within one phase.
+     */
+    class Kinetics {
+
+    public:
+
+        // typedefs
+        typedef ThermoPhase thermo_t;
+
+        /// Constructor.
+        Kinetics() : m_ii(0), m_thermo(0), m_index(-1) {}
+        Kinetics(thermo_t* thermo) 
+            : m_ii(0), m_index(-1) {
+            if (thermo) {
+                m_start.push_back(0);
+                m_thermo.push_back(thermo);
+            }
+        }
+
+        /// Destructor. Does nothing.
+        virtual ~Kinetics() {} // delete m_xml; }
+
+        int index(){ return m_index; }
+        void setIndex(int index) { m_index = index; }
+
+        //XML_Node& xml() { return *m_xml; }
+
+        /// Identifies subclass.
+        virtual int type() { return 0; }
+
+        int start(int n) { return m_start[n]; }
+
+        /// Number of reactions
+        int nReactions() const {return m_ii;}
+
+        /// Number of species
+        int nTotalSpecies() const {
+            int n=0, np;
+            np = nPhases();
+            for (int p = 0; p < np; p++) n += thermo(p).nSpecies();
+            return n;
+        }
+
+        /**
+         * Stoichiometric coefficient of species k as a reactant in
+         * reaction i.  
+         */
+        virtual doublereal reactantStoichCoeff(int k, int i) const { 
+            err("reactantStoichCoeff");
+            return -1.0;
+        }
+
+        /**
+         * Stoichiometric coefficient of species k as a product in
+         * reaction i.  
+         */
+        virtual doublereal productStoichCoeff(int k, int i) const { 
+            err("productStoichCoeff");
+            return -1.0;
+        }
+
+
+        /**
+         * Returns a read-only reference to the vector of reactant
+         * index numbers for reaction i.
+         */ 
+        virtual const vector_int& reactants(int i) const { 
+            return m_reactants[i]; 
+        }
+        virtual const vector_int& products(int i) const { 
+            return m_products[i]; 
+        }
+
+        /**
+         * Flag specifying the type of reaction. The legal values and
+         * their meaning are specific to the particular kinetics
+         * manager.
+         */
+        virtual int reactionType(int i) const { 
+            err("reactionType"); 
+            return -1; 
+        }
+
+        /**
+         * @name Reaction Rates Of Progress
+         */
+        //@{
+
+        /**
+         * Forward rates of progress.
+         * Return the forward rates of progress in array fwdROP, which
+         * must be dimensioned at least as large as the total number
+         * of reactions.
+         */
+        virtual void getFwdRatesOfProgress(doublereal* fwdROP) {
+            err("getFwdRatesOfProgress");
+        }
+ 
+        /**
+         * Reverse rates of progress.
+         * Return the reverse rates of progress in array revROP, which
+         * must be dimensioned at least as large as the total number
+         * of reactions.
+         */
+        virtual void getRevRatesOfProgress(doublereal* revROP) {
+            err("getRevRatesOfProgress");
+        } 
+
+        /**
+         * Net rates of progress.  Return the net (forward - reverse)
+         * rates of progress in array netROP, which must be
+         * dimensioned at least as large as the total number of
+         * reactions.
+         */
+        virtual void getNetRatesOfProgress(doublereal* netROP) {
+            err("getNetRatesOfProgress");
+        }
+
+        /**
+         * True if reaction i has been declared to be reversible. If
+         * isReversible(i) is false, then the reverse rate of progress
+         * for reaction i is always zero.
+         */
+        virtual bool isReversible(int i){return false;}
+
+        /**
+         * Species creation rates [kmol/m^3]. Return the species 
+         * creation rates in array cdot, which must be
+         * dimensioned at least as large as the total number of
+         * species.
+         *  
+         */ 
+        virtual void getCreationRates(doublereal* cdot) {
+            err("getCreationRates");
+        }
+
+        /**
+         * Species destruction rates [kmol/m^3]. Return the species 
+         * destruction rates in array ddot, which must be
+         * dimensioned at least as large as the total number of
+         * species.
+         *  
+         */ 
+        virtual void getDestructionRates(doublereal* ddot) {
+            err("getDestructionRates");
+        }
+
+        /**
+         * Species net production rates [kmol/m^3]. Return the species
+         * net production rates (creation - destruction) in array
+         * wdot, which must be dimensioned at least as large as the
+         * total number of species.
+         */ 
+        virtual void getNetProductionRates(doublereal* wdot) {
+            err("getNetProductionRates");
+        }
+
+        /**
+         * Equilibrium constants. Return the equilibrium constants of
+         * the reactions in concentration units in array kc, which
+         * must be dimensioned at least as large as the total number
+         * of reactions.
+         */  
+         virtual void getEquilibriumConstants(doublereal* kc) {
+             err("getEquilibriumConstants");
+         }
+        //@}
+
+
+        /**
+         * @name Reaction Mechanism Construction
+         */
+        //@{
+
+
+        /**
+         * Get the nth Phase object.
+         */
+        //phase_t& phase(int n=0) { return *m_phase[n]; }
+        //const phase_t& phase(int n=0) const { return *m_phase[n]; }
+        int nPhases() const { return m_thermo.size(); }
+        int phaseIndex(string ph) { return m_phaseindex[ph] - 1; }
+
+        /**
+         * Add a phase.
+         */
+        void addPhase(thermo_t& thermo) { 
+            if (m_thermo.size() > 0) {
+                m_start.push_back(m_start.back() 
+                    + m_thermo.back()->nSpecies());
+            }
+            else {
+                m_start.push_back(0);
+            }
+            m_thermo.push_back(&thermo);
+            m_phaseindex[m_thermo.back()->id()] = nPhases();
+        }
+        thermo_t& thermo(int n=0) { return *m_thermo[n]; }
+        const thermo_t& thermo(int n=0) const { return *m_thermo[n]; }
+        thermo_t& phase(int n=0) { return *m_thermo[n]; }
+        const thermo_t& phase(int n=0) const { return *m_thermo[n]; }
+
+        int speciesIndex(int k, int n) {
+            return m_start[n] + k;
+        }
+
+        int speciesIndex(string nm, string ph = "<any>") {
+            int np = m_thermo.size();
+            int k;
+            string id;
+            for (int n = 0; n < np; n++) {
+                id = thermo(n).id();
+                if (ph == id) {
+                    k = thermo(n).speciesIndex(nm);
+                    if (k < 0) return -1;
+                    return k + m_start[n];
+                }
+                else if (ph == "<any>") {
+                    k = thermo(n).speciesIndex(nm);
+                    if (k >= 0) return k + m_start[n];
+                }                    
+            }
+            return -2;
+        }
+
+        /**
+         * Prepare to add reactions.
+         */
+        virtual void init() {err("init");}
+
+        /// Finished adding reactions. Prepare for use.
+        virtual void finalize() {err("finalize");}
+
+        virtual void addReaction(const ReactionData& r) {err("addReaction");}
+
+        virtual string reactionString(int i) const {
+            err("reactionString"); return "<null>";
+        }
+
+
+        virtual const vector<grouplist_t>& reactantGroups(int i)  
+            { err("reactantGroups"); return m_dummygroups; }
+
+        virtual const vector<grouplist_t>& productGroups(int i) 
+            { err("productGroups"); return m_dummygroups; }
+
+        /**
+         * @name Altering Reaction Rates
+         *
+         * These methods alter reaction rates. They are designed
+         * primarily for carrying out sensitivity analysis.
+         */
+        //@{
+
+        /// The current value of the multiplier for reaction i.
+        doublereal multiplier(int i) const {return m_perturb[i];}
+
+        /// Set the multiplier for reaction i to f.
+        void setMultiplier(int i, doublereal f) {m_perturb[i] = f;}
+        
+        //@}
+
+        void incrementRxnCount() { m_ii++; m_perturb.push_back(1.0); }
+
+        virtual bool ready() const {return false;}
+
+    protected:
+
+        int m_ii;
+        vector_fp m_perturb;
+        vector<vector_int> m_reactants;
+        vector<vector_int> m_products;
+        vector<thermo_t*> m_thermo;
+        vector_int  m_start;
+        //        XML_Node* m_xml;
+        map<string, int> m_phaseindex;
+        int m_index;
+
+    private:
+
+        vector<grouplist_t> m_dummygroups;
+        void err(string m) const {
+            throw CanteraError("Kinetics::"+m,"Base class method called.");
+        }
+    };
+
+    typedef Kinetics kinetics_t;
+}
+
+
+
+#endif

Cantera/cxx/include/numerics.h

@@ -0,0 +1,7 @@
+#ifndef CT_NUM_H_INCL
+#define CT_NUM_H_INCL
+
+#include "kernel/DenseMatrix.h"
+#include "kernel/BandMatrix.h"
+
+#endif

Cantera/cxx/include/onedim.h

@@ -0,0 +1,11 @@
+#ifndef CT_INCL_ONEDIM_H
+#define CT_INCL_ONEDIM_H
+
+#include "kernel/oneD/Sim1D.h"
+#include "kernel/oneD/OneDim.h"
+#include "kernel/oneD/Domain1D.h"
+#include "kernel/oneD/Inlet1D.h"
+#include "kernel/oneD/MultiNewton.h"
+#include "kernel/oneD/MultiJac.h"
+#endif
+

Cantera/cxx/include/reactionpaths.h

@@ -0,0 +1,6 @@
+#ifndef CT_RXNPATHS_H
+#define CT_RXNPATHS_H
+
+#include "kernel/ReactionPath.h"
+
+#endif

Cantera/cxx/include/surface.h

@@ -0,0 +1,7 @@
+#ifndef CT_SURFACE_INCL
+#define CT_SURFACE_INCL
+
+#include "SurfPhase.h"
+#include "InterfaceKinetics.h"
+
+#endif

Cantera/cxx/include/transport.h

@@ -0,0 +1,6 @@
+#ifndef CT_TRANSPORT_INCL
+#define CT_TRANSPORT_INCL
+
+#include "kernel/transport/TransportFactory.h"
+#include "kernel/transport/DustyGasTransport.h"
+#endif

Cantera/cxx/include/zerodim.h

@@ -0,0 +1,9 @@
+#ifndef CT_INCL_ZERODIM_H
+#define CT_INCL_ZERODIM_H
+
+#include "kernel/zeroD/Reactor.h"
+#include "kernel/zeroD/Reservoir.h"
+#include "kernel/zeroD/Wall.h"
+#include "kernel/zeroD/flowControllers.h"
+#endif
+

Cantera/src/Makefile.in

@@ -112,16 +112,6 @@ DEPENDS = $(EVERYTHING:.o=.d)
 	@CXX@ -c $< $(CXX_FLAGS) 
 #$(CXX_INCLUDES)
 
-# these depend on Makefile to insure that they get rebuilt whenever
-# 'configure' has been run since they were last compiled
-#misc.o: misc.cpp Makefile
-#	echo '#define CANTERA_ROOT "@prefix@/cantera"' > ctdir.h
-#	@CXX@ -c misc.cpp $(CXX_FLAGS) 
-
-#ct2ctml.o: ct2ctml.cpp Makefile
-#	echo '#define PYTHON_EXE "@PYTHON_CMD@"' > pypath.h
-#	@CXX@ -c ct2ctml.cpp $(CXX_FLAGS) 
-
 .f.o:
 	@F77@ -c $< $(F77_FLAGS) 
 

Cantera/src/ct2ctml.cpp

@@ -83,7 +83,7 @@ namespace ctml {
         string path = tmpDir()+"/.cttmp.py";
         ofstream f(path.c_str());
         if (!f) {
-            throw CanteraError("ct2ctml","cannot write to "+tmpDir());
+            throw CanteraError("ct2ctml","cannot open "+path+" for writing.");
         }
         f << "from Cantera import *\n"
           << "from Cantera.ctml_writer import *\n"
@@ -96,7 +96,6 @@ namespace ctml {
           << "write()\n";
         f.close();
 #ifdef WIN32
-        //string cmd = "cmd /C "+pypath() + " " + path + ">> ct2ctml.log 2>&1";
         string cmd = pypath() + " " + path + ">> ct2ctml.log 2>&1";
 #else
         string cmd = pypath() + " " + path + " &> ct2ctml.log";
@@ -108,8 +107,7 @@ namespace ctml {
         catch (...) {
             ierr = -10;
         }
-        //char line[90];
-        //if (ierr != 0) {
+
         try {
             char ch=0;
             string s = "";