From ff9584105bd72155a34929f613521fbd8eb2bbca Mon Sep 17 00:00:00 2001
From: Ray Speth <speth@mit.edu>
Date: Thu, 30 Jan 2014 00:47:37 +0000
Subject: [PATCH] Do implicit CTI to XML conversions without generating .xml
 files

When instantiating a phase from a .cti file, do the conversion in memory,
without writing the XML representation to disk. This eliminates the unrequrested
XML files that Cantera normally generates, and also avoids errors when running
Cantera from a directory where the user does not have write permissons.
---
 include/cantera/base/ctml.h              |   9 ++
 interfaces/cython/cantera/ctml_writer.py |  15 ++-
 src/base/application.cpp                 |  11 ++-
 src/base/ct2ctml.cpp                     | 116 ++++++++++++++---------
 test/SConscript                          |  37 ++++----
 test/matlab/testImport.m                 |   1 -
 test/thermo/phaseConstructors.cpp        |  35 +++++++
 test_problems/SConscript                 |   7 +-
 8 files changed, 156 insertions(+), 75 deletions(-)

diff --git a/include/cantera/base/ctml.h b/include/cantera/base/ctml.h
index f0293d217..c45a98011 100644
--- a/include/cantera/base/ctml.h
+++ b/include/cantera/base/ctml.h
@@ -818,6 +818,15 @@ Cantera::XML_Node getCtmlTree(const std::string& file);
  */
 void ct2ctml(const char* file, const int debug = 0);
 
+//! Get a string with the ctml representation of a cti file.
+/*!
+ *  @param   file    Path to the input file in CTI format
+ *  @return  String containing the xml representation of the input file
+ *
+ *  @ingroup inputfiles
+ */
+std::string ct2ctml_string(const std::string& file);
+
 //! Convert a Chemkin-format mechanism into a CTI file.
 /*!
  * @param in_file         input file containing species and reactions
diff --git a/interfaces/cython/cantera/ctml_writer.py b/interfaces/cython/cantera/ctml_writer.py
index afa6e6b94..245f759e9 100644
--- a/interfaces/cython/cantera/ctml_writer.py
+++ b/interfaces/cython/cantera/ctml_writer.py
@@ -18,6 +18,8 @@
 
 from __future__ import print_function
 
+import sys
+
 class CTI_Error(Exception):
     """Exception raised if an error is encountered while
     parsing the input file.
@@ -130,8 +132,11 @@ class XMLnode(object):
         s = ['<?xml version="1.0"?>\n']
         self._write(s, 0)
         s.append('\n')
-        with open(filename, 'w') as f:
-            f.write(''.join(s))
+        if isinstance(filename, str):
+            with open(filename, 'w') as f:
+                f.write(''.join(s))
+        else:
+            filename.write(''.join(s))
 
     def write_comment(self, s, level):
         s.append('\n'+indent[level]+'<!--')
@@ -332,7 +337,9 @@ def write(outName=None):
     for rx in _reactions:
         rx.build(r)
 
-    if outName is not None:
+    if outName == 'STDOUT':
+        x.write(sys.stdout)
+    elif outName is not None:
         x.write(outName)
     elif _name != 'noname':
         x.write(_name+'.xml')
@@ -2583,7 +2590,7 @@ class Lindemann(object):
 validate()
 
 def convert(filename, outName=None):
-    import os, sys
+    import os
     base = os.path.basename(filename)
     root, _ = os.path.splitext(base)
     dataset(root)
diff --git a/src/base/application.cpp b/src/base/application.cpp
index 42373976f..47ceb2f6d 100644
--- a/src/base/application.cpp
+++ b/src/base/application.cpp
@@ -281,10 +281,15 @@ XML_Node* Application::get_XML_File(const std::string& file, int debug)
                 return xmlfiles[ff];
             }
             /*
-             * Ok, we didn't find the processed XML tree. Do the conversion
-             * to xml, possibly overwriting the file, ff, in the process.
+             * Ok, we didn't find the processed XML tree. Do the conversion from cti
              */
-            ctml::ct2ctml(path.c_str(),debug);
+            string phase_xml = ctml::ct2ctml_string(path);
+            XML_Node* x = new XML_Node("doc");
+            std::stringstream s(phase_xml);
+            x->build(s);
+            x->lock();
+            xmlfiles[ff] = x;
+            return x;
         } else {
             ff = path;
         }
diff --git a/src/base/ct2ctml.cpp b/src/base/ct2ctml.cpp
index a3519d250..12def26b7 100644
--- a/src/base/ct2ctml.cpp
+++ b/src/base/ct2ctml.cpp
@@ -52,53 +52,84 @@ static string pypath()
 }
 
 void ct2ctml(const char* file, const int debug)
+{
+    string xml = ct2ctml_string(file);
+    string out_name = file;
+#ifdef _WIN32
+    // For Windows, make the path POSIX compliant so code looking for directory
+    // separators is simpler.  Just look for '/' not both '/' and '\\'
+    std::replace_if(out_name.begin(), out_name.end(),
+                    std::bind2nd(std::equal_to<char>(), '\\'), '/') ;
+#endif
+    size_t idir = out_name.rfind('/');
+    if (idir != npos) {
+        out_name = out_name.substr(idir+1, out_name.size());
+    }
+    size_t idot = out_name.rfind('.');
+    if (idot != npos) {
+        out_name = out_name.substr(0, idot) + ".xml";
+    } else {
+        out_name += ".xml";
+    }
+    std::ofstream out(out_name.c_str());
+    out << xml;
+}
+
+std::string ct2ctml_string(const std::string& file)
 {
 #ifdef HAS_NO_PYTHON
     /*
      *  Section to bomb out if python is not
      *  present in the computation environment.
      */
-    string ppath = file;
     throw CanteraError("ct2ctml",
-                       "python cti to ctml conversion requested for file, " + ppath +
+                       "python cti to ctml conversion requested for file, " + file +
                        ", but not available in this computational environment");
 #endif
 
-    string python_output;
+    string python_output, error_output;
     int python_exit_code;
     try {
         exec_stream_t python;
         python.set_wait_timeout(exec_stream_t::s_all, 1800000); // 30 minutes
-        python.start(pypath(), "-i");
-        stringstream output_stream;
-        python.in() <<
-                    "if True:\n" << // Use this so that the rest is a single block
-                    "    import sys\n" <<
-                    "    sys.stderr = sys.stdout\n" <<
-                    "    try:\n" <<
-                    "        from cantera import ctml_writer\n" <<
-                    "    except ImportError:\n" <<
-                    "        print('sys.path: ' + repr(sys.path) + '\\n')\n" <<
-                    "        raise\n" <<
-                    "    ctml_writer.convert(r'" << file << "')\n" <<
-                    "    sys.exit(0)\n\n" <<
-                    "sys.exit(7)\n";
-        python.close_in();
+        stringstream output_stream, error_stream;
+        std::vector<string> args;
+        args.push_back("-c");
+        args.push_back(
+                    "from __future__ import print_function\n"
+                    "import sys\n"
+                    "try:\n"
+                    "    from cantera import ctml_writer\n"
+                    "except ImportError:\n"
+                    "    print('sys.path: ' + repr(sys.path) + '\\n', file=sys.stderr)\n"
+                    "    raise\n"
+                    "ctml_writer.convert(r'" + file + "', 'STDOUT')\n"
+                    "sys.exit(0)\n");
+
+        python.start(pypath(), args.begin(), args.end());
         std::string line;
-        while (python.out().good()) {
-            std::getline(python.out(), line);
-            output_stream << line << std::endl;;
+        while (true) {
+            if (python.out().good()) {
+                std::getline(python.out(), line);
+                output_stream << line << std::endl;
+            } else if (python.err().good()) {
+                std::getline(python.err(), line);
+                error_stream << line << std::endl;
+            } else {
+                break;
+            }
         }
         python.close();
         python_exit_code = python.exit_code();
-        python_output = stripws(output_stream.str());
+        error_output = stripws(error_stream.str());
+        python_output = output_stream.str();
     } catch (std::exception& err) {
         // Report failure to execute Python
         stringstream message;
         message << "Error executing python while converting input file:\n";
         message << "Python command was: '" << pypath() << "'\n";
         message << err.what() << std::endl;
-        throw CanteraError("ct2ctml", message.str());
+        throw CanteraError("ct2ctml_string", message.str());
     }
 
     if (python_exit_code != 0) {
@@ -107,27 +138,29 @@ void ct2ctml(const char* file, const int debug)
         message << "Error converting input file \"" << file << "\" to CTML.\n";
         message << "Python command was: '" << pypath() << "'\n";
         message << "The exit code was: " << python_exit_code << "\n";
-        if (python_output.size() > 0) {
+        if (error_output.size() > 0) {
             message << "-------------- start of converter log --------------\n";
-            message << python_output << std::endl;
+            message << error_output << std::endl;
             message << "--------------- end of converter log ---------------";
         } else {
             message << "The command did not produce any output." << endl;
         }
-        throw CanteraError("ct2ctml", message.str());
+        throw CanteraError("ct2ctml_string", message.str());
     }
 
-    if (python_output.size() > 0) {
+    if (error_output.size() > 0) {
         // Warn if there was any output from the conversion process
         stringstream message;
         message << "Warning: Unexpected output from CTI converter\n";
         message << "-------------- start of converter log --------------\n";
-        message << python_output << std::endl;
+        message << error_output << std::endl;
         message << "--------------- end of converter log ---------------\n";
         writelog(message.str());
     }
+    return python_output;
 }
 
+
 void ck2cti(const std::string& in_file, const std::string& thermo_file,
             const std::string& transport_file, const std::string& id_tag)
 {
@@ -219,7 +252,7 @@ void ck2cti(const std::string& in_file, const std::string& thermo_file,
 
 void get_CTML_Tree(Cantera::XML_Node* rootPtr, const std::string& file, const int debug)
 {
-    std::string ff, ext = "";
+    std::string ext = "";
 
     // find the input file on the Cantera search path
     std::string inname = findInputFile(file);
@@ -238,27 +271,18 @@ void get_CTML_Tree(Cantera::XML_Node* rootPtr, const std::string& file, const in
         ext = inname.substr(idot, inname.size());
     }
     if (ext != ".xml" && ext != ".ctml") {
-        try {
-            ctml::ct2ctml(inname.c_str(), debug);
-        } catch (std::exception& err) {
-            writelog("get_CTML_Tree: caught an exception:\n");
-            writelog(err.what());
-        }
-        string ffull = inname.substr(0,idot) + ".xml";
-        ff = "./" + getBaseName(ffull) + ".xml";
-        if (debug > 0) {
-            writelogf("ffull name = %s\n", ffull.c_str());
-            writelogf("ff name = %s\n", ff.c_str());
-        }
-    } else {
-        ff = inname;
+        string phase_xml = ctml::ct2ctml_string(inname);
+        stringstream s(phase_xml);
+        rootPtr->build(s);
+        return;
     }
-    writelog("Attempting to parse xml file " + ff + "\n", debug);
-    ifstream fin(ff.c_str());
+
+    writelog("Attempting to parse xml file " + inname + "\n", debug);
+    ifstream fin(inname.c_str());
     if (!fin) {
         throw
         CanteraError("get_CTML_Tree",
-                     "XML file " + ff + " not found");
+                     "XML file " + inname + " not found");
     }
     rootPtr->build(fin);
     fin.close();
diff --git a/test/SConscript b/test/SConscript
index 4c8c918e4..2cc5df74b 100644
--- a/test/SConscript
+++ b/test/SConscript
@@ -35,23 +35,25 @@ def testRunner(target, source, env):
         testResults.failed[passedFile.name] = program
 
 
-def addTestProgram(subdir, progName):
+def addTestProgram(subdir, progName, env_vars={}):
     """
     Compile a test program and create a targets for running
     and resetting the test.
     """
-    program = localenv.Program(pjoin(subdir, progName),
-                               mglob(localenv, subdir, 'cpp'))
+    testenv = localenv.Clone()
+    testenv['ENV'].update(env_vars)
+    program = testenv.Program(pjoin(subdir, progName),
+                              mglob(testenv, subdir, 'cpp'))
     passedFile = File(pjoin(str(program[0].dir), '%s.passed' % program[0].name))
     PASSED_FILES[progName] = str(passedFile)
     testResults.tests[passedFile.name] = program
-    run_program = localenv.Command(passedFile, program, testRunner)
+    run_program = testenv.Command(passedFile, program, testRunner)
     Alias('test', run_program)
     Alias('test-%s' % progName, run_program)
     env['testNames'].append(progName)
     if os.path.exists(passedFile.abspath):
-        Alias('test-reset', localenv.Command('reset-%s%s' % (subdir, progName),
-                                             [], [Delete(passedFile.abspath)]))
+        Alias('test-reset', testenv.Command('reset-%s%s' % (subdir, progName),
+                                            [], [Delete(passedFile.abspath)]))
 
 
 def addPythonTest(testname, subdir, script, interpreter, outfile,
@@ -156,8 +158,18 @@ def addMatlabTest(script, testName, dependencies=None, env_vars=()):
 
     return run_program
 
+if localenv['python_package'] in ('full', 'minimal'):
+    python_env_vars = {'PYTHONPATH': Dir('#build/python2').abspath,
+                       'PYTHON_CMD': localenv.subst('$python_cmd')}
+elif localenv['python3_package'] == 'y':
+    python_env_vars = {'PYTHONPATH': Dir('#build/python3').abspath,
+                       'PYTHON_CMD': localenv.subst('$python3_cmd')}
+else:
+    python_env_vars = {} # Tests calling ck2cti or ctml_writer will fail
+
+
 # Instantiate tests
-addTestProgram('thermo', 'thermo')
+addTestProgram('thermo', 'thermo', env_vars=python_env_vars)
 addTestProgram('kinetics', 'kinetics')
 
 python_subtests = ['']
@@ -191,18 +203,9 @@ if localenv['python3_package'] == 'y':
     make_python_tests(3)
 
 if localenv['matlab_toolbox'] == 'y':
-    if localenv['python_package'] in ('full', 'minimal'):
-        env_vars = {'PYTHONPATH': Dir('#build/python2').abspath,
-                    'PYTHON_CMD': localenv.subst('$python_cmd')}
-    elif localenv['python3_package'] == 'y':
-        env_vars = {'PYTHONPATH': Dir('#build/python3').abspath,
-                    'PYTHON_CMD': localenv.subst('$python3_cmd')}
-    else:
-        env_vars = {} # ck2cti test is likely to fail
-
     matlabTest = addMatlabTest('runCanteraTests.m', 'matlab',
                                dependencies=mglob(localenv, 'matlab', 'm'),
-			       env_vars=env_vars)
+			       env_vars=python_env_vars)
     localenv.Alias('test-matlab', matlabTest)
     env['testNames'].append('matlab')
 
diff --git a/test/matlab/testImport.m b/test/matlab/testImport.m
index 348efe101..d41bbc8a1 100644
--- a/test/matlab/testImport.m
+++ b/test/matlab/testImport.m
@@ -9,4 +9,3 @@ assertEqual(length(dkm), nSpecies(gas))
 function testImportCTI
 gas = importPhase('h2o2.cti');
 assertEqual(temperature(gas), 300)
-delete('h2o2.xml');
diff --git a/test/thermo/phaseConstructors.cpp b/test/thermo/phaseConstructors.cpp
index f8dffc94b..7cb2991bf 100644
--- a/test/thermo/phaseConstructors.cpp
+++ b/test/thermo/phaseConstructors.cpp
@@ -1,6 +1,7 @@
 #include "gtest/gtest.h"
 #include "cantera/thermo/FixedChemPotSSTP.h"
 #include "cantera/thermo/ThermoFactory.h"
+#include "cantera/base/ctml.h"
 
 namespace Cantera
 {
@@ -28,4 +29,38 @@ TEST_F(FixedChemPotSstpConstructorTest, SimpleConstructor)
     ASSERT_FLOAT_EQ(-2.3e7, mu);
 }
 
+#ifndef HAS_NO_PYTHON // skip these tests if the Python converter is unavailable
+class InputFileConversionTest : public testing::Test
+{
+public:
+    InputFileConversionTest() {
+        appdelete();
+    }
+
+    ThermoPhase* p1;
+    ThermoPhase* p2;
+    void compare()
+    {
+        ASSERT_EQ(p1->nSpecies(), p2->nSpecies());
+        for (size_t i = 0; i < p1->nSpecies(); i++) {
+            ASSERT_EQ(p1->speciesName(i), p2->speciesName(i));
+            ASSERT_EQ(p1->molecularWeight(i), p2->molecularWeight(i));
+        }
+    }
+};
+
+TEST_F(InputFileConversionTest, ExplicitConversion) {
+    p1 = newPhase("../data/air-no-reactions.xml", "");
+    ctml::ct2ctml("../data/air-no-reactions.cti");
+    p2 = newPhase("air-no-reactions.xml", "");
+    compare();
+}
+
+TEST_F(InputFileConversionTest, ImplicitConversion) {
+    p1 = newPhase("../data/air-no-reactions.xml", "");
+    p2 = newPhase("../data/air-no-reactions.cti", "");
+    compare();
+}
+#endif
+
 } // namespace Cantera
diff --git a/test_problems/SConscript b/test_problems/SConscript
index ee83aeccb..b50df5899 100644
--- a/test_problems/SConscript
+++ b/test_problems/SConscript
@@ -279,8 +279,7 @@ CompileAndTest('pecosTransport', 'PecosTransport', 'pecosTransport', 'output_ble
 CompileAndTest('printUtil', 'printUtilUnitTest', 'pUtest', 'output_blessed.txt')
 CompileAndTest('pureFluid', 'pureFluidTest', 'testPureWater', 'output_blessed.txt')
 if haveConverters:
-    CompileAndTest('rankine_democxx', 'rankine_democxx', 'rankine', 'output_blessed.txt',
-                   artifacts=['liquidvapor.xml'])
+    CompileAndTest('rankine_democxx', 'rankine_democxx', 'rankine', 'output_blessed.txt')
 CompileAndTest('silane_equil', 'silane_equil', 'silane_equi', 'output_blessed.txt')
 # spectroscopy is incomplete
 CompileAndTest('simpleTransport', 'simpleTransport', 'simpleTransport',
@@ -291,12 +290,12 @@ CompileAndTest('surfkin', 'surfkin', 'surfdemo', 'output_blessed.txt')
 CompileAndTest('surfSolver', 'surfSolverTest', 'surfaceSolver', None,
                arguments='haca2.xml',
                comparisons=[('results_blessed.txt', 'results.txt')],
-               artifacts=['results.txt', 'diamond.xml'],
+               artifacts=['results.txt'],
                extensions=['^surfaceSolver.cpp'])
 CompileAndTest('surfSolver2', 'surfSolverTest', 'surfaceSolver2', None,
                arguments='haca2.xml',
                comparisons=[('results2_blessed.txt', 'results2.txt')],
-               artifacts=['results2.txt', 'diamond.xml'],
+               artifacts=['results2.txt'],
                extensions=['^surfaceSolver2.cpp'])
 CompileAndTest('VCS-NaCl', pjoin('VCSnonideal', 'NaCl_equil'),
                'nacl_equil', 'good_out.txt',