research/cantera
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Rename two-argument version of writelog 'debuglog'

Browse source 
This is a prerequisite to allowing writelog to take an arbitrary number
of arguments.
This commit is contained in:
Ray Speth 2015-09-06 22:45:17 -04:00
parent 0daf89c7d3
commit 41527b1ea7
10 changed files with 37 additions and 37 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
include/cantera/base/global.h
View file

@ -147,7 +147,7 @@ std::string canteraRoot();
void writelog(const std::string& msg); void writelog(const std::string& msg);
//! Write a message to the log only if loglevel > 0 //! Write a message to the log only if loglevel > 0
inline void writelog(const std::string& msg, int loglevel) inline void debuglog(const std::string& msg, int loglevel)
{ {
if (loglevel > 0) { if (loglevel > 0) {
writelog(msg); writelog(msg);

2
src/equil/ChemEquil.cpp
View file

@ -1410,7 +1410,7 @@ int ChemEquil::estimateEP_Brinkley(thermo_t& s, vector_fp& x,
} catch (CanteraError& err) { } catch (CanteraError& err) {
err.save(); err.save();
if (DEBUG_MODE_ENABLED) { if (DEBUG_MODE_ENABLED) {
writelog("Matrix is SINGULAR.ERROR\n", ChemEquil_print_lvl); debuglog("Matrix is SINGULAR.ERROR\n", ChemEquil_print_lvl);
} }
s.restoreState(state); s.restoreState(state);
throw CanteraError("equilibrate:estimateEP_Brinkley()", throw CanteraError("equilibrate:estimateEP_Brinkley()",

16
src/equil/MultiPhase.cpp
View file

@ -745,7 +745,7 @@ void MultiPhase::equilibrate(const std::string& XY, const std::string& solver,
int ixy = _equilflag(XY.c_str()); int ixy = _equilflag(XY.c_str());
if (solver == "auto" || solver == "vcs") { if (solver == "auto" || solver == "vcs") {
try { try {
writelog("Trying VCS equilibrium solver\n", log_level); debuglog("Trying VCS equilibrium solver\n", log_level);
vcs_MultiPhaseEquil eqsolve(this, log_level-1); vcs_MultiPhaseEquil eqsolve(this, log_level-1);
int ret = eqsolve.equilibrate(ixy, estimate_equil, log_level-1, int ret = eqsolve.equilibrate(ixy, estimate_equil, log_level-1,
rtol, max_steps); rtol, max_steps);
@ -753,11 +753,11 @@ void MultiPhase::equilibrate(const std::string& XY, const std::string& solver,
throw CanteraError("MultiPhase::equilibrate", throw CanteraError("MultiPhase::equilibrate",
"VCS solver failed. Return code: " + int2str(ret)); "VCS solver failed. Return code: " + int2str(ret));
} }
writelog("VCS solver succeeded\n", log_level); debuglog("VCS solver succeeded\n", log_level);
return; return;
} catch (std::exception& err) { } catch (std::exception& err) {
writelog("VCS solver failed.\n", log_level); debuglog("VCS solver failed.\n", log_level);
writelog(err.what(), log_level); debuglog(err.what(), log_level);
m_moleFractions = initial_moleFractions; m_moleFractions = initial_moleFractions;
m_moles = initial_moles; m_moles = initial_moles;
m_temp = initial_T; m_temp = initial_T;
@ -772,15 +772,15 @@ void MultiPhase::equilibrate(const std::string& XY, const std::string& solver,
if (solver == "auto" || solver == "gibbs") { if (solver == "auto" || solver == "gibbs") {
try { try {
writelog("Trying MultiPhaseEquil (Gibbs) equilibrium solver\n", debuglog("Trying MultiPhaseEquil (Gibbs) equilibrium solver\n",
log_level); log_level);
equilibrate_MultiPhaseEquil(ixy, rtol, max_steps, max_iter, equilibrate_MultiPhaseEquil(ixy, rtol, max_steps, max_iter,
log_level-1); log_level-1);
writelog("MultiPhaseEquil solver succeeded\n", log_level); debuglog("MultiPhaseEquil solver succeeded\n", log_level);
return; return;
} catch (std::exception& err) { } catch (std::exception& err) {
writelog("MultiPhaseEquil solver failed.\n", log_level); debuglog("MultiPhaseEquil solver failed.\n", log_level);
writelog(err.what(), log_level); debuglog(err.what(), log_level);
m_moleFractions = initial_moleFractions; m_moleFractions = initial_moleFractions;
m_moles = initial_moles; m_moles = initial_moles;
m_temp = initial_T; m_temp = initial_T;

6
src/oneD/MultiNewton.cpp
View file

@ -253,7 +253,7 @@ int MultiNewton::dampStep(const doublereal* x0, const doublereal* step0,
// this case, the Newton algorithm fails, so return an error // this case, the Newton algorithm fails, so return an error
// condition. // condition.
if (fbound < 1.e-10) { if (fbound < 1.e-10) {
writelog("\nAt limits.\n", loglevel); debuglog("\nAt limits.\n", loglevel);
return -3; return -3;
} }
@ -334,7 +334,7 @@ int MultiNewton::solve(doublereal* x0, doublereal* x1,
while (true) { while (true) {
// Check whether the Jacobian should be re-evaluated. // Check whether the Jacobian should be re-evaluated.
if (jac.age() > m_maxAge) { if (jac.age() > m_maxAge) {
writelog("\nMaximum Jacobian age reached ("+int2str(m_maxAge)+")\n", loglevel); debuglog("\nMaximum Jacobian age reached ("+int2str(m_maxAge)+")\n", loglevel);
forceNewJac = true; forceNewJac = true;
} }
@ -386,7 +386,7 @@ int MultiNewton::solve(doublereal* x0, doublereal* x1,
break; break;
} }
nJacReeval++; nJacReeval++;
writelog("\nRe-evaluating Jacobian, since no damping " debuglog("\nRe-evaluating Jacobian, since no damping "
"coefficient\ncould be found with this Jacobian.\n", "coefficient\ncould be found with this Jacobian.\n",
loglevel); loglevel);
} else { } else {

10
src/oneD/OneDim.cpp
View file

@ -320,8 +320,8 @@ doublereal OneDim::timeStep(int nsteps, doublereal dt, doublereal* x,
// set the Jacobian age parameter to the transient value // set the Jacobian age parameter to the transient value
newton().setOptions(m_ts_jac_age); newton().setOptions(m_ts_jac_age);
writelog("\n\n step size (s) log10(ss) \n", loglevel); debuglog("\n\n step size (s) log10(ss) \n", loglevel);
writelog("===============================\n", loglevel); debuglog("===============================\n", loglevel);
int n = 0; int n = 0;
char str[80]; char str[80];
@ -342,7 +342,7 @@ doublereal OneDim::timeStep(int nsteps, doublereal dt, doublereal* x,
// the current solution in x. // the current solution in x.
if (m >= 0) { if (m >= 0) {
n += 1; n += 1;
writelog("\n", loglevel); debuglog("\n", loglevel);
copy(r, r + m_size, x); copy(r, r + m_size, x);
if (m == 100) { if (m == 100) {
dt *= 1.5; dt *= 1.5;
@ -351,7 +351,7 @@ doublereal OneDim::timeStep(int nsteps, doublereal dt, doublereal* x,
} else { } else {
// No solution could be found with this time step. // No solution could be found with this time step.
// Decrease the stepsize and try again. // Decrease the stepsize and try again.
writelog("...failure.\n", loglevel); debuglog("...failure.\n", loglevel);
dt *= m_tfactor; dt *= m_tfactor;
if (dt < m_tmin) { if (dt < m_tmin) {
throw CanteraError("OneDim::timeStep", throw CanteraError("OneDim::timeStep",
@ -406,7 +406,7 @@ void OneDim::save(const std::string& fname, std::string id,
} }
root.write(s); root.write(s);
s.close(); s.close();
writelog("Solution saved to file "+fname+" as solution "+id+".\n", loglevel); debuglog("Solution saved to file "+fname+" as solution "+id+".\n", loglevel);
} }
} }

10
src/oneD/Sim1D.cpp
View file

@ -228,7 +228,7 @@ void Sim1D::solve(int loglevel, bool refine_grid)
writeline('.', 78, true, true); writeline('.', 78, true, true);
} }
while (!ok) { while (!ok) {
writelog("Attempt Newton solution of steady-state problem...", loglevel); debuglog("Attempt Newton solution of steady-state problem...", loglevel);
int status = newtonSolve(loglevel-1); int status = newtonSolve(loglevel-1);
if (status == 0) { if (status == 0) {
@ -255,7 +255,7 @@ void Sim1D::solve(int loglevel, bool refine_grid)
soln_number++; soln_number++;
} else { } else {
char buf[100]; char buf[100];
writelog(" failure. \n", loglevel); debuglog(" failure. \n", loglevel);
if (loglevel > 6) { if (loglevel > 6) {
save("debug_sim1d.xml", "debug", save("debug_sim1d.xml", "debug",
"After unsuccessful Newton solve"); "After unsuccessful Newton solve");
@ -264,7 +264,7 @@ void Sim1D::solve(int loglevel, bool refine_grid)
saveResidual("debug_sim1d.xml", "residual", saveResidual("debug_sim1d.xml", "residual",
"After unsuccessful Newton solve"); "After unsuccessful Newton solve");
} }
writelog("Take "+int2str(nsteps)+" timesteps ", loglevel); debuglog("Take "+int2str(nsteps)+" timesteps ", loglevel);
dt = timeStep(nsteps, dt, DATA_PTR(m_x), DATA_PTR(m_xnew), dt = timeStep(nsteps, dt, DATA_PTR(m_x), DATA_PTR(m_xnew),
loglevel-1); loglevel-1);
if (loglevel > 6) { if (loglevel > 6) {
@ -315,7 +315,7 @@ void Sim1D::solve(int loglevel, bool refine_grid)
new_points = 0; new_points = 0;
} }
} else { } else {
writelog("grid refinement disabled.\n", loglevel); debuglog("grid refinement disabled.\n", loglevel);
new_points = 0; new_points = 0;
} }
} }
@ -376,7 +376,7 @@ int Sim1D::refine(int loglevel)
} }
} }
} else { } else {
writelog("refine: discarding point at "+fp2str(d.grid(m))+"\n", loglevel); debuglog("refine: discarding point at "+fp2str(d.grid(m))+"\n", loglevel);
} }
} }
dsize.push_back(znew.size() - nstart); dsize.push_back(znew.size() - nstart);

14
src/oneD/StFlow.cpp
View file

@ -663,7 +663,7 @@ void StFlow::restore(const XML_Node& dom, doublereal* soln, int loglevel)
if (nm == "z") { if (nm == "z") {
getFloatArray(fa,x,false); getFloatArray(fa,x,false);
np = x.size(); np = x.size();
writelog("Grid contains "+int2str(np)+" points.\n", loglevel >= 2); debuglog("Grid contains "+int2str(np)+" points.\n", loglevel >= 2);
readgrid = true; readgrid = true;
setupGrid(np, DATA_PTR(x)); setupGrid(np, DATA_PTR(x));
} }
@ -673,13 +673,13 @@ void StFlow::restore(const XML_Node& dom, doublereal* soln, int loglevel)
"domain contains no grid points."); "domain contains no grid points.");
} }
writelog("Importing datasets:\n", loglevel >= 2); debuglog("Importing datasets:\n", loglevel >= 2);
for (n = 0; n < nd; n++) { for (n = 0; n < nd; n++) {
const XML_Node& fa = *d[n]; const XML_Node& fa = *d[n];
nm = fa["title"]; nm = fa["title"];
getFloatArray(fa,x,false); getFloatArray(fa,x,false);
if (nm == "u") { if (nm == "u") {
writelog("axial velocity ", loglevel >= 2); debuglog("axial velocity ", loglevel >= 2);
if (x.size() != np) { if (x.size() != np) {
throw CanteraError("StFlow::restore", throw CanteraError("StFlow::restore",
"axial velocity array size error"); "axial velocity array size error");
@ -690,7 +690,7 @@ void StFlow::restore(const XML_Node& dom, doublereal* soln, int loglevel)
} else if (nm == "z") { } else if (nm == "z") {
; // already read grid ; // already read grid
} else if (nm == "V") { } else if (nm == "V") {
writelog("radial velocity ", loglevel >= 2); debuglog("radial velocity ", loglevel >= 2);
if (x.size() != np) { if (x.size() != np) {
throw CanteraError("StFlow::restore", throw CanteraError("StFlow::restore",
"radial velocity array size error"); "radial velocity array size error");
@ -699,7 +699,7 @@ void StFlow::restore(const XML_Node& dom, doublereal* soln, int loglevel)
soln[index(1,j)] = x[j]; soln[index(1,j)] = x[j];
} }
} else if (nm == "T") { } else if (nm == "T") {
writelog("temperature ", loglevel >= 2); debuglog("temperature ", loglevel >= 2);
if (x.size() != np) { if (x.size() != np) {
throw CanteraError("StFlow::restore", throw CanteraError("StFlow::restore",
"temperature array size error"); "temperature array size error");
@ -718,7 +718,7 @@ void StFlow::restore(const XML_Node& dom, doublereal* soln, int loglevel)
} }
setFixedTempProfile(zz, x); setFixedTempProfile(zz, x);
} else if (nm == "L") { } else if (nm == "L") {
writelog("lambda ", loglevel >= 2); debuglog("lambda ", loglevel >= 2);
if (x.size() != np) { if (x.size() != np) {
throw CanteraError("StFlow::restore", throw CanteraError("StFlow::restore",
"lambda arary size error"); "lambda arary size error");
@ -727,7 +727,7 @@ void StFlow::restore(const XML_Node& dom, doublereal* soln, int loglevel)
soln[index(3,j)] = x[j]; soln[index(3,j)] = x[j];
} }
} else if (m_thermo->speciesIndex(nm) != npos) { } else if (m_thermo->speciesIndex(nm) != npos) {
writelog(nm+" ", loglevel >= 2); debuglog(nm+" ", loglevel >= 2);
if (x.size() == np) { if (x.size() == np) {
k = m_thermo->speciesIndex(nm); k = m_thermo->speciesIndex(nm);
did_species[k] = 1; did_species[k] = 1;

2
src/thermo/PureFluidPhase.cpp
View file

@ -86,7 +86,7 @@ void PureFluidPhase::initThermo()
double s_R = s0_R - log(p/refPressure()); double s_R = s0_R - log(p/refPressure());
m_sub->setStdState(h0_RT*GasConstant*298.15/m_mw, m_sub->setStdState(h0_RT*GasConstant*298.15/m_mw,
s_R*GasConstant/m_mw, T0, p); s_R*GasConstant/m_mw, T0, p);
writelog("PureFluidPhase::initThermo: initialized phase " debuglog("PureFluidPhase::initThermo: initialized phase "
+id()+"\n", m_verbose); +id()+"\n", m_verbose);
} }

8
src/thermo/ThermoPhase.cpp
View file

@ -763,7 +763,7 @@ void ThermoPhase::equilibrate(const std::string& XY, const std::string& solver,
if (solver == "auto" || solver == "element_potential") { if (solver == "auto" || solver == "element_potential") {
vector_fp initial_state; vector_fp initial_state;
saveState(initial_state); saveState(initial_state);
writelog("Trying ChemEquil solver\n", log_level); debuglog("Trying ChemEquil solver\n", log_level);
try { try {
ChemEquil E; ChemEquil E;
E.options.maxIterations = max_steps; E.options.maxIterations = max_steps;
@ -775,11 +775,11 @@ void ThermoPhase::equilibrate(const std::string& XY, const std::string& solver,
"ChemEquil solver failed. Return code: " + int2str(ret)); "ChemEquil solver failed. Return code: " + int2str(ret));
} }
setElementPotentials(E.elementPotentials()); setElementPotentials(E.elementPotentials());
writelog("ChemEquil solver succeeded\n", log_level); debuglog("ChemEquil solver succeeded\n", log_level);
return; return;
} catch (std::exception& err) { } catch (std::exception& err) {
writelog("ChemEquil solver failed.\n", log_level); debuglog("ChemEquil solver failed.\n", log_level);
writelog(err.what(), log_level); debuglog(err.what(), log_level);
restoreState(initial_state); restoreState(initial_state);
if (solver == "auto") { if (solver == "auto") {
} else { } else {

4
src/zeroD/ReactorNet.cpp
View file

@ -36,7 +36,7 @@ void ReactorNet::initialize()
size_t n, nv; size_t n, nv;
char buf[100]; char buf[100];
m_nv = 0; m_nv = 0;
writelog("Initializing reactor network.\n", m_verbose); debuglog("Initializing reactor network.\n", m_verbose);
if (m_reactors.empty()) { if (m_reactors.empty()) {
throw CanteraError("ReactorNet::initialize", throw CanteraError("ReactorNet::initialize",
"no reactors in network!"); "no reactors in network!");
@ -96,7 +96,7 @@ void ReactorNet::initialize()
void ReactorNet::reinitialize() void ReactorNet::reinitialize()
{ {
if (m_init) { if (m_init) {
writelog("Re-initializing reactor network.\n", m_verbose); debuglog("Re-initializing reactor network.\n", m_verbose);
m_integ->reinitialize(m_time, *this); m_integ->reinitialize(m_time, *this);
m_integrator_init = true; m_integrator_init = true;
} else { } else {