Cantera  2.2.1
vcs_report.cpp
Go to the documentation of this file.
1 //! @file vcs_report.cpp
2 /*
3  * Copyright (2005) Sandia Corporation. Under the terms of
4  * Contract DE-AC04-94AL85000 with Sandia Corporation, the
5  * U.S. Government retains certain rights in this software.
6  */
7
11
12 namespace Cantera
13 {
14 int VCS_SOLVE::vcs_report(int iconv)
15 {
16  bool printActualMoles = true, inertYes = false;
17  size_t nspecies = m_numSpeciesTot;
18
19  char originalUnitsState = m_unitsState;
20
21  std::vector<size_t> sortindex(nspecies,0);
22  std::vector<double> xy(nspecies,0.0);
23
24  /* ************************************************************** */
25  /* **** SORT DEPENDENT SPECIES IN DECREASING ORDER OF MOLES ***** */
26  /* ************************************************************** */
27
28  for (size_t i = 0; i < nspecies; ++i) {
29  sortindex[i] = i;
30  xy[i] = m_molNumSpecies_old[i];
31  }
32  /*
33  * Sort the XY vector, the mole fraction vector,
34  * and the sort index vector, sortindex, according to
35  * the magnitude of the mole fraction vector.
36  */
37  for (size_t l = m_numComponents; l < m_numSpeciesRdc; ++l) {
38  size_t k = vcs_optMax(VCS_DATA_PTR(xy), 0, l, m_numSpeciesRdc);
39  if (k != l) {
40  std::swap(xy[k], xy[l]);
41  std::swap(sortindex[k], sortindex[l]);
42  }
43  }
44
45  /*
46  * Decide whether we have to nondimensionalize the equations.
47  * -> For the printouts from this routine, we will use nondimensional
48  * representations. This may be expanded in the future.
49  */
51  vcs_nondim_TP();
52  }
53  double molScale = 1.0;
54  if (printActualMoles) {
55  molScale = m_totalMoleScale;
56  }
57
58  vcs_setFlagsVolPhases(false, VCS_STATECALC_OLD);
60  /* ******************************************************** */
61  /* *** PRINT OUT RESULTS ********************************** */
62  /* ******************************************************** */
63
64  plogf("\n\n\n\n");
65  writeline('-', 80);
66  writeline('-', 80);
67  plogf("\t\t VCS_TP REPORT\n");
68  writeline('-', 80);
69  writeline('-', 80);
70  if (iconv < 0) {
71  plogf(" ERROR: CONVERGENCE CRITERION NOT SATISFIED.\n");
72  } else if (iconv == 1) {
73  plogf(" RANGE SPACE ERROR: Equilibrium Found but not all Element Abundances are Satisfied\n");
74  }
75  /*
76  * Calculate some quantities that may need updating
77  */
78  vcs_tmoles();
81
82  plogf("\t\tTemperature = %15.2g Kelvin\n", m_temperature);
83  plogf("\t\tPressure = %15.5g Pa \n", m_pressurePA);
84  plogf("\t\ttotal Volume = %15.5g m**3\n", m_totalVol * molScale);
85  if (!printActualMoles) {
86  plogf("\t\tMole Scale = %15.5g kmol (all mole numbers and volumes are scaled by this value)\n",
87  molScale);
88  }
89
90  /*
91  * -------- TABLE OF SPECIES IN DECREASING MOLE NUMBERS --------------
92  */
93  plogf("\n\n");
94  writeline('-', 80);
95  plogf(" Species Equilibrium kmoles ");
96  plogf("Mole Fraction ChemPot/RT SpecUnkType\n");
97  writeline('-', 80);
98  for (size_t i = 0; i < m_numComponents; ++i) {
99  plogf(" %-12.12s", m_speciesName[i].c_str());
100  writeline(' ', 13, false);
101  plogf("%14.7E %14.7E %12.4E", m_molNumSpecies_old[i] * molScale,
102  m_molNumSpecies_new[i] * molScale, m_feSpecies_old[i]);
103  plogf(" %3d", m_speciesUnknownType[i]);
104  plogf("\n");
105  }
106  for (size_t i = m_numComponents; i < m_numSpeciesRdc; ++i) {
107  size_t l = sortindex[i];
108  plogf(" %-12.12s", m_speciesName[l].c_str());
109  writeline(' ', 13, false);
110
112  plogf("%14.7E %14.7E %12.4E", m_molNumSpecies_old[l] * molScale,
113  m_molNumSpecies_new[l] * molScale, m_feSpecies_old[l]);
114  plogf(" KMolNum ");
116  plogf(" NA %14.7E %12.4E", 1.0, m_feSpecies_old[l]);
117  plogf(" Voltage = %14.7E", m_molNumSpecies_old[l] * molScale);
118  } else {
119  throw CanteraError("VCS_SOLVE::vcs_report", "we have a problem");
120  }
121  plogf("\n");
122  }
123  for (size_t i = 0; i < m_numPhases; i++) {
124  if (TPhInertMoles[i] > 0.0) {
125  inertYes = true;
126  if (i == 0) {
127  plogf(" Inert Gas Species ");
128  } else {
129  plogf(" Inert Species in phase %16s ",
130  (m_VolPhaseList[i])->PhaseName.c_str());
131  }
132  plogf("%14.7E %14.7E %12.4E\n", TPhInertMoles[i] * molScale,
133  TPhInertMoles[i] / m_tPhaseMoles_old[i], 0.0);
134  }
135  }
136  if (m_numSpeciesRdc != nspecies) {
137  plogf("\n SPECIES WITH LESS THAN 1.0E-32 KMOLES:\n\n");
138  for (size_t kspec = m_numSpeciesRdc; kspec < nspecies; ++kspec) {
139  plogf(" %-12.12s", m_speciesName[kspec].c_str());
140  // Note m_deltaGRxn_new[] stores in kspec slot not irxn slot, after solve
141  plogf(" %14.7E %14.7E %12.4E",
142  m_molNumSpecies_old[kspec]*molScale,
143  m_molNumSpecies_new[kspec]*molScale, m_deltaGRxn_new[kspec]);
145  plogf(" KMol_Num");
147  plogf(" Voltage");
148  } else {
149  plogf(" Unknown");
150  }
151
152  plogf("\n");
153  }
154  }
155  writeline('-', 80);
156  plogf("\n");
157
158  /*
159  * ---------- TABLE OF SPECIES FORMATION REACTIONS ------------------
160  */
161  writeline('-', m_numComponents*10 + 45, true, true);
162  plogf(" |ComponentID|");
163  for (size_t j = 0; j < m_numComponents; j++) {
164  plogf(" %3d", j);
165  }
166  plogf(" | |\n");
167  plogf(" | Components|");
168  for (size_t j = 0; j < m_numComponents; j++) {
169  plogf(" %10.10s", m_speciesName[j].c_str());
170  }
171  plogf(" | |\n");
172  plogf(" NonComponent | Moles |");
173  for (size_t j = 0; j < m_numComponents; j++) {
174  plogf(" %10.3g", m_molNumSpecies_old[j] * molScale);
175  }
176  plogf(" | DG/RT Rxn |\n");
177  writeline('-', m_numComponents*10 + 45);
178  for (size_t irxn = 0; irxn < m_numRxnTot; irxn++) {
179  size_t kspec = m_indexRxnToSpecies[irxn];
180  plogf(" %3d ", kspec);
181  plogf("%-10.10s", m_speciesName[kspec].c_str());
182  plogf("|%10.3g |", m_molNumSpecies_old[kspec]*molScale);
183  for (size_t j = 0; j < m_numComponents; j++) {
184  plogf(" %6.2f", m_stoichCoeffRxnMatrix(j,irxn));
185  }
186  plogf(" |%10.3g |", m_deltaGRxn_new[irxn]);
187  plogf("\n");
188  }
189  writeline('-', m_numComponents*10 + 45);
190  plogf("\n");
191
192  /*
193  * ------------------ TABLE OF PHASE INFORMATION ---------------------
194  */
195  std::vector<double> gaPhase(m_numElemConstraints, 0.0);
196  std::vector<double> gaTPhase(m_numElemConstraints, 0.0);
197  double totalMoles = 0.0;
198  double gibbsPhase = 0.0;
199  double gibbsTotal = 0.0;
200  plogf("\n\n");
201  plogf("\n");
202  writeline('-', m_numElemConstraints*10 + 58);
203  plogf(" | ElementID |");
204  for (size_t j = 0; j < m_numElemConstraints; j++) {
205  plogf(" %3d", j);
206  }
207  plogf(" | |\n");
208  plogf(" | Element |");
209  for (size_t j = 0; j < m_numElemConstraints; j++) {
210  plogf(" %10.10s", (m_elementName[j]).c_str());
211  }
212  plogf(" | |\n");
213  plogf(" PhaseName |KMolTarget |");
214  for (size_t j = 0; j < m_numElemConstraints; j++) {
215  plogf(" %10.3g", m_elemAbundancesGoal[j]);
216  }
217  plogf(" | Gibbs Total |\n");
218  writeline('-', m_numElemConstraints*10 + 58);
219  for (size_t iphase = 0; iphase < m_numPhases; iphase++) {
220  plogf(" %3d ", iphase);
221  vcs_VolPhase* VPhase = m_VolPhaseList[iphase];
222  plogf("%-12.12s |",VPhase->PhaseName.c_str());
223  plogf("%10.3e |", m_tPhaseMoles_old[iphase]*molScale);
224  totalMoles += m_tPhaseMoles_old[iphase];
225  if (m_tPhaseMoles_old[iphase] != VPhase->totalMoles()) {
226  if (! vcs_doubleEqual(m_tPhaseMoles_old[iphase], VPhase->totalMoles())) {
227  throw CanteraError("VCS_SOLVE::vcs_report", "we have a problem");
228  }
229  }
230  vcs_elabPhase(iphase, VCS_DATA_PTR(gaPhase));
231  for (size_t j = 0; j < m_numElemConstraints; j++) {
232  plogf(" %10.3g", gaPhase[j]);
233  gaTPhase[j] += gaPhase[j];
234  }
235  gibbsPhase = vcs_GibbsPhase(iphase, VCS_DATA_PTR(m_molNumSpecies_old),
237  gibbsTotal += gibbsPhase;
238  plogf(" | %18.11E |\n", gibbsPhase);
239  }
240  writeline('-', m_numElemConstraints*10 + 58);
241  plogf(" TOTAL |%10.3e |", totalMoles);
242  for (size_t j = 0; j < m_numElemConstraints; j++) {
243  plogf(" %10.3g", gaTPhase[j]);
244  }
245  plogf(" | %18.11E |\n", gibbsTotal);
246
247  writeline('-', m_numElemConstraints*10 + 58);
248  plogf("\n");
249
250  /*
251  * ----------- GLOBAL SATISFACTION INFORMATION -----------------------
252  */
253
254  /*
255  * Calculate the total dimensionless Gibbs Free Energy
256  * -> Inert species are handled as if they had a standard free
257  * energy of zero
258  */
259
262  plogf("\n\tTotal Dimensionless Gibbs Free Energy = G/RT = %15.7E\n", g);
263  if (inertYes) {
264  plogf("\t\t(Inert species have standard free energy of zero)\n");
265  }
266
267  plogf("\nElemental Abundances (kmol): ");
268  plogf(" Actual Target Type ElActive\n");
269  for (size_t i = 0; i < m_numElemConstraints; ++i) {
270  writeline(' ', 26, false);
271  plogf("%-2.2s", (m_elementName[i]).c_str());
272  plogf("%20.12E %20.12E", m_elemAbundances[i]*molScale, m_elemAbundancesGoal[i]*molScale);
273  plogf(" %3d %3d\n", m_elType[i], m_elementActive[i]);
274  }
275  plogf("\n");
276
277  /*
278  * ------------------ TABLE OF SPECIES CHEM POTS ---------------------
279  */
280  writeline('-', 93, true, true);
281  plogf("Chemical Potentials of the Species: (dimensionless)\n");
282
284  plogf("\t\t(RT = %g ", rt);
286  plogf(")\n");
287  plogf(" Name TKMoles StandStateChemPot "
288  " ln(AC) ln(X_i) | F z_i phi | ChemPot | (-lnMnaught)");
289  plogf("| (MolNum ChemPot)|");
290  writeline('-', 147, true, true);
291  for (size_t i = 0; i < nspecies; ++i) {
292  size_t l = sortindex[i];
293  size_t pid = m_phaseID[l];
294  plogf(" %-12.12s", m_speciesName[l].c_str());
295  plogf(" %14.7E ", m_molNumSpecies_old[l]*molScale);
296  plogf("%14.7E ", m_SSfeSpecies[l]);
297  plogf("%14.7E ", log(m_actCoeffSpecies_old[l]));
298  double tpmoles = m_tPhaseMoles_old[pid];
299  double phi = m_phasePhi[pid];
300  double eContrib = phi * m_chargeSpecies[l] * m_Faraday_dim;
301  double lx = 0.0;
303  lx = 0.0;
304  } else {
305  if (tpmoles > 0.0 && m_molNumSpecies_old[l] > 0.0) {
306  double tmp = std::max(VCS_DELETE_MINORSPECIES_CUTOFF, m_molNumSpecies_old[l]);
307  lx = log(tmp) - log(tpmoles);
308  } else {
309  lx = m_feSpecies_old[l] - m_SSfeSpecies[l]
311  }
312  }
313  plogf("%14.7E |", lx);
314  plogf("%14.7E | ", eContrib);
315  double tmp = m_SSfeSpecies[l] + log(m_actCoeffSpecies_old[l])
316  + lx - m_lnMnaughtSpecies[l] + eContrib;
317  if (fabs(m_feSpecies_old[l] - tmp) > 1.0E-7) {
318  throw CanteraError("VCS_SOLVE::vcs_report",
319  "we have a problem - doesn't add up");
320  }
321  plogf(" %12.4E |", m_feSpecies_old[l]);
322  if (m_lnMnaughtSpecies[l] != 0.0) {
323  plogf("(%11.5E)", - m_lnMnaughtSpecies[l]);
324  } else {
325  plogf(" ");
326  }
327
328  plogf("| %20.9E |", m_feSpecies_old[l] * m_molNumSpecies_old[l] * molScale);
329  plogf("\n");
330  }
331  for (size_t i = 0; i < 125; i++) {
332  plogf(" ");
333  }
334  plogf(" %20.9E\n", g);
335  writeline('-', 147);
336
337  /*
338  * ------------- TABLE OF SOLUTION COUNTERS --------------------------
339  */
340  plogf("\n");
341  plogf("\nCounters: Iterations Time (seconds)\n");
342  if (m_timing_print_lvl > 0) {
343  plogf(" vcs_basopt: %5d %11.5E\n",
345  plogf(" vcs_TP: %5d %11.5E\n",
347  } else {
348  plogf(" vcs_basopt: %5d %11s\n",
349  m_VCount->Basis_Opts," NA ");
350  plogf(" vcs_TP: %5d %11s\n",
351  m_VCount->Its," NA ");
352  }
353  writeline('-', 80);
354  writeline('-', 80);
355
356  /*
357  * Set the Units state of the system back to where it was when we
358  * entered the program.
359  */
360  if (originalUnitsState != m_unitsState) {
361  if (originalUnitsState == VCS_DIMENSIONAL_G) {
362  vcs_redim_TP();
363  } else {
364  vcs_nondim_TP();
365  }
366  }
367  /*
368  * Return a successful completion flag
369  */
370  return VCS_SUCCESS;
371 }
372
373 void VCS_SOLVE::vcs_TCounters_report(int timing_print_lvl)
374 {
375  plogf("\nTCounters: Num_Calls Total_Its Total_Time (seconds)\n");
376  if (timing_print_lvl > 0) {
377  plogf(" vcs_basopt: %5d %5d %11.5E\n",
380  plogf(" vcs_TP: %5d %5d %11.5E\n",
383  plogf(" vcs_inest: %5d %11.5E\n",
385  plogf(" vcs_TotalTime: %11.5E\n",
387  } else {
388  plogf(" vcs_basopt: %5d %5d %11s\n",
390  plogf(" vcs_TP: %5d %5d %11s\n",
392  plogf(" vcs_inest: %5d %11s\n",
393  m_VCount->T_Calls_Inest, " NA ");
394  plogf(" vcs_TotalTime: %11s\n",
395  " NA ");
396  }
397 }
398
399 }
std::vector< size_t > m_phaseID
Mapping from the species number to the phase number.
Definition: vcs_solve.h:1832
bool vcs_doubleEqual(double d1, double d2)
Simple routine to check whether two doubles are equal up to roundoff error.
Definition: vcs_util.cpp:185
double vcs_nondimMult_TP(int mu_units, double TKelvin) const
Returns the multiplier for the nondimensionalization of the equations.
Definition: vcs_nondim.cpp:38
int Its
Current number of iterations in the main loop of vcs_TP() to solve for thermo equilibrium.
Definition: vcs_internal.h:58
std::vector< int > m_elType
Type of the element constraint.
Definition: vcs_solve.h:1860
double vcs_Total_Gibbs(double *w, double *fe, double *tPhMoles)
Calculate the total dimensionless Gibbs free energy.
Definition: vcs_Gibbs.cpp:16
int T_Calls_Inest
Current number of times the initial thermo equilibrium estimator has been called. ...
Definition: vcs_internal.h:68
double Time_vcs_TP
Current time spent in vcs_TP.
Definition: vcs_internal.h:77
int Basis_Opts
number of optimizations of the components basis set done
Definition: vcs_internal.h:64
double T_Time_basopt
Total Time spent in basopt.
Definition: vcs_internal.h:80
dimensionless value of Faraday's constant, F / RT (1/volt)
Definition: vcs_solve.h:1976
VCS_COUNTERS * m_VCount
Timing and iteration counters for the vcs object.
Definition: vcs_solve.h:1979
Array2D m_stoichCoeffRxnMatrix
Stoichiometric coefficient matrix for the reaction mechanism expressed in Reduced Canonical Form...
Definition: vcs_solve.h:1552
#define VCS_DATA_PTR(vvv)
Points to the data in a std::vector<> object.
Definition: vcs_internal.h:18
void vcs_dfe(const int stateCalc, const int ll, const size_t lbot, const size_t ltop)
Calculate the dimensionless chemical potentials of all species or of certain groups of species...
void vcs_elabPhase(size_t iphase, double *const elemAbundPhase)
Definition: vcs_elem.cpp:89
std::vector< vcs_VolPhase * > m_VolPhaseList
Array of Phase Structures. Length = number of phases.
Definition: vcs_solve.h:1869
std::vector< double > m_phasePhi
electric potential of the iph phase
Definition: vcs_solve.h:1639
void vcs_nondim_TP()
Nondimensionalize the problem data.
Definition: vcs_nondim.cpp:60
double vcs_tmoles()
Calculates the total number of moles of species in all phases.
std::vector< double > m_lnMnaughtSpecies
specifies the ln(Mnaught) used to calculate the chemical potentials
Definition: vcs_solve.h:1913
std::string PhaseName
String name for the phase.
Definition: vcs_VolPhase.h:696
void vcs_redim_TP()
Redimensionalize the problem data.
Definition: vcs_nondim.cpp:145
void vcs_printChemPotUnits(int unitsFormat) const
Print the string representing the Chemical potential units.
Definition: vcs_nondim.cpp:189
int m_VCS_UnitsFormat
Units for the chemical potential data.
Definition: vcs_solve.h:2014
double totalMoles() const
Return the total moles in the phase.
std::vector< double > m_chargeSpecies
Charge of each species. Length = number of species.
Definition: vcs_solve.h:1945
size_t m_numSpeciesRdc
Current number of species in the problems.
Definition: vcs_solve.h:1512
std::vector< double > m_molNumSpecies_old
Total moles of the species.
Definition: vcs_solve.h:1612
int T_Basis_Opts
Total number of optimizations of the components basis set done.
Definition: vcs_internal.h:61
double vcs_GibbsPhase(size_t iphase, const double *const w, const double *const fe)
Calculate the total dimensionless Gibbs free energy of a single phase.
Definition: vcs_Gibbs.cpp:41
std::vector< std::string > m_elementName
Vector of strings containing the element names.
Definition: vcs_solve.h:1845
Header file for the internal object that holds the vcs equilibrium problem (see Class VCS_SOLVE and E...
Header for the object representing each phase within vcs.
#define VCS_SPECIES_TYPE_MOLNUM
Unknown refers to mole number of a single species.
Definition: vcs_defs.h:343
int vcs_report(int iconv)
Print out a report on the state of the equilibrium problem to standard output.
Definition: vcs_report.cpp:14
#define VCS_DELETE_MINORSPECIES_CUTOFF
Cutoff relative mole number value, below which species are deleted from the equilibrium problem...
Definition: vcs_defs.h:57
double vcs_VolTotal(const double tkelvin, const double pres, const double w[], double volPM[])
Calculation of the total volume and the partial molar volumes.
Definition: vcs_solve.cpp:983
#define VCS_SUCCESS
Definition: vcs_defs.h:21
std::vector< double > m_elemAbundances
Element abundances vector.
Definition: vcs_solve.h:1686
double T_Time_vcs_TP
Current time spent in vcs_TP.
Definition: vcs_internal.h:74
size_t m_numElemConstraints
Number of element constraints in the problem.
Definition: vcs_solve.h:1499
void vcs_TCounters_report(int timing_print_lvl=1)
Create a report on the plog file containing timing and its information.
Definition: vcs_report.cpp:373
size_t m_numSpeciesTot
Total number of species in the problems.
Definition: vcs_solve.h:1493
std::vector< int > m_speciesUnknownType
Specifies the species unknown type.
Definition: vcs_solve.h:1625
int T_Its
Total number of iterations in the main loop of vcs_TP() to solve for thermo equilibrium.
Definition: vcs_internal.h:54
double T_Time_inest
Time spent in initial estimator.
Definition: vcs_internal.h:86
Base class for exceptions thrown by Cantera classes.
Definition: ctexceptions.h:99
std::vector< double > m_tPhaseMoles_old
Total kmols of species in each phase.
Definition: vcs_solve.h:1710
double Time_basopt
Current Time spent in basopt.
Definition: vcs_internal.h:83
int m_timing_print_lvl
printing level of timing information
Definition: vcs_solve.h:2002
size_t m_numComponents
Number of components calculated for the problem.
Definition: vcs_solve.h:1502
std::vector< double > m_molNumSpecies_new
Tentative value of the mole number vector.
Definition: vcs_solve.h:1644
std::vector< double > m_SSfeSpecies
Standard state chemical potentials for species K at the current temperature and pressure.
Definition: vcs_solve.h:1577
std::vector< double > m_actCoeffSpecies_old
Molar-based Activity Coefficients for Species based on old mole numbers.
Definition: vcs_solve.h:1924
double m_totalVol
Total volume of all phases. Units are m^3.
Definition: vcs_solve.h:1966
double m_temperature
Temperature (Kelvin)
Definition: vcs_solve.h:1734
Phase information and Phase calculations for vcs.
Definition: vcs_VolPhase.h:86
#define VCS_DIMENSIONAL_G
dimensioned
Definition: vcs_defs.h:102
std::vector< std::string > m_speciesName
Species string name for the kth species.
Definition: vcs_solve.h:1839
#define VCS_STATECALC_OLD
State Calculation based on the old or base mole numbers.
Definition: vcs_defs.h:365
std::vector< int > m_elementActive
Specifies whether an element constraint is active.
Definition: vcs_solve.h:1866
double m_pressurePA
Pressure (units are determined by m_VCS_UnitsFormat.
Definition: vcs_solve.h:1748
size_t vcs_optMax(const double *x, const double *xSize, size_t j, size_t n)
Finds the location of the maximum component in a double vector.
Definition: vcs_util.cpp:37
std::vector< double > m_PMVolumeSpecies
Partial molar volumes of the species.
Definition: vcs_solve.h:1973
#define plogf
define this Cantera function to replace printf
Definition: vcs_internal.h:24
#define VCS_SPECIES_TYPE_INTERFACIALVOLTAGE
Unknown refers to the voltage level of a phase.
Definition: vcs_defs.h:352
double T_Time_vcs
Time spent in the vcs suite of programs.
Definition: vcs_internal.h:89
char m_unitsState
This specifies the current state of units for the Gibbs free energy properties in the program...
Definition: vcs_solve.h:1879
std::vector< size_t > m_indexRxnToSpecies
Mapping between the species index for noncomponent species and the full species index.
Definition: vcs_solve.h:1821
size_t m_numPhases
Number of Phases in the problem.
Definition: vcs_solve.h:1526
double m_totalMoleScale
Multiplier for the mole numbers within the nondimensionless formulation.
Definition: vcs_solve.h:1888
size_t m_numRxnTot
Total number of non-component species in the problem.
Definition: vcs_solve.h:1505
std::vector< double > TPhInertMoles
Total kmoles of inert to add to each phase.
Definition: vcs_solve.h:1755
std::vector< double > m_elemAbundancesGoal
Element abundances vector Goals.
Definition: vcs_solve.h:1695
std::vector< double > m_feSpecies_old
Free energy vector from the start of the current iteration.
Definition: vcs_solve.h:1584
Definitions for the classes that are thrown when Cantera experiences an error condition (also contain...
std::vector< double > m_deltaGRxn_new
Delta G(irxn) for the noncomponent species in the mechanism.
Definition: vcs_solve.h:1654
int T_Calls_vcs_TP
Current number of calls to vcs_TP.
Definition: vcs_internal.h:71