void addModuleSearchPath(const std::string& path)
{
std::string pathString("path");
auto syspath = PySys_GetObject(&pathString[0]); // Borrowed reference
PythonObject pypath(PythonObject::owning {},
PyString_FromString(path.c_str()));
if (!pypath) {
throw WrappyError("Wrappy: Can't allocate memory for string.");
}
auto pos = PyList_Insert(syspath, 0, pypath.get());
if (pos < 0) {
throw WrappyError("Wrappy: Couldn't add " + path + " to sys.path");
}
}
static std::string call_ctml_writer(const std::string& text, bool isfile)
{
std::string file, arg;
if (isfile) {
file = text;
arg = "r'" + text + "'";
} else {
file = "<string>";
arg = "text=r'''" + text + "'''";
}
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
stringstream output_stream, error_stream;
python.start(pypath(), "");
ostream& pyin = python.in();
pyin << "from __future__ import print_function\n"
"if True:\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(";
pyin << arg << ", outName='STDOUT')\n";
pyin << " sys.exit(0)\n\n";
pyin << "sys.exit(7)\n";
python.close_in();
std::string line;
while (python.out().good()) {
std::getline(python.out(), line);
output_stream << line << std::endl;
}
#ifdef _WIN32
// Sleeping for 1 ms prevents a (somewhat inexplicable) deadlock while
// reading from the stream.
Sleep(1);
#endif
while (python.err().good()) {
std::getline(python.err(), line);
error_stream << line << std::endl;
}
python.close();
python_exit_code = python.exit_code();
error_output = trimCopy(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_string", message.str());
}
if (python_exit_code != 0) {
// Report a failure in the conversion process
stringstream message;
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 (error_output.size() > 0) {
message << "-------------- start of converter log --------------\n";
message << error_output << std::endl;
message << "--------------- end of converter log ---------------";
} else {
message << "The command did not produce any output." << endl;
}
throw CanteraError("ct2ctml_string", message.str());
}
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 << 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)
{
string python_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;
ostream& pyin = python.in();
pyin << "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 ck2cti\n" <<
" except ImportError:\n" <<
" print('sys.path: ' + repr(sys.path))\n" <<
" raise\n"
" ck2cti.Parser().convertMech(r'" << in_file << "',";
if (thermo_file != "" && thermo_file != "-") {
pyin << " thermoFile=r'" << thermo_file << "',";
}
if (transport_file != "" && transport_file != "-") {
pyin << " transportFile=r'" << transport_file << "',";
}
pyin << " phaseName='" << id_tag << "',";
pyin << " permissive=True,";
pyin << " quiet=True)\n";
pyin << " sys.exit(0)\n\n";
pyin << "sys.exit(7)\n";
python.close_in();
std::string line;
while (python.out().good()) {
std::getline(python.out(), line);
output_stream << line << std::endl;;
}
python.close();
python_exit_code = python.exit_code();
python_output = trimCopy(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());
}
if (python_exit_code != 0) {
// Report a failure in the conversion process
stringstream message;
message << "Error converting input file \"" << in_file << "\" to CTI.\n";
message << "Python command was: '" << pypath() << "'\n";
message << "The exit code was: " << python_exit_code << "\n";
if (python_output.size() > 0) {
message << "-------------- start of converter log --------------\n";
message << python_output << std::endl;
message << "--------------- end of converter log ---------------";
} else {
message << "The command did not produce any output." << endl;
}
throw CanteraError("ck2cti", message.str());
}
if (python_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 << "--------------- end of converter log ---------------\n";
writelog(message.str());
}
}
/*
*
* @param file Pointer to the file
* @param debug Turn on debug printing
*
* @ingroup inputfiles
*/
void ct2ctml(const char* file, const int debug) {
#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 +
", but not available in this computational environment");
#endif
time_t aclock;
time( &aclock );
int ia = static_cast<int>(aclock);
string path = tmpDir()+"/.cttmp"+int2str(ia)+".pyw";
ofstream f(path.c_str());
if (!f) {
throw CanteraError("ct2ctml","cannot open "+path+" for writing.");
}
f << "from ctml_writer import *\n"
<< "import sys, os, os.path\n"
<< "file = \"" << file << "\"\n"
<< "base = os.path.basename(file)\n"
<< "root, ext = os.path.splitext(base)\n"
<< "dataset(root)\n"
<< "execfile(file)\n"
<< "write()\n";
f.close();
string logfile = tmpDir()+"/ct2ctml.log";
#ifdef _WIN32
string cmd = pypath() + " " + "\"" + path + "\"" + "> " + logfile + " 2>&1";
#else
string cmd = "sleep " + sleep() + "; " + "\"" + pypath() + "\"" +
" " + "\"" + path + "\"" + " &> " + logfile;
#endif
#ifdef DEBUG_PATHS
writelog("ct2ctml: executing the command " + cmd + "\n");
#endif
if (debug > 0) {
writelog("ct2ctml: executing the command " + cmd + "\n");
writelog("ct2ctml: the Python command is: " + pypath() + "\n");
}
int ierr = 0;
try {
ierr = system(cmd.c_str());
}
catch (...) {
ierr = -10;
if (debug > 0) {
writelog("ct2ctml: command execution failed.\n");
}
}
/*
* This next section may seem a bit weird. However, it is in
* response to an issue that arises when running cantera with
* cygwin, using cygwin's python intepreter. Basically, the
* xml file is written to the local directory by the last
* system command. Then, the xml file is read immediately
* after by an ifstream() c++ command. Unfortunately, it seems
* that the directory info is not being synched fast enough so
* that the ifstream() read fails, even though the file is
* actually there. Putting in a sleep system call here fixes
* this problem. Also, having the xml file pre-existing fixes
* the problem as well. There may be more direct ways to fix
* this bug; however, I am not aware of them.
* HKM -> During the solaris port, I found the same thing.
* It probably has to do with NFS syncing problems.
* 3/3/06
*/
#ifndef _WIN32
string sss = sleep();
if (debug > 0) {
writelog("sleeping for " + sss + " secs+\n");
}
cmd = "sleep " + sss;
try {
ierr = system(cmd.c_str());
}
catch (...) {
ierr = -10;
writelog("ct2ctml: command execution failed.\n");
}
#else
// This command works on windows machines if Windows.h and Winbase.h are included
// Sleep(5000);
#endif
// show the contents of the log file on the screen
try {
char ch=0;
string s = "";
ifstream ferr("ct2ctml.log");
if (ferr) {
while (!ferr.eof()) {
ferr.get(ch);
s += ch;
if (ch == '\n') {
writelog(s);
s = "";
}
}
ferr.close();
}
else {
if (debug > 0) {
writelog("cannot open ct2ctml.log for reading.\n");
}
}
}
catch (...) {
writelog("ct2ctml: caught something \n");;
}
if (ierr != 0) {
string msg = cmd;
writelog("ct2ctml: throw cantera error \n");;
throw CanteraError("ct2ctml",
"could not convert input file to CTML.\n "
"Command line was: \n" + msg);
}
// if the conversion succeeded and DEBUG_PATHS is not defined,
// then clean up by deleting the temporary Python file.
#ifndef DEBUG_PATHS
//#ifdef _WIN32
//cmd = "cmd /C rm " + path;
if (debug == 0)
remove(path.c_str());
else {
writelog("ct2ctml: retaining temporary file "+path+"\n");
}
#else
if (debug > 0) {
writelog("ct2ctml: retaining temporary file "+path+"\n");
}
#endif
}
void ct2ctml(const char* file, const int debug)
{
#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 +
", but not available in this computational environment");
#endif
string python_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" <<
" import ctml_writer\n" <<
" ctml_writer.convert(r'" << file << "')\n" <<
" sys.exit(0)\n\n"
"sys.exit(7)\n";
python.close_in();
std::string line;
while (python.out().good()) {
std::getline(python.out(), line);
output_stream << line << std::endl;;
}
python.close();
python_exit_code = python.exit_code();
python_output = stripws(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());
}
if (python_exit_code != 0) {
// Report a failure in the conversion process
stringstream message;
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) {
message << "-------------- start of converter log --------------\n";
message << python_output << std::endl;
message << "--------------- end of converter log ---------------";
} else {
message << "The command did not produce any output." << endl;
}
throw CanteraError("ct2ctml", message.str());
}
if (python_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 << "--------------- end of converter log ---------------\n";
writelog(message.str());
}
}