research/cantera
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
cantera/src/equil/vcs_solve_TP.cpp
Ray Speth 3f6d8b0aca Use cppformat instead of int2str and fp2str
2015-10-14 18:45:23 -04:00

4368 lines
182 KiB
C++
Raw Blame History

/**
* @file vcs_solve_TP.cpp Implementation file that contains the
* main algorithm for finding an equilibrium
*/
/*
* Copyright (2005) Sandia Corporation. Under the terms of
* Contract DE-AC04-94AL85000 with Sandia Corporation, the
* U.S. Government retains certain rights in this software.
*/
#include "cantera/equil/vcs_solve.h"
#include "cantera/equil/vcs_VolPhase.h"
#include "cantera/base/ctexceptions.h"
#include "cantera/base/clockWC.h"
#include "cantera/base/stringUtils.h"
#include "cantera/numerics/ctlapack.h"
#include <cstdio>
using namespace std;
namespace {
enum stages {MAIN, EQUILIB_CHECK, ELEM_ABUND_CHECK,
RECHECK_DELETED, RETURN_A, RETURN_B};
}
namespace Cantera
{
void VCS_SOLVE::checkDelta1(double* const dsLocal,
double* const delTPhMoles, size_t kspec)
{
vector_fp dchange(m_numPhases, 0.0);
for (size_t k = 0; k < kspec; k++) {
if (m_speciesUnknownType[k] != VCS_SPECIES_TYPE_INTERFACIALVOLTAGE) {
size_t iph = m_phaseID[k];
dchange[iph] += dsLocal[k];
}
}
for (size_t iphase = 0; iphase < m_numPhases; iphase++) {
double denom = max(m_totalMolNum, 1.0E-4);
if (!vcs_doubleEqual(dchange[iphase]/denom, delTPhMoles[iphase]/denom)) {
throw CanteraError("VCS_SOLVE::checkDelta1",
"we have found a problem");
}
}
}
int VCS_SOLVE::vcs_solve_TP(int print_lvl, int printDetails, int maxit)
{
int stage = MAIN;
int solveFail;
bool allMinorZeroedSpecies = false;
size_t it1 = 0;
size_t npb, iti;
int rangeErrorFound = 0;
bool giveUpOnElemAbund = false;
int finalElemAbundAttempts = 0;
bool uptodate_minors = true;
int forceComponentCalc = 1;
#ifdef DEBUG_MODE
char ANOTE[128];
/*
* Set the debug print lvl to the same as the print lvl.
*/
m_debug_print_lvl = printDetails;
#else
char* ANOTE = 0;
#endif
if (printDetails > 0 && print_lvl == 0) {
print_lvl = 1;
}
/*
* Initialize and set up all counters
*/
vcs_counters_init(0);
clockWC ticktock;
/*
* Malloc temporary space for usage in this routine and in
* subroutines
* sm[ne*ne]
* ss[ne]
* sa[ne]
* aw[m]
* wx[ne]
* xy[m]
*/
m_sm.assign(m_numElemConstraints*m_numElemConstraints, 0.0);
m_ss.assign(m_numElemConstraints, 0.0);
m_sa.assign(m_numElemConstraints, 0.0);
m_aw.assign(m_numSpeciesTot, 0.0);
m_wx.assign(m_numElemConstraints, 0.0);
solveFail = false;
/* ****************************************************** */
/* **** Evaluate the elemental composition ****** */
/* ****************************************************** */
vcs_elab();
/* ******************************************************* */
/* **** Printout the initial conditions for problem ****** */
/* ******************************************************* */
if (print_lvl != 0) {
plogf("VCS CALCULATION METHOD\n\n ");
plogf("%s\n", m_title);
plogf("\n\n%5d SPECIES\n%5d ELEMENTS\n", m_numSpeciesTot, m_numElemConstraints);
plogf("%5d COMPONENTS\n", m_numComponents);
plogf("%5d PHASES\n", m_numPhases);
plogf(" PRESSURE%22.8g %3s\n", m_pressurePA, "Pa ");
plogf(" TEMPERATURE%19.3f K\n", m_temperature);
vcs_VolPhase* Vphase = m_VolPhaseList[0];
if (Vphase->nSpecies() > 0) {
plogf(" PHASE1 INERTS%17.3f\n", TPhInertMoles[0]);
}
if (m_numPhases > 1) {
plogf(" PHASE2 INERTS%17.3f\n", TPhInertMoles[1]);
}
plogf("\n ELEMENTAL ABUNDANCES CORRECT");
plogf(" FROM ESTIMATE Type\n\n");
for (size_t i = 0; i < m_numElemConstraints; ++i) {
writeline(' ', 26, false);
plogf("%-2.2s", m_elementName[i]);
plogf("%20.12E%20.12E %3d\n", m_elemAbundancesGoal[i], m_elemAbundances[i],
m_elType[i]);
}
if (m_doEstimateEquil < 0) {
plogf("\n MODIFIED LINEAR PROGRAMMING ESTIMATE OF EQUILIBRIUM - forced\n");
} else if (m_doEstimateEquil > 0) {
plogf("\n MODIFIED LINEAR PROGRAMMING ESTIMATE OF EQUILIBRIUM - where necessary\n");
}
if (m_doEstimateEquil == 0) {
plogf("\n USER ESTIMATE OF EQUILIBRIUM\n");
}
if (m_VCS_UnitsFormat == VCS_UNITS_KCALMOL) {
plogf(" Stan. Chem. Pot. in kcal/mole\n");
}
if (m_VCS_UnitsFormat == VCS_UNITS_UNITLESS) {
plogf(" Stan. Chem. Pot. is MU/RT\n");
}
if (m_VCS_UnitsFormat == VCS_UNITS_KJMOL) {
plogf(" Stan. Chem. Pot. in KJ/mole\n");
}
if (m_VCS_UnitsFormat == VCS_UNITS_KELVIN) {
plogf(" Stan. Chem. Pot. in Kelvin\n");
}
if (m_VCS_UnitsFormat == VCS_UNITS_MKS) {
plogf(" Stan. Chem. Pot. in J/kmol\n");
}
plogf("\n SPECIES FORMULA VECTOR ");
writeline(' ', 41, false);
plogf(" STAN_CHEM_POT EQUILIBRIUM_EST. Species_Type\n\n");
writeline(' ', 20, false);
for (size_t i = 0; i < m_numElemConstraints; ++i) {
plogf("%-4.4s ", m_elementName[i]);
}
plogf(" PhaseID\n");
double RT = vcs_nondimMult_TP(m_VCS_UnitsFormat, m_temperature);
for (size_t i = 0; i < m_numSpeciesTot; ++i) {
plogf(" %-18.18s", m_speciesName[i]);
for (size_t j = 0; j < m_numElemConstraints; ++j) {
plogf("% -7.3g ", m_formulaMatrix(i,j));
}
plogf(" %3d ", m_phaseID[i]);
writeline(' ', std::max(55-int(m_numElemConstraints)*8, 0), false);
plogf("%12.5E %12.5E", RT * m_SSfeSpecies[i], m_molNumSpecies_old[i]);
if (m_speciesUnknownType[i] == VCS_SPECIES_TYPE_MOLNUM) {
plogf(" Mol_Num");
} else if (m_speciesUnknownType[i] == VCS_SPECIES_TYPE_INTERFACIALVOLTAGE) {
plogf(" Voltage");
} else {
plogf(" Unknown");
}
plogendl();
}
}
for (size_t i = 0; i < m_numSpeciesTot; ++i) {
if (m_molNumSpecies_old[i] < 0.0) {
plogf("On Input species %-12s has a negative MF, setting it small",
m_speciesName[i]);
plogendl();
size_t iph = m_phaseID[i];
double tmp = m_tPhaseMoles_old[iph] * VCS_RELDELETE_SPECIES_CUTOFF * 10;
tmp = std::max(tmp, VCS_DELETE_MINORSPECIES_CUTOFF*10.);
m_molNumSpecies_old[i] = tmp;
}
}
/*
* Evaluate the total moles of species in the problem
*/
vcs_tmoles();
/*
* Evaluate all chemical potentials at the old mole numbers at the
* outset of the calculation.
*/
vcs_setFlagsVolPhases(false, VCS_STATECALC_OLD);
vcs_dfe(VCS_STATECALC_OLD, 0, 0, m_numSpeciesRdc);
bool lec;
while (true) {
if (stage == MAIN) {
/* *********************************************************** */
/* **** DETERMINE BASIS SPECIES, EVALUATE STOICHIOMETRY ****** */
/* *********************************************************** */
if (forceComponentCalc) {
int retn = solve_tp_component_calc(allMinorZeroedSpecies);
if (retn != VCS_SUCCESS) {
return retn;
}
it1 = 1;
forceComponentCalc = 0;
iti = 0;
}
/*
* Check on too many iterations.
* If we have too many iterations, Clean up and exit code even though we haven't
* converged. -> we have run out of iterations!
*/
if (m_VCount->Its > maxit) {
return -1;
}
solve_tp_inner(iti, it1, uptodate_minors, allMinorZeroedSpecies,
forceComponentCalc, stage, printDetails, ANOTE);
lec = false;
} else if (stage == EQUILIB_CHECK) {
/*************************************************************************/
/***************** EQUILIBRIUM CHECK FOR MAJOR SPECIES *******************/
/*************************************************************************/
solve_tp_equilib_check(allMinorZeroedSpecies, uptodate_minors,
giveUpOnElemAbund, solveFail, iti, it1,
maxit, stage, lec);
} else if (stage == ELEM_ABUND_CHECK) {
/* *************************************************** */
/* **** CORRECT ELEMENTAL ABUNDANCES ***************** */
/* *************************************************** */
solve_tp_elem_abund_check(iti, stage, lec, giveUpOnElemAbund,
finalElemAbundAttempts, rangeErrorFound);
} else if (stage == RECHECK_DELETED) {
/* *************************************************** */
/* **** RECHECK DELETED SPECIES ********************** */
/* *************************************************** */
/*
* We are here for two reasons. One is if we have
* achieved convergence, but some species have been eliminated
* from the problem because they were in multispecies phases
* and their mole fractions drifted less than
* VCS_DELETE_SPECIES_CUTOFF .
* The other reason why we are here is because all of the
* non-component species in the problem have been eliminated
* for one reason or another.
*/
npb = vcs_recheck_deleted();
/*
* If we haven't found any species that needed adding we are done.
*/
if (npb <= 0) {
stage = RETURN_B;
} else {
/*
* If we have found something to add, recalculate everything
* for minor species and go back to do a full iteration
*/
vcs_setFlagsVolPhases(false, VCS_STATECALC_OLD);
vcs_dfe(VCS_STATECALC_OLD, 1, 0, m_numSpeciesRdc);
vcs_deltag(0, false, VCS_STATECALC_OLD);
iti = 0;
stage = MAIN;
}
} else if (stage == RETURN_A) {
/*************************************************************************/
/******************** CLEANUP AND RETURN BLOCK ***************************/
/*************************************************************************/
npb = vcs_recheck_deleted();
/*
* If we haven't found any species that needed adding we are done.
*/
if (npb > 0) {
/*
* If we have found something to add, recalculate everything
* for minor species and go back to do a full iteration
*/
vcs_setFlagsVolPhases(false, VCS_STATECALC_OLD);
vcs_dfe(VCS_STATECALC_OLD, 1, 0, m_numSpeciesRdc);
vcs_deltag(0, false, VCS_STATECALC_OLD);
iti = 0;
stage = MAIN;
} else {
stage = RETURN_B;
}
} else if (stage == RETURN_B) {
/*
* Add back deleted species in non-zeroed phases. Estimate their
* mole numbers.
*/
npb = vcs_add_all_deleted();
if (npb > 0) {
iti = 0;
if (DEBUG_MODE_ENABLED && m_debug_print_lvl >= 1) {
plogf(" --- add_all_deleted(): some rxns not converged. RETURNING TO LOOP!");
plogendl();
}
stage = MAIN;
} else {
break;
}
}
}
/*
* Make sure the volume phase objects hold the same state and
* information as the vcs object. This also update the Cantera objects
* with this information.
*/
vcs_updateVP(VCS_STATECALC_OLD);
/*
* Evaluate the final mole fractions
* storing them in wt[]
*/
m_molNumSpecies_new.assign(m_molNumSpecies_new.size(), 0.0);
for (size_t kspec = 0; kspec < m_numSpeciesTot; ++kspec) {
if (m_SSPhase[kspec]) {
m_molNumSpecies_new[kspec] = 1.0;
} else {
size_t iph = m_phaseID[kspec];
if (m_tPhaseMoles_old[iph] != 0.0) {
m_molNumSpecies_new[kspec] = m_molNumSpecies_old[kspec] / m_tPhaseMoles_old[iph];
} else {
/*
* For MultiSpecies phases that are zeroed out,
* return the mole fraction vector from the VolPhase object.
* This contains the mole fraction that would be true if
* the phase just pops into existence.
*/
size_t i = m_speciesLocalPhaseIndex[kspec];
m_molNumSpecies_new[kspec] = m_VolPhaseList[iph]->molefraction(i);
}
}
}
// Return an error code if a Range Space Error is thought to have occurred.
if (rangeErrorFound) {
solveFail = 1;
}
/*
* Calculate counters
*/
double tsecond = ticktock.secondsWC();
m_VCount->Time_vcs_TP = tsecond;
m_VCount->T_Time_vcs_TP += m_VCount->Time_vcs_TP;
m_VCount->T_Calls_vcs_TP++;
m_VCount->T_Its += m_VCount->Its;
m_VCount->T_Basis_Opts += m_VCount->Basis_Opts;
m_VCount->T_Time_basopt += m_VCount->Time_basopt;
/*
* Return a Flag indicating whether convergence occurred
*/
return solveFail;
}
int VCS_SOLVE::solve_tp_component_calc(bool& allMinorZeroedSpecies)
{
double test = -1.0e-10;
bool usedZeroedSpecies;
int retn = vcs_basopt(false, &m_aw[0], &m_sa[0], &m_sm[0], &m_ss[0],
test, &usedZeroedSpecies);
if (retn != VCS_SUCCESS) {
return retn;
}
// Update the phase objects with the contents of the soln vector
vcs_updateVP(VCS_STATECALC_OLD);
vcs_deltag(0, false, VCS_STATECALC_OLD);
/*************************************************************************/
/************** EVALUATE INITIAL SPECIES STATUS VECTOR *******************/
/*************************************************************************/
allMinorZeroedSpecies = vcs_evaluate_speciesType();
/*************************************************************************/
/************** EVALUATE THE ELELEMT ABUNDANCE CHECK ******************/
/*************************************************************************/
if (! vcs_elabcheck(0)) {
if (DEBUG_MODE_ENABLED && m_debug_print_lvl >= 2) {
plogf(" --- Element Abundance check failed");
plogendl();
}
vcs_elcorr(&m_sm[0], &m_wx[0]);
vcs_setFlagsVolPhases(false, VCS_STATECALC_OLD);
vcs_dfe(VCS_STATECALC_OLD, 0, 0, m_numSpeciesRdc);
// Update the phase objects with the contents of the soln vector
vcs_updateVP(VCS_STATECALC_OLD);
vcs_deltag(0, false, VCS_STATECALC_OLD);
} else if (DEBUG_MODE_ENABLED && m_debug_print_lvl >= 2) {
plogf(" --- Element Abundance check passed");
plogendl();
}
return retn;
}
void VCS_SOLVE::solve_tp_inner(size_t& iti, size_t& it1,
bool& uptodate_minors,
bool& allMinorZeroedSpecies,
int& forceComponentCalc,
int& stage, bool printDetails, char* ANOTE)
{
if (iti == 0) {
/* ********************************************************* */
/* **** SET INITIAL VALUES FOR ITERATION ******************* */
/* **** EVALUATE REACTION ADJUSTMENTS ******************* */
/* ********************************************************* */
/*
* Evaluate the minor non-component species chemical
* potentials and delta G for their formation reactions
* We have already evaluated the major non-components
*/
if (!uptodate_minors) {
vcs_setFlagsVolPhases(false, VCS_STATECALC_OLD);
vcs_dfe(VCS_STATECALC_OLD, 1, 0, m_numSpeciesRdc);
vcs_deltag(1, false, VCS_STATECALC_OLD);
}
uptodate_minors = true;
} else {
uptodate_minors = false;
}
if (printDetails) {
plogf("\n");
writeline('=', 110);
plogf(" Iteration = %3d, Iterations since last evaluation of "
"optimal basis = %3d",
m_VCount->Its, it1 - 1);
if (iti == 0) {
plogf(" (all species)\n");
} else {
plogf(" (only major species)\n");
}
}
/*
* Calculate the total moles in each phase -> old solution
* -> Needed for numerical stability when phases disappear.
* -> the phase moles tend to drift off without this step.
*/
#ifdef DEBUG_MODE
check_tmoles();
#endif
vcs_tmoles();
/*************************************************************************/
/************** COPY OLD into NEW and ZERO VECTORS ***********************/
/*************************************************************************/
/*
* Copy the old solution into the new solution as an initial guess
*/
m_feSpecies_new = m_feSpecies_old;
m_actCoeffSpecies_new = m_actCoeffSpecies_old;
m_deltaGRxn_new = m_deltaGRxn_old;
m_deltaGRxn_Deficient = m_deltaGRxn_old;
m_tPhaseMoles_new = m_tPhaseMoles_old;
/*
* Zero out the entire vector of updates. We sometimes would
* query these values below, and we want to be sure that no
* information is left from previous iterations.
*/
m_deltaMolNumSpecies.assign(m_deltaMolNumSpecies.size(), 0.0);
/*************************************************************************/
/************** DETERMINE IF DEAD PHASES POP INTO EXISTENCE **************/
/*************************************************************************/
/*
* First step is a major branch in the algorithm.
* We first determine if a phase pops into existence.
*/
std::vector<size_t> phasePopPhaseIDs(0);
size_t iphasePop = vcs_popPhaseID(phasePopPhaseIDs);
if (iphasePop != npos) {
int soldel = vcs_popPhaseRxnStepSizes(iphasePop);
if (soldel == 3) {
iphasePop = npos;
if (DEBUG_MODE_ENABLED && m_debug_print_lvl >= 2) {
plogf(" --- vcs_popPhaseRxnStepSizes() was called but stoich "
"prevented phase %d popping\n");
}
}
}
/*************************************************************************/
/* DETERMINE THE REACTION STEP SIZES FOR MAIN STEP AND IF PHASES DIE *****/
/*************************************************************************/
/*
* Don't do this step if there is a phase pop
*/
size_t iphaseDelete = npos;
size_t kspec;
if (iphasePop == npos) {
/*
* Figure out the new reaction step sizes
* for the major species (do minor species in the future too)
*/
kspec = npos;
iphaseDelete = vcs_RxnStepSizes(forceComponentCalc, kspec);
} else if (DEBUG_MODE_ENABLED && m_debug_print_lvl >= 2) {
plogf(" --- vcs_RxnStepSizes not called because alternative"
"phase creation delta was used instead\n");
}
size_t doPhaseDeleteKspec = npos;
size_t doPhaseDeleteIph = npos;
/*
* Zero out the net change in moles of multispecies phases
*/
m_deltaPhaseMoles.assign(m_deltaPhaseMoles.size(), 0.0);
/* ********************************************************************** */
/* ***************** MAIN LOOP IN CALCULATION *************************** */
/* ***************** LOOP OVER IRXN TO DETERMINE STEP SIZE ************** */
/* ********************************************************************** */
/*
* Loop through all of the reactions, irxn, pertaining to the
* formation reaction for species kspec in canonical form.
*
* At the end of this loop, we will have a new estimate for the
* mole numbers for all species consistent with an extent
* of reaction for all noncomponent species formation
* reactions. We will have also ensured that all predicted
* non-component mole numbers are greater than zero.
*
* Old_Solution New_Solution Description
* -----------------------------------------------------------------------------
* m_molNumSpecies_old[kspec] m_molNumSpecies_new[kspec] Species Mole Numbers
* m_deltaMolNumSpecies[kspec] Delta in the Species Mole Numbers
*/
if (iphaseDelete != npos) {
if (DEBUG_MODE_ENABLED && m_debug_print_lvl >= 2) {
plogf(" --- Main Loop Treatment -> Circumvented due to Phase Deletion ");
plogendl();
}
for (size_t k = 0; k < m_numSpeciesTot; k++) {
m_molNumSpecies_new[k] = m_molNumSpecies_old[k] + m_deltaMolNumSpecies[k];
size_t iph = m_phaseID[k];
m_tPhaseMoles_new[iph] += m_deltaMolNumSpecies[k];
}
if (kspec >= m_numComponents) {
if (m_molNumSpecies_new[m_numSpeciesTot] != 0.0) {
throw CanteraError("VCS_SOLVE::solve_tp_inner",
"we shouldn't be here!");
}
if (m_SSPhase[kspec] == 1) {
m_speciesStatus[kspec] = VCS_SPECIES_ZEROEDSS;
} else {
throw CanteraError("VCS_SOLVE::solve_tp_inner",
"we shouldn't be here!");
}
++m_numRxnMinorZeroed;
allMinorZeroedSpecies = (m_numRxnMinorZeroed == m_numRxnRdc);
}
/*
* Set the flags indicating the mole numbers in the vcs_VolPhase
* objects are out of date.
*/
vcs_setFlagsVolPhases(false, VCS_STATECALC_NEW);
/*
* Calculate the new chemical potentials using the tentative
* solution values. We only calculate a subset of these, because
* we have only updated a subset of the W().
*/
vcs_dfe(VCS_STATECALC_NEW, 0, 0, m_numSpeciesTot);
/*
* Evaluate DeltaG for all components if ITI=0, and for
* major components only if ITI NE 0
*/
vcs_deltag(0, false, VCS_STATECALC_NEW);
} else {
if (DEBUG_MODE_ENABLED && m_debug_print_lvl >= 2) {
plogf(" --- Main Loop Treatment of each non-component species ");
if (iti == 0) {
plogf("- Full Calculation:\n");
} else {
plogf("- Major Components Calculation:\n");
}
plogf(" --- Species IC ");
plogf(" KMoles Tent_KMoles Rxn_Adj | Comment \n");
}
for (size_t irxn = 0; irxn < m_numRxnRdc; irxn++) {
size_t kspec = m_indexRxnToSpecies[irxn];
double* sc_irxn = m_stoichCoeffRxnMatrix.ptrColumn(irxn);
size_t iph = m_phaseID[kspec];
vcs_VolPhase* Vphase = m_VolPhaseList[iph];
if (DEBUG_MODE_ENABLED) {
ANOTE[0] = '\0';
}
double dx;
if (iphasePop != npos) {
if (iph == iphasePop) {
dx = m_deltaMolNumSpecies[kspec];
m_molNumSpecies_new[kspec] = m_molNumSpecies_old[kspec] + m_deltaMolNumSpecies[kspec];
if (DEBUG_MODE_ENABLED) {
sprintf(ANOTE, "Phase pop");
}
} else {
dx = 0.0;
m_molNumSpecies_new[kspec] = m_molNumSpecies_old[kspec];
}
} else if (m_speciesStatus[kspec] == VCS_SPECIES_INTERFACIALVOLTAGE) {
/********************************************************************/
/************************ VOLTAGE SPECIES ***************************/
/********************************************************************/
bool soldel_ret;
dx = vcs_minor_alt_calc(kspec, irxn, &soldel_ret, ANOTE);
m_deltaMolNumSpecies[kspec] = dx;
} else if (m_speciesStatus[kspec] < VCS_SPECIES_MINOR) {
/********************************************************************/
/********************** ZEROED OUT SPECIES **************************/
/********************************************************************/
bool resurrect = (m_deltaMolNumSpecies[kspec] > 0.0);
if (DEBUG_MODE_ENABLED && m_debug_print_lvl >= 3) {
plogf(" --- %s currently zeroed (SpStatus=%-2d):",
m_speciesName[kspec], m_speciesStatus[kspec]);
plogf("%3d DG = %11.4E WT = %11.4E W = %11.4E DS = %11.4E\n",
irxn, m_deltaGRxn_new[irxn], m_molNumSpecies_new[kspec],
m_molNumSpecies_old[kspec], m_deltaMolNumSpecies[kspec]);
}
if (m_deltaGRxn_new[irxn] >= 0.0 || !resurrect) {
m_molNumSpecies_new[kspec] = m_molNumSpecies_old[kspec];
m_deltaMolNumSpecies[kspec] = 0.0;
resurrect = false;
if (DEBUG_MODE_ENABLED) {
sprintf(ANOTE, "Species stays zeroed: DG = %11.4E", m_deltaGRxn_new[irxn]);
if (m_deltaGRxn_new[irxn] < 0.0) {
if (m_speciesStatus[kspec] == VCS_SPECIES_STOICHZERO) {
sprintf(ANOTE, "Species stays zeroed even though dg neg due to "
"STOICH/PHASEPOP constraint: DG = %11.4E",
m_deltaGRxn_new[irxn]);
} else {
sprintf(ANOTE, "Species stays zeroed even though dg neg: DG = %11.4E, ds zeroed",
m_deltaGRxn_new[irxn]);
}
}
}
} else {
for (size_t j = 0; j < m_numElemConstraints; ++j) {
int elType = m_elType[j];
if (elType == VCS_ELEM_TYPE_ABSPOS) {
double atomComp = m_formulaMatrix(kspec,j);
if (atomComp > 0.0) {
double maxPermissible = m_elemAbundancesGoal[j] / atomComp;
if (maxPermissible < VCS_DELETE_MINORSPECIES_CUTOFF) {
if (DEBUG_MODE_ENABLED) {
sprintf(ANOTE, "Species stays zeroed even though dG "
"neg, because of %s elemAbund",
m_elementName[j].c_str());
}
resurrect = false;
break;
}
}
}
}
}
/*
* Resurrect the species
*/
if (resurrect) {
if (Vphase->exists() == VCS_PHASE_EXIST_NO) {
if (DEBUG_MODE_ENABLED && m_debug_print_lvl >= 2) {
plogf(" --- Zeroed species changed to major: ");
plogf("%-12s\n", m_speciesName[kspec]);
}
m_speciesStatus[kspec] = VCS_SPECIES_MAJOR;
allMinorZeroedSpecies = false;
} else {
if (DEBUG_MODE_ENABLED && m_debug_print_lvl >= 2) {
plogf(" --- Zeroed species changed to minor: ");
plogf("%-12s\n", m_speciesName[kspec]);
}
m_speciesStatus[kspec] = VCS_SPECIES_MINOR;
}
if (m_deltaMolNumSpecies[kspec] > 0.0) {
dx = m_deltaMolNumSpecies[kspec] * 0.01;
m_molNumSpecies_new[kspec] = m_molNumSpecies_old[kspec] + dx;
} else {
m_molNumSpecies_new[kspec] = m_totalMolNum * VCS_DELETE_PHASE_CUTOFF * 10.;
dx = m_molNumSpecies_new[kspec] - m_molNumSpecies_old[kspec];
}
m_deltaMolNumSpecies[kspec] = dx;
if (DEBUG_MODE_ENABLED) {
sprintf(ANOTE, "Born:IC=-1 to IC=1:DG=%11.4E", m_deltaGRxn_new[irxn]);
}
} else {
m_molNumSpecies_new[kspec] = m_molNumSpecies_old[kspec];
m_deltaMolNumSpecies[kspec] = 0.0;
dx = 0.0;
}
} else if (m_speciesStatus[kspec] == VCS_SPECIES_MINOR) {
/********************************************************************/
/***************************** MINOR SPECIES ************************/
/********************************************************************/
/*
* Unless ITI isn't equal to zero we zero out changes
* to minor species.
*/
if (iti != 0) {
m_molNumSpecies_new[kspec] = m_molNumSpecies_old[kspec];
m_deltaMolNumSpecies[kspec] = 0.0;
dx = 0.0;
if (DEBUG_MODE_ENABLED) {
sprintf(ANOTE,"minor species not considered");
if (m_debug_print_lvl >= 2) {
plogf(" --- ");
plogf("%-12s", m_speciesName[kspec]);
plogf("%3d%11.4E%11.4E%11.4E | %s",
m_speciesStatus[kspec], m_molNumSpecies_old[kspec], m_molNumSpecies_new[kspec],
m_deltaMolNumSpecies[kspec], ANOTE);
plogendl();
}
}
continue;
}
/*
* Minor species alternative calculation
* ---------------------------------------
* This is based upon the following approximation:
* The mole fraction changes due to these reactions don't affect
* the mole numbers of the component species. Therefore the
* following approximation is valid for an ideal solution
* 0 = DG(I) + log(WT(I)/W(I))
* (DG contains the contribution from FF(I) + log(W(I)/TL) )
* Thus,
* WT(I) = W(I) EXP(-DG(I))
* If soldel is true on return, then we branch to the section
* that deletes a species from the current set of active species.
*/
bool soldel_ret;
dx = vcs_minor_alt_calc(kspec, irxn, &soldel_ret, ANOTE);
m_deltaMolNumSpecies[kspec] = dx;
m_molNumSpecies_new[kspec] = m_molNumSpecies_old[kspec] + dx;
if (soldel_ret) {
/*******************************************************************/
/***** DELETE MINOR SPECIES LESS THAN VCS_DELETE_SPECIES_CUTOFF */
/***** MOLE NUMBER */
/*******************************************************************/
if (DEBUG_MODE_ENABLED && m_debug_print_lvl >= 2) {
plogf(" --- Delete minor species in multispec phase: %-12s",
m_speciesName[kspec]);
plogendl();
}
m_deltaMolNumSpecies[kspec] = 0.0;
/*
* Delete species, kspec. The alternate return is for the case
* where all species become deleted. Then, we need to
* branch to the code where we reevaluate the deletion
* of all species.
*/
size_t lnospec = vcs_delete_species(kspec);
if (lnospec) {
stage = RECHECK_DELETED;
break;
}
/*
* Go back to consider the next species in the list.
* Note, however, that the next species in the list is now
* in slot l. In deleting the previous species L, We have
* exchanged slot MR with slot l, and then have
* decremented MR.
* Therefore, we will decrement the species counter, here.
*/
--irxn;
continue;
}
} else {
/********************************************************************/
/*********************** MAJOR SPECIES ******************************/
/********************************************************************/
if (DEBUG_MODE_ENABLED) {
sprintf(ANOTE, "Normal Major Calc");
}
/*
* Check for superconvergence of the formation reaction. Do
* nothing if it is superconverged. Skip to the end of the
* irxn loop if it is superconverged.
*/
if (fabs(m_deltaGRxn_new[irxn]) <= m_tolmaj2) {
m_molNumSpecies_new[kspec] = m_molNumSpecies_old[kspec];
m_deltaMolNumSpecies[kspec] = 0.0;
dx = 0.0;
if (DEBUG_MODE_ENABLED) {
sprintf(ANOTE, "major species is converged");
if (m_debug_print_lvl >= 2) {
plogf(" --- ");
plogf("%-12s", m_speciesName[kspec]);
plogf("%3d%11.4E%11.4E%11.4E | %s",
m_speciesStatus[kspec], m_molNumSpecies_old[kspec], m_molNumSpecies_new[kspec],
m_deltaMolNumSpecies[kspec], ANOTE);
plogendl();
}
}
continue;
}
/*
* Set the initial step size, dx, equal to the value produced
* by the routine, vcs_RxnStepSize().
*
* Note the multiplication logic is to make sure that
* dg[] didn't change sign due to w[] changing in the
* middle of the iteration. (it can if a single species
* phase goes out of existence).
*/
if ((m_deltaGRxn_new[irxn] * m_deltaMolNumSpecies[kspec]) <= 0.0) {
dx = m_deltaMolNumSpecies[kspec];
} else {
dx = 0.0;
m_deltaMolNumSpecies[kspec] = 0.0;
if (DEBUG_MODE_ENABLED) {
sprintf(ANOTE, "dx set to 0, DG flipped sign due to "
"changed initial point");
}
}
/*
* Form a tentative value of the new species moles
*/
m_molNumSpecies_new[kspec] = m_molNumSpecies_old[kspec] + dx;
/*
* Check for non-positive mole fraction of major species.
* If we find one, we branch to a section below. Then,
* depending upon the outcome, we branch to sections below,
* or we restart the entire iteration.
*/
if (m_molNumSpecies_new[kspec] <= 0.0) {
if (DEBUG_MODE_ENABLED) {
sprintf(ANOTE, "initial nonpos kmoles= %11.3E",
m_molNumSpecies_new[kspec]);
}
/* ************************************************* */
/* *** NON-POSITIVE MOLES OF MAJOR SPECIES ********* */
/* ************************************************* */
/*
* We are here when a tentative value of a mole fraction
* created by a tentative value of M_DELTAMOLNUMSPECIES(*) is negative.
* We branch from here depending upon whether this
* species is in a single species phase or in
* a multispecies phase.
*/
if (!m_SSPhase[kspec]) {
/*
* Section for multispecies phases:
* - Cut reaction adjustment for positive kmoles of
* major species in multispecies phases.
* Decrease its concentration by a factor of 10.
*/
dx = -0.9 * m_molNumSpecies_old[kspec];
m_deltaMolNumSpecies[kspec] = dx;
m_molNumSpecies_new[kspec] = m_molNumSpecies_old[kspec] + dx;
} else {
/*
* Section for single species phases:
* Calculate a dx that will wipe out the
* moles in the phase.
*/
dx = -m_molNumSpecies_old[kspec];
/*
* Calculate an update that doesn't create a negative mole
* number for a component species. Actually, restrict this
* a little more so that the component values can only be
* reduced by two 99%,
*/
for (size_t j = 0; j < m_numComponents; ++j) {
if (sc_irxn[j] != 0.0) {
m_wx[j] = m_molNumSpecies_old[j] + sc_irxn[j] * dx;
if (m_wx[j] <= m_molNumSpecies_old[j] * 0.01 - 1.0E-150) {
dx = std::max(dx, m_molNumSpecies_old[j] * -0.99 / sc_irxn[j]);
}
} else {
m_wx[j] = m_molNumSpecies_old[j];
}
}
m_molNumSpecies_new[kspec] = m_molNumSpecies_old[kspec] + dx;
if (m_molNumSpecies_new[kspec] > 0.0) {
m_deltaMolNumSpecies[kspec] = dx;
if (DEBUG_MODE_ENABLED) {
sprintf(ANOTE,
"zeroing SS phase created a neg component species "
"-> reducing step size instead");
}
} else {
/*
* We are going to zero the single species phase.
* Set the existence flag
*/
iph = m_phaseID[kspec];
Vphase = m_VolPhaseList[iph];
if (DEBUG_MODE_ENABLED) {
sprintf(ANOTE, "zeroing out SS phase: ");
}
/*
* Change the base mole numbers for the iteration.
* We need to do this here, because we have decided
* to eliminate the phase in this special section
* outside the main loop.
*/
m_molNumSpecies_new[kspec] = 0.0;
doPhaseDeleteIph = iph;
if (DEBUG_MODE_ENABLED) {
doPhaseDeleteKspec = kspec;
if (m_debug_print_lvl >= 2 && m_speciesStatus[kspec] >= 0) {
plogf(" --- SS species changed to zeroedss: ");
plogf("%-12s", m_speciesName[kspec]);
plogendl();
}
}
m_speciesStatus[kspec] = VCS_SPECIES_ZEROEDSS;
++m_numRxnMinorZeroed;
allMinorZeroedSpecies = (m_numRxnMinorZeroed == m_numRxnRdc);
for (size_t kk = 0; kk < m_numSpeciesTot; kk++) {
m_deltaMolNumSpecies[kk] = 0.0;
m_molNumSpecies_new[kk] = m_molNumSpecies_old[kk];
}
m_deltaMolNumSpecies[kspec] = dx;
m_molNumSpecies_new[kspec] = 0.0;
for (size_t k = 0; k < m_numComponents; ++k) {
m_deltaMolNumSpecies[k] = 0.0;
}
for (iph = 0; iph < m_numPhases; iph++) {
m_deltaPhaseMoles[iph] = 0.0;
}
}
}
}
} /* End of Loop on ic[irxn] -> the type of species */
/***********************************************************************/
/****** CALCULATE KMOLE NUMBER CHANGE FOR THE COMPONENT BASIS **********/
/***********************************************************************/
if (dx != 0.0 && (m_speciesUnknownType[kspec] !=
VCS_SPECIES_TYPE_INTERFACIALVOLTAGE)) {
/*
* Change the amount of the component compounds according
* to the reaction delta that we just computed.
* This should keep the amount of material constant.
*/
AssertThrowMsg(fabs(m_deltaMolNumSpecies[kspec] -dx) <
1.0E-14*(fabs(m_deltaMolNumSpecies[kspec]) + fabs(dx) + 1.0E-32),
"VCS_SOLVE::solve_tp_inner",
"ds[kspec] = " + fp2str(m_deltaMolNumSpecies[kspec]) +
" dx = " + fp2str(dx) + " , kspec = " + int2str(kspec) +
"\nwe have a problem!");
for (size_t k = 0; k < m_numComponents; ++k) {
m_deltaMolNumSpecies[k] += sc_irxn[k] * dx;
}
/*
* Calculate the tentative change in the total number of
* moles in all of the phases
*/
for (iph = 0; iph < m_numPhases; iph++) {
m_deltaPhaseMoles[iph] += dx * m_deltaMolNumPhase(iph,irxn);
}
}
if (DEBUG_MODE_ENABLED) {
checkDelta1(&m_deltaMolNumSpecies[0],
&m_deltaPhaseMoles[0], kspec+1);
}
/*
* Branch point for returning -
*/
if (m_debug_print_lvl >= 2) {
m_molNumSpecies_new[kspec] = m_molNumSpecies_old[kspec] + m_deltaMolNumSpecies[kspec];
plogf(" --- ");
plogf("%-12.12s", m_speciesName[kspec]);
plogf("%3d%11.4E%11.4E%11.4E | %s",
m_speciesStatus[kspec], m_molNumSpecies_old[kspec],
m_molNumSpecies_new[kspec],
m_deltaMolNumSpecies[kspec], ANOTE);
plogendl();
}
if (doPhaseDeleteIph != npos) {
if (DEBUG_MODE_ENABLED && m_debug_print_lvl >= 2) {
plogf(" --- ");
plogf("%-12.12s Main Loop Special Case deleting phase with species: ",
m_speciesName[doPhaseDeleteKspec]);
plogendl();
}
break;
}
} /**************** END OF MAIN LOOP OVER FORMATION REACTIONS ************/
if (DEBUG_MODE_ENABLED && m_debug_print_lvl >= 2) {
for (size_t k = 0; k < m_numComponents; k++) {
plogf(" --- ");
plogf("%-12.12s", m_speciesName[k]);
plogf(" c%11.4E%11.4E%11.4E |\n",
m_molNumSpecies_old[k],
m_molNumSpecies_old[k]+m_deltaMolNumSpecies[k], m_deltaMolNumSpecies[k]);
}
plogf(" ");
writeline('-', 80);
plogf(" --- Finished Main Loop");
plogendl();
}
/*************************************************************************/
/*********** LIMIT REDUCTION OF BASIS SPECIES TO 99% *********************/
/*************************************************************************/
/*
* We have a tentative m_deltaMolNumSpecies[]. Now apply other criteria
* to limit its magnitude.
*/
double par = 0.5;
size_t ll; // only used in DEBUG_MODE
for (size_t k = 0; k < m_numComponents; ++k) {
if (m_molNumSpecies_old[k] > 0.0) {
double xx = -m_deltaMolNumSpecies[k] / m_molNumSpecies_old[k];
if (par < xx) {
par = xx;
ll = k;
}
} else if (m_deltaMolNumSpecies[k] < 0.0) {
/*
* If we are here, we then do a step which violates element
* conservation.
*/
size_t iph = m_phaseID[k];
m_deltaPhaseMoles[iph] -= m_deltaMolNumSpecies[k];
m_deltaMolNumSpecies[k] = 0.0;
}
}
par = 1.0 / par;
if (par <= 1.01 && par > 0.0) {
/* Reduce the size of the step by the multiplicative factor, par */
par *= 0.99;
if (DEBUG_MODE_ENABLED && m_debug_print_lvl >= 2) {
plogf(" --- Reduction in step size due to component ");
plogf("%s", m_speciesName[ll]);
plogf(" going negative = %11.3E", par);
plogendl();
}
for (size_t i = 0; i < m_numSpeciesTot; ++i) {
m_deltaMolNumSpecies[i] *= par;
}
for (size_t iph = 0; iph < m_numPhases; iph++) {
m_deltaPhaseMoles[iph] *= par;
}
} else {
par = 1.0;
}
if (DEBUG_MODE_ENABLED) {
checkDelta1(&m_deltaMolNumSpecies[0],
&m_deltaPhaseMoles[0], m_numSpeciesTot);
}
/*
* Now adjust the wt[kspec]'s so that the reflect the decrease in
* the overall length of m_deltaMolNumSpecies[kspec] just calculated. At the end
* of this section wt[], m_deltaMolNumSpecies[], tPhMoles, and tPhMoles1 should all be
* consistent with a new estimate of the state of the system.
*/
for (size_t kspec = 0; kspec < m_numSpeciesTot; ++kspec) {
m_molNumSpecies_new[kspec] = m_molNumSpecies_old[kspec] + m_deltaMolNumSpecies[kspec];
if (m_molNumSpecies_new[kspec] < 0.0 && (m_speciesUnknownType[kspec]
!= VCS_SPECIES_TYPE_INTERFACIALVOLTAGE)) {
throw CanteraError("VCS_SOLVE::solve_tp_inner",
"vcs_solve_TP: ERROR on step change wt[{}:{}]: {} < 0.0",
kspec, m_speciesName[kspec], m_molNumSpecies_new[kspec]);
}
}
/*
* Calculate the tentative total mole numbers for each phase
*/
for (size_t iph = 0; iph < m_numPhases; iph++) {
m_tPhaseMoles_new[iph] = m_tPhaseMoles_old[iph] + m_deltaPhaseMoles[iph];
}
/*
* Set the flags indicating the mole numbers in the vcs_VolPhase
* objects are out of date.
*/
vcs_setFlagsVolPhases(false, VCS_STATECALC_NEW);
/*
* Calculate the new chemical potentials using the tentative
* solution values. We only calculate a subset of these, because
* we have only updated a subset of the W().
*/
vcs_dfe(VCS_STATECALC_NEW, 0, 0, m_numSpeciesTot);
/*
* Evaluate DeltaG for all components if ITI=0, and for
* major components only if ITI NE 0
*/
vcs_deltag(0, false, VCS_STATECALC_NEW);
/* *************************************************************** */
/* **** CONVERGENCE FORCER SECTION ******************************* */
/* *************************************************************** */
if (printDetails) {
plogf(" --- Total Old Dimensionless Gibbs Free Energy = %20.13E\n",
vcs_Total_Gibbs(&m_molNumSpecies_old[0], &m_feSpecies_old[0],
&m_tPhaseMoles_old[0]));
plogf(" --- Total tentative Dimensionless Gibbs Free Energy = %20.13E",
vcs_Total_Gibbs(&m_molNumSpecies_new[0], &m_feSpecies_new[0],
&m_tPhaseMoles_new[0]));
plogendl();
}
bool forced = vcs_globStepDamp();
/*
* Print out the changes to the solution that FORCER produced
*/
if (printDetails && forced) {
plogf(" -----------------------------------------------------\n");
plogf(" --- FORCER SUBROUTINE changed the solution:\n");
plogf(" --- SPECIES Status INIT MOLES TENT_MOLES");
plogf(" FINAL KMOLES INIT_DEL_G/RT TENT_DEL_G/RT FINAL_DELTA_G/RT\n");
for (size_t i = 0; i < m_numComponents; ++i) {
plogf(" --- %-12.12s", m_speciesName[i]);
plogf(" %14.6E %14.6E %14.6E\n", m_molNumSpecies_old[i],
m_molNumSpecies_old[i] + m_deltaMolNumSpecies[i], m_molNumSpecies_new[i]);
}
for (size_t kspec = m_numComponents; kspec < m_numSpeciesRdc; ++kspec) {
size_t irxn = kspec - m_numComponents;
plogf(" --- %-12.12s", m_speciesName[kspec]);
plogf(" %2d %14.6E%14.6E%14.6E%14.6E%14.6E%14.6E\n", m_speciesStatus[kspec],
m_molNumSpecies_old[kspec],
m_molNumSpecies_old[kspec]+m_deltaMolNumSpecies[kspec],
m_molNumSpecies_new[kspec], m_deltaGRxn_old[irxn],
m_deltaGRxn_tmp[irxn], m_deltaGRxn_new[irxn]);
}
writeline(' ', 26, false);
plogf("Norms of Delta G():%14.6E%14.6E\n",
l2normdg(&m_deltaGRxn_old[0]),
l2normdg(&m_deltaGRxn_new[0]));
plogf(" Total kmoles of gas = %15.7E\n", m_tPhaseMoles_old[0]);
if ((m_numPhases > 1) && (!m_VolPhaseList[1]->m_singleSpecies)) {
plogf(" Total kmoles of liquid = %15.7E\n", m_tPhaseMoles_old[1]);
} else {
plogf(" Total kmoles of liquid = %15.7E\n", 0.0);
}
plogf(" Total New Dimensionless Gibbs Free Energy = %20.13E\n",
vcs_Total_Gibbs(&m_molNumSpecies_new[0], &m_feSpecies_new[0],
&m_tPhaseMoles_new[0]));
plogf(" -----------------------------------------------------");
plogendl();
}
}
/* *************************************************************** */
/* **** ITERATION SUMMARY PRINTOUT SECTION *********************** */
/* *************************************************************** */
if (printDetails) {
plogf(" ");
writeline('-', 103);
plogf(" --- Summary of the Update ");
if (iti == 0) {
plogf(" (all species):");
} else {
plogf(" (only major species):");
}
if (m_totalMoleScale != 1.0) {
plogf(" (Total Mole Scale = %g)", m_totalMoleScale);
}
plogf("\n");
plogf(" --- Species Status Initial_KMoles Final_KMoles Initial_Mu/RT");
plogf(" Mu/RT Init_Del_G/RT Delta_G/RT\n");
for (size_t i = 0; i < m_numComponents; ++i) {
plogf(" --- %-12.12s", m_speciesName[i]);
plogf(" ");
plogf("%14.6E%14.6E%14.6E%14.6E\n", m_molNumSpecies_old[i],
m_molNumSpecies_new[i], m_feSpecies_old[i], m_feSpecies_new[i]);
}
for (size_t i = m_numComponents; i < m_numSpeciesRdc; ++i) {
size_t l1 = i - m_numComponents;
plogf(" --- %-12.12s", m_speciesName[i]);
plogf(" %2d %14.6E%14.6E%14.6E%14.6E%14.6E%14.6E\n",
m_speciesStatus[i], m_molNumSpecies_old[i],
m_molNumSpecies_new[i], m_feSpecies_old[i], m_feSpecies_new[i],
m_deltaGRxn_old[l1], m_deltaGRxn_new[l1]);
}
for (size_t kspec = m_numSpeciesRdc; kspec < m_numSpeciesTot; ++kspec) {
size_t l1 = kspec - m_numComponents;
plogf(" --- %-12.12s", m_speciesName[kspec]);
plogf(" %2d %14.6E%14.6E%14.6E%14.6E%14.6E%14.6E\n",
m_speciesStatus[kspec], m_molNumSpecies_old[kspec],
m_molNumSpecies_new[kspec], m_feSpecies_old[kspec], m_feSpecies_new[kspec],
m_deltaGRxn_old[l1], m_deltaGRxn_new[l1]);
}
plogf(" ---");
writeline(' ', 56, false);
plogf("Norms of Delta G():%14.6E%14.6E",
l2normdg(&m_deltaGRxn_old[0]),
l2normdg(&m_deltaGRxn_new[0]));
plogendl();
plogf(" --- Phase_Name KMoles(after update)\n");
plogf(" --- ");
writeline('-', 50);
for (size_t iph = 0; iph < m_numPhases; iph++) {
vcs_VolPhase* Vphase = m_VolPhaseList[iph];
plogf(" --- %18s = %15.7E\n", Vphase->PhaseName, m_tPhaseMoles_new[iph]);
}
plogf(" ");
writeline('-', 103);
plogf(" --- Total Old Dimensionless Gibbs Free Energy = %20.13E\n",
vcs_Total_Gibbs(&m_molNumSpecies_old[0], &m_feSpecies_old[0],
&m_tPhaseMoles_old[0]));
plogf(" --- Total New Dimensionless Gibbs Free Energy = %20.13E",
vcs_Total_Gibbs(&m_molNumSpecies_new[0], &m_feSpecies_new[0],
&m_tPhaseMoles_new[0]));
plogendl();
if (DEBUG_MODE_ENABLED && m_VCount->Its > 550) {
plogf(" --- Troublesome solve");
plogendl();
}
}
/*************************************************************************/
/******************* RESET VALUES AT END OF ITERATION ********************/
/******************* UPDATE MOLE NUMBERS *********************************/
/*************************************************************************/
/*
* If the solution wasn't changed in the forcer routine,
* then copy the tentative mole numbers and Phase moles
* into the actual mole numbers and phase moles.
* We will consider this current step to be completed.
*
* Accept the step. -> the tentative solution now becomes
* the real solution. If FORCED is true, then
* we have already done this inside the FORCED
* loop.
*/
vcs_updateMolNumVolPhases(VCS_STATECALC_NEW);
m_tPhaseMoles_old = m_tPhaseMoles_new;
m_molNumSpecies_old = m_molNumSpecies_new;
m_actCoeffSpecies_old = m_actCoeffSpecies_new;
m_deltaGRxn_old = m_deltaGRxn_new;
m_feSpecies_old = m_feSpecies_new;
vcs_setFlagsVolPhases(true, VCS_STATECALC_OLD);
/*
* Increment the iteration counters
*/
++m_VCount->Its;
++it1;
if (DEBUG_MODE_ENABLED && m_debug_print_lvl >= 2) {
plogf(" --- Increment counter increased, step is accepted: %4d",
m_VCount->Its);
plogendl();
}
/*************************************************************************/
/******************* HANDLE DELETION OF MULTISPECIES PHASES **************/
/*************************************************************************/
/*
* We delete multiphases, when the total moles in the multiphase
* is reduced below a relative threshold.
* Set microscopic multispecies phases with total relative
* number of moles less than VCS_DELETE_PHASE_CUTOFF to
* absolute zero.
*/
bool justDeletedMultiPhase = false;
for (size_t iph = 0; iph < m_numPhases; iph++) {
if (!m_VolPhaseList[iph]->m_singleSpecies && m_tPhaseMoles_old[iph] != 0.0 &&
m_tPhaseMoles_old[iph]/m_totalMolNum <= VCS_DELETE_PHASE_CUTOFF) {
if (DEBUG_MODE_ENABLED && m_debug_print_lvl >= 1) {
plogf(" --- Setting microscopic phase %d to zero", iph);
plogendl();
}
justDeletedMultiPhase = true;
vcs_delete_multiphase(iph);
}
}
/*
* If we have deleted a multispecies phase because the
* equilibrium moles decreased, then we will update all
* the component basis calculation, and therefore all
* of the thermo functions just to be safe.
*/
if (justDeletedMultiPhase) {
bool usedZeroedSpecies;
double test = -1.0e-10;
int retn = vcs_basopt(false, &m_aw[0], &m_sa[0], &m_sm[0], &m_ss[0],
test, &usedZeroedSpecies);
if (retn != VCS_SUCCESS) {
throw CanteraError("VCS_SOLVE::solve_tp_inner",
"BASOPT returned with an error condition");
}
vcs_setFlagsVolPhases(false, VCS_STATECALC_OLD);
vcs_dfe(VCS_STATECALC_OLD, 0, 0, m_numSpeciesRdc);
vcs_deltag(0, true, VCS_STATECALC_OLD);
iti = 0;
return;
}
/*************************************************************************/
/***************** CHECK FOR ELEMENT ABUNDANCE****************************/
/*************************************************************************/
if (DEBUG_MODE_ENABLED && m_debug_print_lvl >= 2) {
plogf(" --- Normal element abundance check");
}
vcs_elab();
if (! vcs_elabcheck(0)) {
if (DEBUG_MODE_ENABLED && m_debug_print_lvl >= 2) {
plogf(" - failed -> redoing element abundances.");
plogendl();
}
vcs_elcorr(&m_sm[0], &m_wx[0]);
vcs_setFlagsVolPhases(false, VCS_STATECALC_OLD);
vcs_dfe(VCS_STATECALC_OLD, 0, 0, m_numSpeciesRdc);
vcs_deltag(0, true, VCS_STATECALC_OLD);
uptodate_minors = true;
} else if (DEBUG_MODE_ENABLED && m_debug_print_lvl >= 2) {
plogf(" - passed");
plogendl();
}
/*************************************************************************/
/***************** CHECK FOR OPTIMUM BASIS *******************************/
/*************************************************************************/
for (size_t i = 0; i < m_numRxnRdc; ++i) {
size_t l = m_indexRxnToSpecies[i];
if (m_speciesUnknownType[l] == VCS_SPECIES_TYPE_INTERFACIALVOLTAGE) {
continue;
}
for (size_t j = 0; j < m_numComponents; ++j) {
bool doSwap = false;
if (m_SSPhase[j]) {
doSwap = (m_molNumSpecies_old[l] * m_spSize[l]) >
(m_molNumSpecies_old[j] * m_spSize[j] * 1.01);
if (!m_SSPhase[l] && doSwap) {
doSwap = m_molNumSpecies_old[l] > (m_molNumSpecies_old[j] * 1.01);
}
} else {
if (m_SSPhase[l]) {
doSwap = (m_molNumSpecies_old[l] * m_spSize[l]) >
(m_molNumSpecies_old[j] * m_spSize[j] * 1.01);
if (!doSwap) {
doSwap = m_molNumSpecies_old[l] > (m_molNumSpecies_old[j] * 1.01);
}
} else {
doSwap = (m_molNumSpecies_old[l] * m_spSize[l]) >
(m_molNumSpecies_old[j] * m_spSize[j] * 1.01);
}
}
if (doSwap && m_stoichCoeffRxnMatrix(j,i) != 0.0) {
if (DEBUG_MODE_ENABLED && m_debug_print_lvl >= 2) {
plogf(" --- Get a new basis because ");
plogf("%s", m_speciesName[l]);
plogf(" is better than comp ");
plogf("%s", m_speciesName[j]);
plogf(" and share nonzero stoic: %-9.1f",
m_stoichCoeffRxnMatrix(j,i));
plogendl();
}
forceComponentCalc = 1;
return;
}
}
}
if (DEBUG_MODE_ENABLED && m_debug_print_lvl >= 2) {
plogf(" --- Check for an optimum basis passed");
plogendl();
}
stage = EQUILIB_CHECK;
/*************************************************************************/
/********************** RE-EVALUATE MAJOR-MINOR VECTOR IF NECESSARY ******/
/*************************************************************************/
/*
* Skip this section if we haven't done a full calculation.
* Go right to the check equilibrium section
*/
if (iti != 0) {
return;
}
if (DEBUG_MODE_ENABLED && m_debug_print_lvl >= 2) {
plogf(" --- Reevaluate major-minor status of noncomponents:\n");
}
m_numRxnMinorZeroed = 0;
for (size_t irxn = 0; irxn < m_numRxnRdc; irxn++) {
size_t kspec = m_indexRxnToSpecies[irxn];
int speciesType = vcs_species_type(kspec);
if (speciesType < VCS_SPECIES_MINOR) {
if (DEBUG_MODE_ENABLED && m_debug_print_lvl >= 2 && m_speciesStatus[kspec] >= VCS_SPECIES_MINOR) {
plogf(" --- major/minor species is now zeroed out: %s\n",
m_speciesName[kspec]);
}
++m_numRxnMinorZeroed;
} else if (speciesType == VCS_SPECIES_MINOR) {
if (DEBUG_MODE_ENABLED && m_debug_print_lvl >= 2 && m_speciesStatus[kspec] != VCS_SPECIES_MINOR) {
if (m_speciesStatus[kspec] == VCS_SPECIES_MAJOR) {
plogf(" --- Noncomponent turned from major to minor: ");
} else if (kspec < m_numComponents) {
plogf(" --- Component turned into a minor species: ");
} else {
plogf(" --- Zeroed Species turned into a "
"minor species: ");
}
plogf("%s\n", m_speciesName[kspec]);
}
++m_numRxnMinorZeroed;
} else if (speciesType == VCS_SPECIES_MAJOR) {
if (m_speciesStatus[kspec] != VCS_SPECIES_MAJOR) {
if (DEBUG_MODE_ENABLED && m_debug_print_lvl >= 2) {
if (m_speciesStatus[kspec] == VCS_SPECIES_MINOR) {
plogf(" --- Noncomponent turned from minor to major: ");
} else if (kspec < m_numComponents) {
plogf(" --- Component turned into a major: ");
} else {
plogf(" --- Noncomponent turned from zeroed to major: ");
}
plogf("%s\n", m_speciesName[kspec]);
}
m_speciesStatus[kspec] = VCS_SPECIES_MAJOR;
}
}
m_speciesStatus[kspec] = speciesType;
}
/*
* This logical variable indicates whether all current
* non-component species are minor or nonexistent
*/
allMinorZeroedSpecies = (m_numRxnMinorZeroed == m_numRxnRdc);
}
void VCS_SOLVE::solve_tp_equilib_check(bool& allMinorZeroedSpecies,
bool& uptodate_minors,
bool& giveUpOnElemAbund, int& solveFail,
size_t& iti, size_t& it1, int maxit,
int& stage, bool& lec)
{
if (! allMinorZeroedSpecies) {
if (DEBUG_MODE_ENABLED && m_debug_print_lvl >= 2) {
plogf(" --- Equilibrium check for major species: ");
}
for (size_t irxn = 0; irxn < m_numRxnRdc; ++irxn) {
size_t kspec = irxn + m_numComponents;
if (m_speciesStatus[kspec] == VCS_SPECIES_MAJOR && (fabs(m_deltaGRxn_new[irxn]) > m_tolmaj)) {
if (m_VCount->Its >= maxit) {
solveFail = -1;
/*
* Clean up and exit code even though we haven't
* converged. -> we have run out of iterations!
*/
stage = RETURN_A;
} else {
if (DEBUG_MODE_ENABLED && m_debug_print_lvl >= 2) {
plogf("%s failed\n", m_speciesName[m_indexRxnToSpecies[irxn]]);
}
// Convergence amongst major species has not been achieved
/*
* Go back and do another iteration with variable ITI
*/
iti = ((it1/4) *4) - it1;
stage = MAIN;
}
return;
}
}
if (DEBUG_MODE_ENABLED && m_debug_print_lvl >= 2) {
plogf(" MAJOR SPECIES CONVERGENCE achieved");
plogendl();
}
} else if (DEBUG_MODE_ENABLED && m_debug_print_lvl >= 2) {
plogf(" MAJOR SPECIES CONVERGENCE achieved "
"(because there are no major species)");
plogendl();
}
// Convergence amongst major species has been achieved
/*************************************************************************/
/*************** EQUILIBRIUM CHECK FOR MINOR SPECIES *********************/
/*************************************************************************/
if (m_numRxnMinorZeroed != 0) {
/*
* Calculate the chemical potential and reaction DeltaG
* for minor species, if needed.
*/
if (iti != 0) {
vcs_setFlagsVolPhases(false, VCS_STATECALC_OLD);
vcs_dfe(VCS_STATECALC_OLD, 1, 0, m_numSpeciesRdc);
vcs_deltag(1, false, VCS_STATECALC_OLD);
uptodate_minors = true;
}
if (DEBUG_MODE_ENABLED && m_debug_print_lvl >= 2) {
plogf(" --- Equilibrium check for minor species: ");
}
for (size_t irxn = 0; irxn < m_numRxnRdc; ++irxn) {
size_t kspec = irxn + m_numComponents;
if (m_speciesStatus[kspec] == VCS_SPECIES_MINOR && (fabs(m_deltaGRxn_new[irxn]) > m_tolmin)) {
if (m_VCount->Its >= maxit) {
solveFail = -1;
/*
* Clean up and exit code. -> Even though we have not
* converged, we have run out of iterations !
*/
stage = RETURN_A;
return;
}
if (DEBUG_MODE_ENABLED && m_debug_print_lvl >= 2) {
plogf("%s failed\n", m_speciesName[m_indexRxnToSpecies[irxn]]);
}
/*
* Set iti to zero to force a full calculation, and go back
* to the main loop to do another iteration.
*/
iti = 0;
stage = MAIN;
return;
}
}
if (DEBUG_MODE_ENABLED && m_debug_print_lvl >= 2) {
plogf(" CONVERGENCE achieved\n");
}
}
/*************************************************************************/
/*********************** FINAL ELEMENTAL ABUNDANCE CHECK *****************/
/*************************************************************************/
/*
* Recalculate the element abundance vector again
*/
vcs_updateVP(VCS_STATECALC_OLD);
vcs_elab();
/* LEC is only true when we are near the end game */
if (lec) {
if (!giveUpOnElemAbund) {
if (DEBUG_MODE_ENABLED && m_debug_print_lvl >= 2) {
plogf(" --- Check the Full Element Abundances: ");
}
/*
* Final element abundance check:
* If we fail then we need to go back and correct
* the element abundances, and then go do a major step
*/
if (! vcs_elabcheck(1)) {
if (DEBUG_MODE_ENABLED && m_debug_print_lvl >= 2) {
if (! vcs_elabcheck(0)) {
plogf(" failed\n");
} else {
plogf(" passed for NC but failed for NE: RANGE ERROR\n");
}
}
// delete?
stage = ELEM_ABUND_CHECK;
return;
}
if (DEBUG_MODE_ENABLED && m_debug_print_lvl >= 2) {
plogf(" passed\n");
}
}
/*
* If we have deleted a species then we need to recheck the
* the deleted species, before exiting
*/
if (m_numSpeciesRdc != m_numSpeciesTot) {
stage = RECHECK_DELETED;
return;
}
/* - Final checks are passed -> go check out */
stage = RETURN_A;
}
lec = true;
}
void VCS_SOLVE::solve_tp_elem_abund_check(size_t& iti, int& stage, bool& lec,
bool& giveUpOnElemAbund,
int& finalElemAbundAttempts,
int& rangeErrorFound)
{
/*
* HKM - Put in an element abundance check. The element abundances
* were being corrected even if they were perfectly OK to
* start with. This is actually an expensive operation, so
* I took it out. Also vcs_dfe() doesn't need to be called if
* no changes were made.
*/
rangeErrorFound = 0;
if (! vcs_elabcheck(1)) {
bool ncBefore = vcs_elabcheck(0);
vcs_elcorr(&m_sm[0], &m_wx[0]);
bool ncAfter = vcs_elabcheck(0);
bool neAfter = vcs_elabcheck(1);
/*
* Go back to evaluate the total moles of gas and liquid.
*/
vcs_setFlagsVolPhases(false, VCS_STATECALC_OLD);
vcs_dfe(VCS_STATECALC_OLD, 0, 0, m_numSpeciesRdc);
vcs_deltag(0, false, VCS_STATECALC_OLD);
if (!ncBefore) {
if (ncAfter) {
/*
* We have breathed new life into the old problem. Now the
* element abundances up to NC agree. Go back and
* restart the main loop calculation, resetting the
* end conditions.
*/
lec = false;
iti = 0;
stage = MAIN;
} else {
/*
* We are still hosed
*/
if (finalElemAbundAttempts >= 3) {
giveUpOnElemAbund = true;
stage = EQUILIB_CHECK;
} else {
finalElemAbundAttempts++;
lec = false;
iti = 0;
stage = MAIN;
}
}
return;
} else if (ncAfter) {
if (!neAfter) {
/*
* Probably an unrecoverable range error
*/
if (DEBUG_MODE_ENABLED && m_debug_print_lvl >= 2) {
plogf(" --- vcs_solve_tp: RANGE SPACE ERROR ENCOUNTERED\n");
plogf(" --- vcs_solve_tp: - Giving up on NE Element Abundance satisfaction \n");
plogf(" --- vcs_solve_tp: - However, NC Element Abundance criteria is satisfied \n");
plogf(" --- vcs_solve_tp: - Returning the calculated equilibrium condition ");
plogendl();
}
rangeErrorFound = 1;
giveUpOnElemAbund = true;
}
/*
* Recovery of end element abundances
* -> go do equilibrium check again and then
* check out.
*/
stage = EQUILIB_CHECK;
return;
}
}
// Calculate delta g's
vcs_deltag(0, false, VCS_STATECALC_OLD);
// Go back to equilibrium check as a prep to eventually checking out
stage = EQUILIB_CHECK;
}
double VCS_SOLVE::vcs_minor_alt_calc(size_t kspec, size_t irxn, bool* do_delete,
char* ANOTE) const
{
double dx = 0.0, a;
double w_kspec = m_molNumSpecies_old[kspec];
double molNum_kspec_new;
double wTrial, tmp;
double dg_irxn = m_deltaGRxn_old[irxn];
doublereal s;
size_t iph = m_phaseID[kspec];
*do_delete = false;
if (m_speciesUnknownType[kspec] != VCS_SPECIES_TYPE_INTERFACIALVOLTAGE) {
if (w_kspec <= 0.0) {
w_kspec = VCS_DELETE_MINORSPECIES_CUTOFF;
}
dg_irxn = std::max(dg_irxn, -200.0);
if (DEBUG_MODE_ENABLED && ANOTE) {
sprintf(ANOTE,"minor species alternative calc");
}
if (dg_irxn >= 23.0) {
molNum_kspec_new = w_kspec * 1.0e-10;
if (w_kspec < VCS_DELETE_MINORSPECIES_CUTOFF) {
goto L_ZERO_SPECIES;
}
return molNum_kspec_new - w_kspec;
} else {
if (fabs(dg_irxn) <= m_tolmin2) {
molNum_kspec_new = w_kspec;
return 0.0;
}
}
/*
* get the diagonal of the activity coefficient Jacobian
*/
s = m_np_dLnActCoeffdMolNum(kspec,kspec) / m_tPhaseMoles_old[iph];
/*
* We fit it to a power law approximation of the activity coefficient
*
* gamma = gamma_0 * ( x / x0)**a
*
* where a is forced to be a little bit greater than -1.
* We do this so that the resulting expression is always nonnegative
*
* We then solve the resulting calculation:
*
* gamma * x = gamma_0 * x0 exp (-deltaG/RT);
*/
a = clip(w_kspec * s, -1.0+1e-8, 100.0);
tmp = clip(-dg_irxn / (1.0 + a), -200.0, 200.0);
wTrial = w_kspec * exp(tmp);
molNum_kspec_new = wTrial;
if (wTrial > 100. * w_kspec) {
double molNumMax = 0.0001 * m_tPhaseMoles_old[iph];
if (molNumMax < 100. * w_kspec) {
molNumMax = 100. * w_kspec;
}
if (wTrial > molNumMax) {
molNum_kspec_new = molNumMax;
} else {
molNum_kspec_new = wTrial;
}
} else if (1.0E10 * wTrial < w_kspec) {
molNum_kspec_new= 1.0E-10 * w_kspec;
} else {
molNum_kspec_new = wTrial;
}
if ((molNum_kspec_new) < VCS_DELETE_MINORSPECIES_CUTOFF) {
goto L_ZERO_SPECIES;
}
return molNum_kspec_new - w_kspec;
/*
*
* Alternate return based for cases where we need to delete the species
* from the current list of active species, because its concentration
* has gotten too small.
*/
L_ZERO_SPECIES:
;
*do_delete = true;
return - w_kspec;
} else {
/*
* Voltage calculation
* Need to check the sign -> This is good for electrons
*/
dx = m_deltaGRxn_old[irxn]/ m_Faraday_dim;
if (DEBUG_MODE_ENABLED && ANOTE) {
sprintf(ANOTE,"voltage species alternative calc");
}
}
return dx;
}
int VCS_SOLVE::delta_species(const size_t kspec, double* const delta_ptr)
{
size_t irxn = kspec - m_numComponents;
int retn = 1;
double delta = *delta_ptr;
AssertThrowMsg(kspec >= m_numComponents, "VCS_SOLVE::delta_species",
"delete_species() ERROR: called for a component " + int2str(kspec));
if (m_speciesUnknownType[kspec] != VCS_SPECIES_TYPE_INTERFACIALVOLTAGE) {
/*
* Attempt the given dx. If it doesn't work, try to see if a smaller
* one would work,
*/
double dx = delta;
double* sc_irxn = m_stoichCoeffRxnMatrix.ptrColumn(irxn);
for (size_t j = 0; j < m_numComponents; ++j) {
if (m_molNumSpecies_old[j] > 0.0) {
double tmp = sc_irxn[j] * dx;
if (-tmp > m_molNumSpecies_old[j]) {
retn = 0;
dx = std::min(dx, - m_molNumSpecies_old[j] / sc_irxn[j]);
}
}
/*
* If the component has a zero concentration and is a reactant
* in the formation reaction, then dx == 0.0, and we just return.
*/
if (m_molNumSpecies_old[j] <= 0.0 && sc_irxn[j] < 0.0) {
*delta_ptr = 0.0;
return 0;
}
}
/*
* ok, we found a positive dx. implement it.
*/
*delta_ptr = dx;
m_molNumSpecies_old[kspec] += dx;
size_t iph = m_phaseID[kspec];
m_tPhaseMoles_old[iph] += dx;
vcs_setFlagsVolPhase(iph, false, VCS_STATECALC_OLD);
for (size_t j = 0; j < m_numComponents; ++j) {
double tmp = sc_irxn[j] * dx;
if (tmp != 0.0) {
iph = m_phaseID[j];
m_molNumSpecies_old[j] += tmp;
m_tPhaseMoles_old[iph] += tmp;
vcs_setFlagsVolPhase(iph, false, VCS_STATECALC_OLD);
m_molNumSpecies_old[j] = std::max(m_molNumSpecies_old[j], 0.0);
}
}
}
return retn;
}
int VCS_SOLVE::vcs_zero_species(const size_t kspec)
{
int retn = 1;
/*
* Calculate a delta that will eliminate the species.
*/
if (m_speciesUnknownType[kspec] != VCS_SPECIES_TYPE_INTERFACIALVOLTAGE) {
double dx = -m_molNumSpecies_old[kspec];
if (dx != 0.0) {
retn = delta_species(kspec, &dx);
if (DEBUG_MODE_ENABLED && !retn && m_debug_print_lvl >= 1) {
plogf("vcs_zero_species: Couldn't zero the species %d, "
"did delta of %g. orig conc of %g",
kspec, dx, m_molNumSpecies_old[kspec] + dx);
plogendl();
}
}
}
return retn;
}
int VCS_SOLVE::vcs_delete_species(const size_t kspec)
{
const size_t klast = m_numSpeciesRdc - 1;
const size_t iph = m_phaseID[kspec];
vcs_VolPhase* const Vphase = m_VolPhaseList[iph];
const size_t irxn = kspec - m_numComponents;
/*
* Zero the concentration of the species.
* -> This zeroes w[kspec] and modifies m_tPhaseMoles_old[]
*/
const int retn = vcs_zero_species(kspec);
if (!retn) {
throw CanteraError("VCS_SOLVE::vcs_delete_species",
"Failed to delete a species!");
}
/*
* Decrement the minor species counter if the current species is
* a minor species
*/
if (m_speciesStatus[kspec] != VCS_SPECIES_MAJOR) {
--m_numRxnMinorZeroed;
}
m_speciesStatus[kspec] = VCS_SPECIES_DELETED;
m_deltaGRxn_new[irxn] = 0.0;
m_deltaGRxn_old[irxn] = 0.0;
m_feSpecies_new[kspec] = 0.0;
m_feSpecies_old[kspec] = 0.0;
m_molNumSpecies_new[kspec] = m_molNumSpecies_old[kspec];
/*
* Rearrange the data if the current species isn't the last active
* species.
*/
if (kspec != klast) {
vcs_switch_pos(true, klast, kspec);
}
/*
* Adjust the total moles in a phase downwards.
*/
Vphase->setMolesFromVCSCheck(VCS_STATECALC_OLD, &m_molNumSpecies_old[0],
&m_tPhaseMoles_old[0]);
/*
* Adjust the current number of active species and reactions counters
*/
--m_numRxnRdc;
--m_numSpeciesRdc;
/*
* Check to see whether we have just annihilated a multispecies phase.
* If it is extinct, call the delete_multiphase() function.
*/
if (! m_SSPhase[klast] && Vphase->exists() != VCS_PHASE_EXIST_ALWAYS) {
bool stillExists = false;
for (size_t k = 0; k < m_numSpeciesRdc; k++) {
if (m_speciesUnknownType[k] != VCS_SPECIES_TYPE_INTERFACIALVOLTAGE &&
m_phaseID[k] == iph && m_molNumSpecies_old[k] > 0.0) {
stillExists = true;
break;
}
}
if (!stillExists) {
vcs_delete_multiphase(iph);
}
}
/*
* When the total number of noncomponent species is zero, we
* have to signal the calling code
*/
return (m_numRxnRdc == 0);
}
void VCS_SOLVE::vcs_reinsert_deleted(size_t kspec)
{
size_t iph = m_phaseID[kspec];
if (DEBUG_MODE_ENABLED && m_debug_print_lvl >= 2) {
plogf(" --- Add back a deleted species: %-12s\n", m_speciesName[kspec]);
}
/*
* Set the species back to minor species status
* this adjusts m_molNumSpecies_old[] and m_tPhaseMoles_old[]
* HKM -> make this a relative mole number!
*/
double dx = m_tPhaseMoles_old[iph] * VCS_RELDELETE_SPECIES_CUTOFF * 10.;
delta_species(kspec, &dx);
m_speciesStatus[kspec] = VCS_SPECIES_MINOR;
if (m_SSPhase[kspec]) {
m_speciesStatus[kspec] = VCS_SPECIES_MAJOR;
--m_numRxnMinorZeroed;
}
vcs_VolPhase* Vphase = m_VolPhaseList[iph];
Vphase->setMolesFromVCSCheck(VCS_STATECALC_OLD,
&m_molNumSpecies_old[0],
&m_tPhaseMoles_old[0]);
/*
* We may have popped a multispecies phase back
* into existence. If we did, we have to check
* the other species in that phase.
* Take care of the m_speciesStatus[] flag.
* The value of m_speciesStatus[] must change from
* VCS_SPECIES_ZEROEDPHASE to VCS_SPECIES_ZEROEDMS
* for those other species.
*/
if (! m_SSPhase[kspec]) {
if (Vphase->exists() == VCS_PHASE_EXIST_NO) {
Vphase->setExistence(VCS_PHASE_EXIST_YES);
for (size_t k = 0; k < m_numSpeciesTot; k++) {
if (m_phaseID[k] == iph && m_speciesStatus[k] != VCS_SPECIES_DELETED) {
m_speciesStatus[k] = VCS_SPECIES_MINOR;
}
}
}
} else {
Vphase->setExistence(VCS_PHASE_EXIST_YES);
}
++m_numRxnRdc;
++m_numSpeciesRdc;
++m_numRxnMinorZeroed;
if (kspec != (m_numSpeciesRdc - 1)) {
/*
* Rearrange both the species and the non-component global data
*/
vcs_switch_pos(true, (m_numSpeciesRdc - 1), kspec);
}
}
bool VCS_SOLVE::vcs_delete_multiphase(const size_t iph)
{
vcs_VolPhase* Vphase = m_VolPhaseList[iph];
bool successful = true;
/*
* set the phase existence flag to dead
*/
Vphase->setTotalMoles(0.0);
if (DEBUG_MODE_ENABLED && m_debug_print_lvl >= 2) {
plogf(" --- delete_multiphase %d, %s\n", iph, Vphase->PhaseName);
}
/*
* Loop over all of the species in the phase.
*/
for (size_t kspec = m_numComponents; kspec < m_numSpeciesRdc; ++kspec) {
if (m_phaseID[kspec] == iph) {
if (m_speciesUnknownType[kspec] != VCS_SPECIES_TYPE_INTERFACIALVOLTAGE) {
/*
* calculate an extent of rxn, dx, that zeroes out the species.
*/
double dx = - m_molNumSpecies_old[kspec];
double dxTent = dx;
int retn = delta_species(kspec, &dxTent);
if (retn != 1) {
successful = false;
if (DEBUG_MODE_ENABLED && m_debug_print_lvl >= 2) {
plogf(" --- delete_multiphase %d, %s ERROR problems deleting species %s\n",
iph, Vphase->PhaseName, m_speciesName[kspec]);
plogf(" --- delta attempted: %g achieved: %g "
" Zeroing it manually\n", dx, dxTent);
}
m_molNumSpecies_old[kspec] = 0.0;
m_molNumSpecies_new[kspec] = 0.0;
m_deltaMolNumSpecies[kspec] = 0.0;
// recover the total phase moles.
vcs_tmoles();
} else {
/*
* Set the mole number of that species to zero.
*/
m_molNumSpecies_old[kspec] = 0.0;
m_molNumSpecies_new[kspec] = 0.0;
m_deltaMolNumSpecies[kspec] = 0.0;
}
/*
* Change the status flag of the species to that of an
* zeroed phase
*/
m_speciesStatus[kspec] = VCS_SPECIES_ZEROEDMS;
}
}
}
double dj, dxWant, dxPerm = 0.0, dxPerm2 = 0.0;
for (size_t kcomp = 0; kcomp < m_numComponents; ++kcomp) {
if (m_phaseID[kcomp] == iph) {
if (DEBUG_MODE_ENABLED && m_debug_print_lvl >= 2) {
plogf(" --- delete_multiphase One of the species is a component %d - %s with mole number %g\n",
kcomp, m_speciesName[kcomp], m_molNumSpecies_old[kcomp]);
}
if (m_molNumSpecies_old[kcomp] != 0.0) {
for (size_t kspec = m_numComponents; kspec < m_numSpeciesRdc; ++kspec) {
size_t irxn = kspec - m_numComponents;
if (m_phaseID[kspec] != iph) {
if (m_stoichCoeffRxnMatrix(kcomp,irxn) != 0.0) {
dxWant = -m_molNumSpecies_old[kcomp] / m_stoichCoeffRxnMatrix(kcomp,irxn);
if (dxWant + m_molNumSpecies_old[kspec] < 0.0) {
dxPerm = -m_molNumSpecies_old[kspec];
}
for (size_t jcomp = 0; kcomp < m_numComponents; ++kcomp) {
if (jcomp != kcomp) {
if (m_phaseID[jcomp] == iph) {
dxPerm = 0.0;
} else {
dj = dxWant * m_stoichCoeffRxnMatrix(jcomp,irxn);
if (dj + m_molNumSpecies_old[kcomp] < 0.0) {
dxPerm2 = -m_molNumSpecies_old[kcomp] / m_stoichCoeffRxnMatrix(jcomp,irxn);
}
if (fabs(dxPerm2) < fabs(dxPerm)) {
dxPerm = dxPerm2;
}
}
}
}
}
if (dxPerm != 0.0) {
delta_species(kspec, &dxPerm);
}
}
}
}
if (m_molNumSpecies_old[kcomp] != 0.0) {
if (DEBUG_MODE_ENABLED && m_debug_print_lvl >= 2) {
plogf(" --- delete_multiphase One of the species is a component %d - %s still with mole number %g\n",
kcomp, m_speciesName[kcomp], m_molNumSpecies_old[kcomp]);
plogf(" --- zeroing it \n");
}
m_molNumSpecies_old[kcomp] = 0.0;
}
m_speciesStatus[kcomp] = VCS_SPECIES_ZEROEDMS;
}
}
/*
* Loop over all of the inactive species in the phase:
* Right now we reinstate all species in a deleted multiphase.
* We may only want to reinstate the "major ones" in the future.
* Note, species in phases with zero mole numbers are still
* considered active. Whether the phase pops back into
* existence or not is checked as part of the main iteration
* loop.
*/
for (size_t kspec = m_numSpeciesRdc; kspec < m_numSpeciesTot; ++kspec) {
if (m_phaseID[kspec] == iph) {
m_molNumSpecies_old[kspec] = 0.0;
m_molNumSpecies_new[kspec] = 0.0;
m_deltaMolNumSpecies[kspec] = 0.0;
m_speciesStatus[kspec] = VCS_SPECIES_ZEROEDMS;
++m_numRxnRdc;
++m_numSpeciesRdc;
if (DEBUG_MODE_ENABLED && m_debug_print_lvl >= 2) {
plogf(" --- Make %s", m_speciesName[kspec]);
plogf(" an active but zeroed species because its phase "
"was zeroed\n");
}
if (kspec != (m_numSpeciesRdc - 1)) {
/*
* Rearrange both the species and the non-component global data
*/
vcs_switch_pos(true, (m_numSpeciesRdc - 1), kspec);
}
}
}
/*
* Zero out the total moles counters for the phase
*/
m_tPhaseMoles_old[iph] = 0.0;
m_tPhaseMoles_new[iph] = 0.0;
m_deltaPhaseMoles[iph] = 0.0;
/*
* Upload the state to the VP object
*/
Vphase->setTotalMoles(0.0);
return successful;
}
int VCS_SOLVE::vcs_recheck_deleted()
{
vector_fp& xtcutoff = m_TmpPhase;
if (DEBUG_MODE_ENABLED && m_debug_print_lvl >= 2) {
plogf(" --- Start rechecking deleted species in multispec phases\n");
}
if (m_numSpeciesRdc == m_numSpeciesTot) {
return 0;
}
/*
* Use the standard chemical potentials for the chemical potentials
* of deleted species. Then, calculate Delta G for
* for formation reactions.
* Note: fe[] here includes everything except for the ln(x[i]) term
*/
for (size_t kspec = m_numSpeciesRdc; kspec < m_numSpeciesTot; ++kspec) {
size_t iph = m_phaseID[kspec];
m_feSpecies_new[kspec] = (m_SSfeSpecies[kspec] + log(m_actCoeffSpecies_old[kspec])
- m_lnMnaughtSpecies[kspec]
+ m_chargeSpecies[kspec] * m_Faraday_dim * m_phasePhi[iph]);
}
/*
* Recalculate the DeltaG's of the formation reactions for the
* deleted species in the mechanism
*/
vcs_deltag(0, true, VCS_STATECALC_NEW);
for (size_t iph = 0; iph < m_numPhases; iph++) {
if (m_tPhaseMoles_old[iph] > 0.0) {
xtcutoff[iph] = log(1.0 / VCS_RELDELETE_SPECIES_CUTOFF);
} else {
xtcutoff[iph] = 0.0;
}
}
/*
*
* We are checking the equation:
*
* sum_u = sum_j_comp [ sigma_i_j * u_j ]
* = u_i_O + log((AC_i * W_i)/m_tPhaseMoles_old)
*
* by first evaluating:
*
* DG_i_O = u_i_O - sum_u.
*
* Then, if TL is zero, the phase pops into existence if DG_i_O < 0.
* Also, if the phase exists, then we check to see if the species
* can have a mole number larger than VCS_DELETE_SPECIES_CUTOFF
* (default value = 1.0E-32).
*
* HKM:
* This seems to be an inconsistency in the algorithm here that needs
* correcting. The requirement above may bypass some multiphases which
* should exist. The real requirement for the phase to exist is:
*
* sum_i_in_phase [ exp(-DG_i_O) ] >= 1.0
*
* Thus, we need to amend the code. Also nonideal solutions will tend to
* complicate matters severely also.
*/
int npb = 0;
for (size_t irxn = m_numRxnRdc; irxn < m_numRxnTot; ++irxn) {
size_t kspec = m_indexRxnToSpecies[irxn];
size_t iph = m_phaseID[kspec];
if (m_tPhaseMoles_old[iph] == 0.0) {
if (m_deltaGRxn_new[irxn] < 0.0) {
vcs_reinsert_deleted(kspec);
npb++;
} else {
m_molNumSpecies_old[kspec] = 0.0;
}
} else if (m_tPhaseMoles_old[iph] > 0.0) {
if (m_deltaGRxn_new[irxn] < xtcutoff[iph]) {
vcs_reinsert_deleted(kspec);
npb++;
}
}
}
return npb;
}
bool VCS_SOLVE::recheck_deleted_phase(const int iphase)
{
// Check first to see if the phase is in fact deleted
const vcs_VolPhase* Vphase = m_VolPhaseList[iphase];
if (Vphase->exists() != VCS_PHASE_EXIST_NO) {
return false;
}
if (Vphase->exists() == VCS_PHASE_EXIST_ZEROEDPHASE) {
return false;
}
if (Vphase->m_singleSpecies) {
size_t kspec = Vphase->spGlobalIndexVCS(0);
size_t irxn = kspec + m_numComponents;
if (m_deltaGRxn_old[irxn] < 0.0) {
return true;
}
return false;
}
double phaseDG = 1.0;
for (size_t kk = 0; kk < Vphase->nSpecies(); kk++) {
size_t kspec = Vphase->spGlobalIndexVCS(kk);
size_t irxn = kspec + m_numComponents;
m_deltaGRxn_old[irxn] = clip(m_deltaGRxn_old[irxn], -50.0, 50.0);
phaseDG -= exp(-m_deltaGRxn_old[irxn]);
}
if (phaseDG < 0.0) {
return true;
}
return false;
}
size_t VCS_SOLVE::vcs_add_all_deleted()
{
size_t retn;
if (m_numSpeciesRdc == m_numSpeciesTot) {
return 0;
}
/*
* Use the standard chemical potentials for the chemical potentials of deleted species. Then, calculate Delta G for
* for formation reactions.
* We are relying here on a old saved value of m_actCoeffSpecies_old[kspec]
* being sufficiently good. Note, we will recalculate everything at the end of the routine.
*/
m_molNumSpecies_new = m_molNumSpecies_old;
for (int cits = 0; cits < 3; cits++) {
for (size_t kspec = m_numSpeciesRdc; kspec < m_numSpeciesTot; ++kspec) {
size_t iph = m_phaseID[kspec];
vcs_VolPhase* Vphase = m_VolPhaseList[iph];
if (m_molNumSpecies_new[kspec] == 0.0) {
m_molNumSpecies_new[kspec] = VCS_DELETE_MINORSPECIES_CUTOFF * 1.0E-10;
}
if (!Vphase->m_singleSpecies) {
Vphase->sendToVCS_ActCoeff(VCS_STATECALC_NEW, &m_actCoeffSpecies_new[0]);
}
m_feSpecies_new[kspec] = (m_SSfeSpecies[kspec] + log(m_actCoeffSpecies_new[kspec]) - m_lnMnaughtSpecies[kspec]
+ m_chargeSpecies[kspec] * m_Faraday_dim * m_phasePhi[iph]);
}
/*
* Recalculate the DeltaG's of the formation reactions for the deleted species in the mechanism
*/
vcs_deltag(0, true, VCS_STATECALC_NEW);
for (size_t irxn = m_numRxnRdc; irxn < m_numRxnTot; ++irxn) {
size_t kspec = m_indexRxnToSpecies[irxn];
size_t iph = m_phaseID[kspec];
if (m_tPhaseMoles_old[iph] > 0.0) {
double maxDG = std::min(m_deltaGRxn_new[irxn], 690.0);
double dx = m_tPhaseMoles_old[iph] * exp(- maxDG);
m_molNumSpecies_new[kspec] = dx;
}
}
}
for (size_t irxn = m_numRxnRdc; irxn < m_numRxnTot; ++irxn) {
size_t kspec = m_indexRxnToSpecies[irxn];
size_t iph = m_phaseID[kspec];
if (m_tPhaseMoles_old[iph] > 0.0) {
double dx = m_molNumSpecies_new[kspec];
retn = delta_species(kspec, &dx);
if (retn == 0) {
if (DEBUG_MODE_ENABLED && m_debug_print_lvl) {
plogf(" --- add_deleted(): delta_species() failed for species %s (%d) with mol number %g\n",
m_speciesName[kspec], kspec, dx);
}
if (dx > 1.0E-50) {
dx = 1.0E-50;
retn = delta_species(kspec, &dx);
if (DEBUG_MODE_ENABLED && retn == 0 && m_debug_print_lvl) {
plogf(" --- add_deleted(): delta_species() failed for species %s (%d) with mol number %g\n",
m_speciesName[kspec], kspec, dx);
}
}
}
if (DEBUG_MODE_ENABLED && m_debug_print_lvl >= 2) {
if (retn != 0) {
plogf(" --- add_deleted(): species %s added back in with mol number %g",
m_speciesName[kspec], dx);
plogendl();
} else {
plogf(" --- add_deleted(): species %s failed to be added back in");
plogendl();
}
}
}
}
vcs_setFlagsVolPhases(false, VCS_STATECALC_OLD);
vcs_dfe(VCS_STATECALC_OLD, 0, 0, m_numSpeciesTot);
vcs_deltag(0, true, VCS_STATECALC_OLD);
retn = 0;
for (size_t irxn = m_numRxnRdc; irxn < m_numRxnTot; ++irxn) {
size_t kspec = m_indexRxnToSpecies[irxn];
size_t iph = m_phaseID[kspec];
if (m_tPhaseMoles_old[iph] > 0.0 && fabs(m_deltaGRxn_old[irxn]) > m_tolmin) {
if (((m_molNumSpecies_old[kspec] * exp(-m_deltaGRxn_old[irxn])) >
VCS_DELETE_MINORSPECIES_CUTOFF) ||
(m_molNumSpecies_old[kspec] > VCS_DELETE_MINORSPECIES_CUTOFF)) {
retn++;
if (DEBUG_MODE_ENABLED && m_debug_print_lvl >= 2) {
plogf(" --- add_deleted(): species %s with mol number %g not converged: DG = %g",
m_speciesName[kspec], m_molNumSpecies_old[kspec],
m_deltaGRxn_old[irxn]);
plogendl();
}
}
}
}
return retn;
}
bool VCS_SOLVE::vcs_globStepDamp()
{
double* dptr = &m_deltaGRxn_new[0];
/* *************************************************** */
/* **** CALCULATE SLOPE AT END OF THE STEP ********** */
/* *************************************************** */
double s2 = 0.0;
for (size_t irxn = 0; irxn < m_numRxnRdc; ++irxn) {
size_t kspec = irxn + m_numComponents;
if (m_speciesUnknownType[kspec] != VCS_SPECIES_TYPE_INTERFACIALVOLTAGE) {
s2 += dptr[irxn] * m_deltaMolNumSpecies[kspec];
}
}
/* *************************************************** */
/* **** CALCULATE ORIGINAL SLOPE ********************* */
/* ************************************************** */
double s1 = 0.0;
dptr = &m_deltaGRxn_old[0];
for (size_t irxn = 0; irxn < m_numRxnRdc; ++irxn) {
size_t kspec = irxn + m_numComponents;
if (m_speciesUnknownType[kspec] != VCS_SPECIES_TYPE_INTERFACIALVOLTAGE) {
s1 += dptr[irxn] * m_deltaMolNumSpecies[kspec];
}
}
if (DEBUG_MODE_ENABLED && m_debug_print_lvl >= 2) {
plogf(" --- subroutine FORCE: Beginning Slope = %g\n", s1);
plogf(" --- subroutine FORCE: End Slope = %g\n", s2);
}
if (s1 > 0.0) {
if (DEBUG_MODE_ENABLED && m_debug_print_lvl >= 2) {
plogf(" --- subroutine FORCE produced no adjustments,");
if (s1 < 1.0E-40) {
plogf(" s1 positive but really small");
} else {
plogf(" failed s1 test");
}
plogendl();
}
return false;
}
if (s2 <= 0.0) {
if (DEBUG_MODE_ENABLED && m_debug_print_lvl >= 2) {
plogf(" --- subroutine FORCE produced no adjustments, s2 < 0");
plogendl();
}
return false;
}
/* *************************************************** */
/* **** FIT PARABOLA ********************************* */
/* *************************************************** */
double al = 1.0;
if (fabs(s1 -s2) > 1.0E-200) {
al = s1 / (s1 - s2);
}
if (al >= 0.95 || al < 0.0) {
if (DEBUG_MODE_ENABLED && m_debug_print_lvl >= 2) {
plogf(" --- subroutine FORCE produced no adjustments (al = %g)\n", al);
}
return false;
}
if (DEBUG_MODE_ENABLED && m_debug_print_lvl >= 2) {
plogf(" --- subroutine FORCE produced a damping factor = %g\n", al);
}
/* *************************************************** */
/* **** ADJUST MOLE NUMBERS, CHEM. POT *************** */
/* *************************************************** */
if (DEBUG_MODE_ENABLED && m_debug_print_lvl >= 2) {
m_deltaGRxn_tmp = m_deltaGRxn_new;
}
dptr = &m_molNumSpecies_new[0];
for (size_t kspec = 0; kspec < m_numSpeciesRdc; ++kspec) {
m_molNumSpecies_new[kspec] = m_molNumSpecies_old[kspec] +
al * m_deltaMolNumSpecies[kspec];
}
for (size_t iph = 0; iph < m_numPhases; iph++) {
m_tPhaseMoles_new[iph] = m_tPhaseMoles_old[iph] + al * m_deltaPhaseMoles[iph];
}
vcs_updateVP(VCS_STATECALC_NEW);
if (DEBUG_MODE_ENABLED && m_debug_print_lvl >= 2) {
plogf(" --- subroutine FORCE adjusted the mole "
"numbers, AL = %10.3f\n", al);
}
/*
* Because we changed the mole numbers, we need to
* calculate the chemical potentials again. If a major-
* only step is being carried out, then we don't need to
* update the minor noncomponents.
*/
vcs_setFlagsVolPhases(false, VCS_STATECALC_NEW);
vcs_dfe(VCS_STATECALC_NEW, 0, 0, m_numSpeciesRdc);
/*
* Evaluate DeltaG for all components if ITI=0, and for
* major components only if ITI NE 0
*/
vcs_deltag(0, false, VCS_STATECALC_NEW);
dptr = &m_deltaGRxn_new[0];
s2 = 0.0;
for (size_t irxn = 0; irxn < m_numRxnRdc; ++irxn) {
size_t kspec = irxn + m_numComponents;
if (m_speciesUnknownType[kspec] != VCS_SPECIES_TYPE_INTERFACIALVOLTAGE) {
s2 += dptr[irxn] * m_deltaMolNumSpecies[kspec];
}
}
if (DEBUG_MODE_ENABLED && m_debug_print_lvl >= 2) {
plogf(" --- subroutine FORCE: Adj End Slope = %g", s2);
plogendl();
}
return true;
}
int VCS_SOLVE::vcs_basopt(const bool doJustComponents, double aw[], double sa[], double sm[],
double ss[], double test, bool* const usedZeroedSpecies)
{
size_t k;
size_t juse = npos;
size_t jlose = npos;
double* scrxn_ptr;
clockWC tickTock;
if (DEBUG_MODE_ENABLED && m_debug_print_lvl >= 2) {
plogf(" ");
for (size_t i=0; i<77; i++) {
plogf("-");
}
plogf("\n");
plogf(" --- Subroutine BASOPT called to ");
if (doJustComponents) {
plogf("calculate the number of components\n");
} else {
plogf("reevaluate the components\n");
}
if (m_debug_print_lvl >= 2) {
plogf("\n");
plogf(" --- Formula Matrix used in BASOPT calculation\n");
plogf(" --- Active | ");
for (size_t j = 0; j < m_numElemConstraints; j++) {
plogf(" %1d ", m_elementActive[j]);
}
plogf("\n");
plogf(" --- Species | ");
for (size_t j = 0; j < m_numElemConstraints; j++) {
plogf(" ");
vcs_print_stringTrunc(m_elementName[j].c_str(), 8, 1);
}
plogf("\n");
for (k = 0; k < m_numSpeciesTot; k++) {
plogf(" --- ");
vcs_print_stringTrunc(m_speciesName[k].c_str(), 11, 1);
plogf(" | ");
for (size_t j = 0; j < m_numElemConstraints; j++) {
plogf(" %8.2g", m_formulaMatrix(k,j));
}
plogf("\n");
}
plogendl();
}
}
/*
* Calculate the maximum value of the number of components possible
* It's equal to the minimum of the number of elements and the
* number of total species.
*/
size_t ncTrial = std::min(m_numElemConstraints, m_numSpeciesTot);
m_numComponents = ncTrial;
*usedZeroedSpecies = false;
vector_int ipiv(ncTrial);
int info;
/*
* Use a temporary work array for the mole numbers, aw[]
*/
std::copy(m_molNumSpecies_old.begin(),
m_molNumSpecies_old.begin() + m_numSpeciesTot, aw);
/*
* Take out the Voltage unknowns from consideration
*/
for (k = 0; k < m_numSpeciesTot; k++) {
if (m_speciesUnknownType[k] == VCS_SPECIES_TYPE_INTERFACIALVOLTAGE) {
aw[k] = test;
}
}
size_t jr = 0;
/*
* Top of a loop of some sort based on the index JR. JR is the
* current number of component species found.
*/
while (jr < ncTrial) {
/* - Top of another loop point based on finding a linearly */
/* - independent species */
while (true) {
/*
* Search the remaining part of the mole fraction vector, AW,
* for the largest remaining species. Return its identity in K.
* The first search criteria is always the largest positive
* magnitude of the mole number.
*/
k = vcs_basisOptMax(aw, jr, m_numSpeciesTot);
/*
* The fun really starts when you have run out of species that have a significant
* concentration. It becomes extremely important to make a good choice of which
* species you want to pick to fill out the basis. Basically, you don't want to
* use species with elements abundances which aren't pegged to zero. This means
* that those modes will never be allowed to grow. You want to have the
* best chance that the component will grow positively.
*
* Suppose you start with CH4, N2, as the only species with nonzero compositions.
* You have the following abundances:
*
* Abundances:
* ----------------
* C 2.0
* N 2.0
* H 4.0
* O 0.0
*
* For example, Make the following choice:
*
* CH4 N2 O choose -> OH
* or
* CH4 N2 O choose -> H2
*
* OH and H2 both fill out the basis. They will pass the algorithm. However,
* choosing OH as the next species will create a situation where H2 can not
* grow in concentration. This happened in practice, btw. The reason is that
* the formation reaction for H2 will cause one of the component species
* to go negative.
*
* The basic idea here is to pick a simple species whose mole number
* can grow according to the element compositions. Candidates are still
* filtered according to their linear independence.
*
* Note, if there is electronic charge and the electron species,
* you should probably pick the electron as a component, if it
* linearly independent. The algorithm below will do this automagically.
*
*/
if ((aw[k] != test) && aw[k] < VCS_DELETE_MINORSPECIES_CUTOFF) {
*usedZeroedSpecies = true;
double maxConcPossKspec = 0.0;
double maxConcPoss = 0.0;
size_t kfound = npos;
int minNonZeroes = 100000;
int nonZeroesKspec = 0;
for (size_t kspec = ncTrial; kspec < m_numSpeciesTot; kspec++) {
if (aw[kspec] >= 0.0 && m_speciesUnknownType[kspec] != VCS_SPECIES_TYPE_INTERFACIALVOLTAGE) {
maxConcPossKspec = 1.0E10;
nonZeroesKspec = 0;
for (size_t j = 0; j < m_numElemConstraints; ++j) {
if (m_elementActive[j] && m_elType[j] == VCS_ELEM_TYPE_ABSPOS) {
double nu = m_formulaMatrix(kspec,j);
if (nu != 0.0) {
nonZeroesKspec++;
maxConcPossKspec = std::min(m_elemAbundancesGoal[j] / nu, maxConcPossKspec);
}
}
}
if ((maxConcPossKspec >= maxConcPoss) || (maxConcPossKspec > 1.0E-5)) {
if (nonZeroesKspec <= minNonZeroes) {
if (kfound == npos || nonZeroesKspec < minNonZeroes) {
kfound = kspec;
} else {
// ok we are sitting pretty equal here decide on the raw ss Gibbs energy
if (m_SSfeSpecies[kspec] <= m_SSfeSpecies[kfound]) {
kfound = kspec;
}
}
}
minNonZeroes = std::min(minNonZeroes, nonZeroesKspec);
maxConcPoss = std::max(maxConcPoss, maxConcPossKspec);
}
}
}
if (kfound == npos) {
double gmin = 0.0;
kfound = k;
for (size_t kspec = ncTrial; kspec < m_numSpeciesTot; kspec++) {
if (aw[kspec] >= 0.0) {
size_t irxn = kspec - ncTrial;
if (m_deltaGRxn_new[irxn] < gmin) {
gmin = m_deltaGRxn_new[irxn];
kfound = kspec;
}
}
}
}
k = kfound;
}
if (aw[k] == test) {
m_numComponents = jr;
ncTrial = m_numComponents;
size_t numPreDeleted = m_numRxnTot - m_numRxnRdc;
if (numPreDeleted != (m_numSpeciesTot - m_numSpeciesRdc)) {
throw CanteraError("VCS_SOLVE::vcs_basopt", "we shouldn't be here");
}
m_numRxnTot = m_numSpeciesTot - ncTrial;
m_numRxnRdc = m_numRxnTot - numPreDeleted;
m_numSpeciesRdc = m_numSpeciesTot - numPreDeleted;
for (size_t i = 0; i < m_numSpeciesTot; ++i) {
m_indexRxnToSpecies[i] = ncTrial + i;
}
if (DEBUG_MODE_ENABLED && m_debug_print_lvl >= 2) {
plogf(" --- Total number of components found = %3d (ne = %d)\n ",
ncTrial, m_numElemConstraints);
}
goto L_END_LOOP;
}
/*
* Assign a small negative number to the component that we have
* just found, in order to take it out of further consideration.
*/
aw[k] = test;
/* *********************************************************** */
/* **** CHECK LINEAR INDEPENDENCE WITH PREVIOUS SPECIES ****** */
/* *********************************************************** */
/*
* Modified Gram-Schmidt Method, p. 202 Dalquist
* QR factorization of a matrix without row pivoting.
*/
size_t jl = jr;
for (size_t j = 0; j < m_numElemConstraints; ++j) {
sm[j + jr*m_numElemConstraints] = m_formulaMatrix(k,j);
}
if (jl > 0) {
/*
* Compute the coefficients of JA column of the
* the upper triangular R matrix, SS(J) = R_J_JR
* (this is slightly different than Dalquist)
* R_JA_JA = 1
*/
for (size_t j = 0; j < jl; ++j) {
ss[j] = 0.0;
for (size_t i = 0; i < m_numElemConstraints; ++i) {
ss[j] += sm[i + jr*m_numElemConstraints] * sm[i + j*m_numElemConstraints];
}
ss[j] /= sa[j];
}
/*
* Now make the new column, (*,JR), orthogonal to the
* previous columns
*/
for (size_t j = 0; j < jl; ++j) {
for (size_t l = 0; l < m_numElemConstraints; ++l) {
sm[l + jr*m_numElemConstraints] -= ss[j] * sm[l + j*m_numElemConstraints];
}
}
}
/*
* Find the new length of the new column in Q.
* It will be used in the denominator in future row calcs.
*/
sa[jr] = 0.0;
for (size_t ml = 0; ml < m_numElemConstraints; ++ml) {
sa[jr] += pow(sm[ml + jr*m_numElemConstraints], 2);
}
/* **************************************************** */
/* **** IF NORM OF NEW ROW .LT. 1E-3 REJECT ********** */
/* **************************************************** */
if (sa[jr] > 1.0e-6) {
break;
}
}
/* ****************************************** */
/* **** REARRANGE THE DATA ****************** */
/* ****************************************** */
if (jr != k) {
if (DEBUG_MODE_ENABLED && m_debug_print_lvl >= 2) {
plogf(" --- %-12.12s", m_speciesName[k]);
if (m_speciesUnknownType[k] == VCS_SPECIES_TYPE_INTERFACIALVOLTAGE) {
plogf("(Volts = %9.2g)", m_molNumSpecies_old[k]);
} else {
plogf("(%9.2g)", m_molNumSpecies_old[k]);
}
plogf(" replaces %-12.12s", m_speciesName[jr]);
if (m_speciesUnknownType[jr] == VCS_SPECIES_TYPE_INTERFACIALVOLTAGE) {
plogf("(Volts = %9.2g)", m_molNumSpecies_old[jr]);
} else {
plogf("(%9.2g)", m_molNumSpecies_old[jr]);
}
plogf(" as component %3d\n", jr);
}
vcs_switch_pos(false, jr, k);
std::swap(aw[jr], aw[k]);
} else if (DEBUG_MODE_ENABLED && m_debug_print_lvl >= 2) {
plogf(" --- %-12.12s", m_speciesName[k]);
if (m_speciesUnknownType[k] == VCS_SPECIES_TYPE_INTERFACIALVOLTAGE) {
plogf("(Volts = %9.2g) remains ", m_molNumSpecies_old[k]);
} else {
plogf("(%9.2g) remains ", m_molNumSpecies_old[k]);
}
plogf(" as component %3d\n", jr);
}
/* - entry point from up above */
L_END_LOOP:
;
// If we haven't found enough components, go back and find some more.
jr++;
}
if (doJustComponents) {
goto L_CLEANUP;
}
/* ****************************************************** */
/* **** EVALUATE THE STOICHIOMETRY ********************** */
/* ****************************************************** */
/*
* Formulate the matrix problem for the stoichiometric
* coefficients. CX + B = 0
* C will be an nc x nc matrix made up of the formula
* vectors for the components.
* n RHS's will be solved for. Thus, B is an nc x n
* matrix.
*
* BIG PROBLEM 1/21/99:
*
* This algorithm makes the assumption that the
* first nc rows of the formula matrix aren't rank deficient.
* However, this might not be the case. For example, assume
* that the first element in m_formulaMatrix[] is argon. Assume that
* no species in the matrix problem actually includes argon.
* Then, the first row in sm[], below will be identically
* zero. bleh.
* What needs to be done is to perform a rearrangement
* of the ELEMENTS -> i.e. rearrange, m_formulaMatrix, sp,
* and m_elemAbundancesGoal, such
* that the first nc elements form in combination with the
* nc components create an invertible sm[]. not a small
* project, but very doable.
* An alternative would be to turn the matrix problem
* below into an ne x nc problem, and do QR elimination instead
* of Gauss-Jordan elimination.
* Note the rearrangement of elements need only be done once
* in the problem. It's actually very similar to the top of
* this program with ne being the species and nc being the
* elements!!
*/
for (size_t j = 0; j < ncTrial; ++j) {
for (size_t i = 0; i < ncTrial; ++i) {
sm[i + j*m_numElemConstraints] = m_formulaMatrix(j,i);
}
}
for (size_t i = 0; i < m_numRxnTot; ++i) {
k = m_indexRxnToSpecies[i];
for (size_t j = 0; j < ncTrial; ++j) {
m_stoichCoeffRxnMatrix(j,i) = - m_formulaMatrix(k,j);
}
}
// Solve the linear system to calculate the reaction matrix,
// m_stoichCoeffRxnMatrix.
ct_dgetrf(ncTrial, ncTrial, sm, m_numElemConstraints, &ipiv[0], info);
if (info) {
plogf("vcs_solve_TP ERROR: Error factorizing stoichiometric coefficient matrix\n");
return VCS_FAILED_CONVERGENCE;
}
ct_dgetrs(ctlapack::NoTranspose, ncTrial, m_numRxnTot, sm, m_numElemConstraints,
&ipiv[0], m_stoichCoeffRxnMatrix.ptrColumn(0), m_numElemConstraints, info);
/*
* NOW, if we have interfacial voltage unknowns, what we did
* was just wrong -> hopefully it didn't blow up. Redo the problem.
* Search for inactive E
*/
juse = npos;
jlose = npos;
for (size_t j = 0; j < m_numElemConstraints; j++) {
if (!m_elementActive[j] && !strcmp(m_elementName[j].c_str(), "E")) {
juse = j;
}
}
for (size_t j = 0; j < m_numElemConstraints; j++) {
if (m_elementActive[j] && !strncmp((m_elementName[j]).c_str(), "cn_", 3)) {
jlose = j;
}
}
for (k = 0; k < m_numSpeciesTot; k++) {
if (m_speciesUnknownType[k] == VCS_SPECIES_TYPE_INTERFACIALVOLTAGE) {
for (size_t j = 0; j < ncTrial; ++j) {
for (size_t i = 0; i < ncTrial; ++i) {
if (i == jlose) {
sm[i + j*m_numElemConstraints] = m_formulaMatrix(j,juse);
} else {
sm[i + j*m_numElemConstraints] = m_formulaMatrix(j,i);
}
}
}
for (size_t i = 0; i < m_numRxnTot; ++i) {
k = m_indexRxnToSpecies[i];
for (size_t j = 0; j < ncTrial; ++j) {
if (j == jlose) {
aw[j] = - m_formulaMatrix(k,juse);
} else {
aw[j] = - m_formulaMatrix(k,j);
}
}
}
ct_dgetrf(ncTrial, ncTrial, sm, m_numElemConstraints, &ipiv[0], info);
if (info) {
plogf("vcs_solve_TP ERROR: Error factorizing matrix\n");
return VCS_FAILED_CONVERGENCE;
}
ct_dgetrs(ctlapack::NoTranspose, ncTrial, 1, sm, m_numElemConstraints,
&ipiv[0], aw, m_numElemConstraints, info);
size_t i = k - ncTrial;
for (size_t j = 0; j < ncTrial; j++) {
m_stoichCoeffRxnMatrix(j,i) = aw[j];
}
}
}
/*
* Calculate the szTmp array for each formation reaction
*/
for (size_t i = 0; i < m_numRxnTot; i++) {
double szTmp = 0.0;
for (size_t j = 0; j < ncTrial; j++) {
szTmp += fabs(m_stoichCoeffRxnMatrix(j,i));
}
m_scSize[i] = szTmp;
}
if (DEBUG_MODE_ENABLED && m_debug_print_lvl >= 2) {
plogf(" --- Components:");
for (size_t j = 0; j < ncTrial; j++) {
plogf(" %3d", j);
}
plogf("\n --- Components Moles:");
for (size_t j = 0; j < ncTrial; j++) {
if (m_speciesUnknownType[j] == VCS_SPECIES_TYPE_INTERFACIALVOLTAGE) {
plogf(" % -10.3E", 0.0);
} else {
plogf(" % -10.3E", m_molNumSpecies_old[j]);
}
}
plogf("\n --- NonComponent| Moles |");
for (size_t j = 0; j < ncTrial; j++) {
plogf(" %10.10s", m_speciesName[j]);
}
plogf("\n");
for (size_t i = 0; i < m_numRxnTot; i++) {
plogf(" --- %3d ", m_indexRxnToSpecies[i]);
plogf("%-10.10s", m_speciesName[m_indexRxnToSpecies[i]]);
if (m_speciesUnknownType[m_indexRxnToSpecies[i]] == VCS_SPECIES_TYPE_INTERFACIALVOLTAGE) {
plogf("|% -10.3E|", 0.0);
} else {
plogf("|% -10.3E|", m_molNumSpecies_old[m_indexRxnToSpecies[i]]);
}
for (size_t j = 0; j < ncTrial; j++) {
plogf(" %+7.3f", m_stoichCoeffRxnMatrix(j,i));
}
plogf("\n");
}
/*
* Manual check on the satisfaction of the reaction matrix's ability
* to conserve elements
*/
double sumMax = -1.0;
size_t iMax = npos;
size_t jMax = npos;
for (size_t i = 0; i < m_numRxnTot; ++i) {
k = m_indexRxnToSpecies[i];
double sum;
for (size_t j = 0; j < ncTrial; ++j) {
if (j == jlose) {
sum = m_formulaMatrix(k,juse);
for (size_t n = 0; n < ncTrial; n++) {
double numElements = m_formulaMatrix(n,juse);
double coeff = m_stoichCoeffRxnMatrix(n,i);
sum += coeff * numElements;
}
} else {
sum = m_formulaMatrix(k,j);
for (size_t n = 0; n < ncTrial; n++) {
double numElements = m_formulaMatrix(n,j);
double coeff = m_stoichCoeffRxnMatrix(n,i);
sum += coeff * numElements;
}
}
if (fabs(sum) > sumMax) {
sumMax = fabs(sum);
iMax = i;
jMax = j;
if (j == jlose) {
jMax = juse;
}
}
if (fabs(sum) > 1.0E-6) {
throw CanteraError("VCS_SOLVE::vcs_basopt", "we have a prob");
}
}
}
plogf(" --- largest error in Stoich coeff = %g at rxn = %d ", sumMax, iMax);
plogf("%-10.10s", m_speciesName[m_indexRxnToSpecies[iMax]]);
plogf(" element = %d ", jMax);
plogf("%-5.5s", m_elementName[jMax]);
plogf("\n");
plogf(" ");
for (size_t i=0; i<77; i++) {
plogf("-");
}
plogf("\n");
}
/* **************************************************** */
/* **** EVALUATE DELTA N VALUES *********************** */
/* **************************************************** */
/*
* Evaluate the change in gas and liquid total moles
* due to reaction vectors, DNG and DNL.
*/
/*
* Zero out the change of Phase Moles array
*/
m_deltaMolNumPhase.zero();
m_phaseParticipation.zero();
/*
* Loop over each reaction, creating the change in Phase Moles
* array, m_deltaMolNumPhase(iphase,irxn),
* and the phase participation array, PhaseParticipation[irxn][iphase]
*/
for (size_t irxn = 0; irxn < m_numRxnTot; ++irxn) {
scrxn_ptr = m_stoichCoeffRxnMatrix.ptrColumn(irxn);
size_t kspec = m_indexRxnToSpecies[irxn];
size_t iph = m_phaseID[kspec];
m_deltaMolNumPhase(iph,irxn) = 1.0;
m_phaseParticipation(iph,irxn)++;
for (size_t j = 0; j < ncTrial; ++j) {
iph = m_phaseID[j];
if (fabs(scrxn_ptr[j]) <= 1.0e-6) {
scrxn_ptr[j] = 0.0;
} else {
m_deltaMolNumPhase(iph,irxn) += scrxn_ptr[j];
m_phaseParticipation(iph,irxn)++;
}
}
}
L_CLEANUP:
;
double tsecond = tickTock.secondsWC();
m_VCount->Time_basopt += tsecond;
m_VCount->Basis_Opts++;
return VCS_SUCCESS;
}
size_t VCS_SOLVE::vcs_basisOptMax(const double* const molNum, const size_t j,
const size_t n)
{
/*
* The factors of 1.01 and 1.001 are placed in this routine for a purpose.
* The purpose is to ensure that roundoff errors don't influence major
* decisions. This means that the optimized and non-optimized versions of
* the code remain close to each other.
*
* (we try to avoid the logic: a = b
* if (a > b) { do this }
* else { do something else }
* because roundoff error makes a difference in the inequality evaluation)
*
* Mole numbers are frequently equal to each other in equilibrium problems
* due to constraints. Swaps are only done if there are a 1% difference in
* the mole numbers. Of course this logic isn't foolproof.
*/
size_t largest = j;
double big = molNum[j] * m_spSize[j] * 1.01;
if (m_spSize[j] <= 0.0) {
throw CanteraError("VCS_SOLVE::vcs_basisOptMax",
"spSize is nonpositive");
}
for (size_t i = j + 1; i < n; ++i) {
if (m_spSize[i] <= 0.0) {
throw CanteraError("VCS_SOLVE::vcs_basisOptMax",
"spSize is nonpositive");
}
bool doSwap = false;
if (m_SSPhase[j]) {
doSwap = (molNum[i] * m_spSize[i]) > big;
if (!m_SSPhase[i] && doSwap) {
doSwap = molNum[i] > (molNum[largest] * 1.001);
}
} else {
if (m_SSPhase[i]) {
doSwap = (molNum[i] * m_spSize[i]) > big;
if (!doSwap) {
doSwap = molNum[i] > (molNum[largest] * 1.001);
}
} else {
doSwap = (molNum[i] * m_spSize[i]) > big;
}
}
if (doSwap) {
largest = i;
big = molNum[i] * m_spSize[i] * 1.01;
}
}
return largest;
}
int VCS_SOLVE::vcs_species_type(const size_t kspec) const
{
// ---------- Treat special cases first ---------------------
if (m_speciesUnknownType[kspec] == VCS_SPECIES_TYPE_INTERFACIALVOLTAGE) {
return VCS_SPECIES_INTERFACIALVOLTAGE;
}
size_t iph = m_phaseID[kspec];
int irxn = int(kspec) - int(m_numComponents);
vcs_VolPhase* VPhase = m_VolPhaseList[iph];
int phaseExist = VPhase->exists();
// ---------- Treat zeroed out species first ----------------
if (m_molNumSpecies_old[kspec] <= 0.0) {
if (m_tPhaseMoles_old[iph] <= 0.0 && !m_SSPhase[kspec]) {
return VCS_SPECIES_ZEROEDMS;
}
/*
* see if the species has an element
* which is so low that species will always be zero
*
*/
for (size_t j = 0; j < m_numElemConstraints; ++j) {
int elType = m_elType[j];
if (elType == VCS_ELEM_TYPE_ABSPOS) {
double atomComp = m_formulaMatrix(kspec,j);
if (atomComp > 0.0) {
double maxPermissible = m_elemAbundancesGoal[j] / atomComp;
if (maxPermissible < VCS_DELETE_MINORSPECIES_CUTOFF) {
if (DEBUG_MODE_ENABLED && m_debug_print_lvl >= 2) {
plogf(" --- %s can not be nonzero because"
" needed element %s is zero\n",
m_speciesName[kspec], m_elementName[j]);
}
if (m_SSPhase[kspec]) {
return VCS_SPECIES_ZEROEDSS;
} else {
return VCS_SPECIES_STOICHZERO;
}
}
}
}
}
/*
* The Gibbs free energy for this species is such that
* it will pop back into existence.
* -> An exception to this is if a needed regular element
* is also zeroed out. Then, don't pop the phase or the species back into
* existence.
*/
if (irxn >= 0) {
for (size_t j = 0; j < m_numComponents; ++j) {
double stoicC = m_stoichCoeffRxnMatrix(j,irxn);
if (stoicC != 0.0) {
double negChangeComp = - stoicC;
if (negChangeComp > 0.0) {
if (m_molNumSpecies_old[j] < 1.0E-60) {
if (DEBUG_MODE_ENABLED && m_debug_print_lvl >= 2) {
plogf(" --- %s is prevented from popping into existence because"
" a needed component to be consumed, %s, has a zero mole number\n",
m_speciesName[kspec], m_speciesName[j]);
}
if (m_SSPhase[kspec]) {
return VCS_SPECIES_ZEROEDSS;
} else {
return VCS_SPECIES_STOICHZERO;
}
}
} else if (negChangeComp < 0.0) {
size_t jph = m_phaseID[j];
vcs_VolPhase* jVPhase = m_VolPhaseList[jph];
if (jVPhase->exists() <= 0) {
if (DEBUG_MODE_ENABLED && m_debug_print_lvl >= 2) {
plogf(" --- %s is prevented from popping into existence because"
" a needed component %s is in a zeroed-phase that would be "
"popped into existence at the same time\n",
m_speciesName[kspec], m_speciesName[j]);
}
if (m_SSPhase[kspec]) {
return VCS_SPECIES_ZEROEDSS;
} else {
return VCS_SPECIES_STOICHZERO;
}
}
}
}
}
}
if (irxn >= 0 && m_deltaGRxn_old[irxn] >= 0.0) {
/*
* We are here when the species is or should remain zeroed out
*/
if (m_SSPhase[kspec]) {
return VCS_SPECIES_ZEROEDSS;
} else {
if (phaseExist >= VCS_PHASE_EXIST_YES) {
return VCS_SPECIES_ACTIVEBUTZERO;
} else if (phaseExist == VCS_PHASE_EXIST_ZEROEDPHASE) {
return VCS_SPECIES_ZEROEDPHASE;
} else {
return VCS_SPECIES_ZEROEDMS;
}
}
}
/*
* If the current phase already exists,
*/
if (m_tPhaseMoles_old[iph] > 0.0) {
if (m_SSPhase[kspec]) {
return VCS_SPECIES_MAJOR;
} else {
return VCS_SPECIES_ACTIVEBUTZERO;
}
}
/*
* The Gibbs free energy for this species is such that
* it will pop back into existence.
*
* -> Set it to a major species in anticipation.
* -> note, if we had an estimate for the emerging mole
* fraction of the species in the phase, we could do
* better here.
*/
if (m_tPhaseMoles_old[iph] <= 0.0) {
if (m_SSPhase[kspec]) {
return VCS_SPECIES_MAJOR;
} else {
return VCS_SPECIES_ZEROEDMS;
}
}
}
// ---------- Treat species with non-zero mole numbers next ------------
/*
* Always treat species in single species phases as majors if the
* phase exists.
*/
if (m_SSPhase[kspec]) {
return VCS_SPECIES_MAJOR;
}
/*
* Check to see whether the current species is a major component
* of its phase. If it is, it is a major component. This is consistent
* with the above rule about single species phases. A major component
* (i.e., a species with a high mole fraction)
* in any phase is always treated as a major species
*/
if (m_molNumSpecies_old[kspec] > (m_tPhaseMoles_old[iph] * 0.001)) {
return VCS_SPECIES_MAJOR;
}
/*
* Main check in the loop:
* Check to see if there is a component with a mole number that is
* within a factor of 100 of the current species.
* If there is and that component is not part of a single species
* phase and shares a non-zero stoichiometric coefficient, then
* the current species is a major species.
*/
if (irxn < 0) {
return VCS_SPECIES_MAJOR;
} else {
double szAdj = m_scSize[irxn] * std::sqrt((double)m_numRxnTot);
for (size_t k = 0; k < m_numComponents; ++k) {
if (!m_SSPhase[k] && m_stoichCoeffRxnMatrix(k,irxn) != 0.0 && m_molNumSpecies_old[kspec] * szAdj >= m_molNumSpecies_old[k] * 0.01) {
return VCS_SPECIES_MAJOR;
}
}
}
return VCS_SPECIES_MINOR;
}
void VCS_SOLVE::vcs_chemPotPhase(const int stateCalc,
const size_t iph, const double* const molNum,
double* const ac, double* const mu_i,
const bool do_deleted)
{
vcs_VolPhase* Vphase = m_VolPhaseList[iph];
size_t nkk = Vphase->nSpecies();
double tMoles = TPhInertMoles[iph];
for (size_t k = 0; k < nkk; k++) {
size_t kspec = Vphase->spGlobalIndexVCS(k);
tMoles += molNum[kspec];
}
double tlogMoles = 0.0;
if (tMoles > 0.0) {
tlogMoles = log(tMoles);
}
Vphase->setMolesFromVCS(stateCalc, molNum);
Vphase->sendToVCS_ActCoeff(stateCalc, ac);
double phi = Vphase->electricPotential();
double Faraday_phi = m_Faraday_dim * phi;
for (size_t k = 0; k < nkk; k++) {
size_t kspec = Vphase->spGlobalIndexVCS(k);
if (kspec >= m_numComponents) {
if (!do_deleted &&
(m_speciesStatus[kspec] == VCS_SPECIES_DELETED)) {
continue;
}
}
if (m_speciesUnknownType[kspec] == VCS_SPECIES_TYPE_INTERFACIALVOLTAGE) {
AssertThrowMsg(molNum[kspec] == phi, "VCS_SOLVE::vcs_chemPotPhase",
"We have an inconsistency!");
AssertThrowMsg(m_chargeSpecies[kspec] == -1.0, "VCS_SOLVE::vcs_chemPotPhase",
"We have an unexpected situation!");
mu_i[kspec] = m_SSfeSpecies[kspec] + m_chargeSpecies[kspec] * Faraday_phi;
} else {
if (m_SSPhase[kspec]) {
mu_i[kspec] = m_SSfeSpecies[kspec] + m_chargeSpecies[kspec] * Faraday_phi;
} else if (molNum[kspec] <= VCS_DELETE_MINORSPECIES_CUTOFF) {
mu_i[kspec] = m_SSfeSpecies[kspec] + log(ac[kspec] * VCS_DELETE_MINORSPECIES_CUTOFF)
- tlogMoles - m_lnMnaughtSpecies[kspec] + m_chargeSpecies[kspec] * Faraday_phi;
} else {
mu_i[kspec] = m_SSfeSpecies[kspec] + log(ac[kspec] * molNum[kspec])
- tlogMoles - m_lnMnaughtSpecies[kspec] + m_chargeSpecies[kspec] * Faraday_phi;
}
}
}
}
void VCS_SOLVE::vcs_dfe(const int stateCalc,
const int ll, const size_t lbot, const size_t ltop)
{
double* tPhMoles_ptr=0;
double* actCoeff_ptr=0;
double* feSpecies=0;
double* molNum=0;
if (stateCalc == VCS_STATECALC_OLD) {
feSpecies = &m_feSpecies_old[0];
tPhMoles_ptr = &m_tPhaseMoles_old[0];
actCoeff_ptr = &m_actCoeffSpecies_old[0];
molNum = &m_molNumSpecies_old[0];
} else if (stateCalc == VCS_STATECALC_NEW) {
feSpecies = &m_feSpecies_new[0];
tPhMoles_ptr = &m_tPhaseMoles_new[0];
actCoeff_ptr = &m_actCoeffSpecies_new[0];
molNum = &m_molNumSpecies_new[0];
} else if (DEBUG_MODE_ENABLED) {
throw CanteraError("VCS_SOLVE::vcs_dfe",
"Subroutine vcs_dfe called with bad stateCalc value: {}", stateCalc);
}
AssertThrowMsg(m_unitsState != VCS_DIMENSIONAL_G, "VCS_SOLVE::vcs_dfe",
"called with wrong units state");
if (DEBUG_MODE_ENABLED && m_debug_print_lvl >= 2) {
if (ll == 0) {
if (lbot != 0) {
plogf(" --- Subroutine vcs_dfe called for one species: ");
plogf("%-12.12s", m_speciesName[lbot]);
} else {
plogf(" --- Subroutine vcs_dfe called for all species");
}
} else if (ll > 0) {
plogf(" --- Subroutine vcs_dfe called for components and minors");
} else {
plogf(" --- Subroutine vcs_dfe called for components and majors");
}
if (stateCalc == VCS_STATECALC_NEW) {
plogf(" using tentative solution");
}
plogendl();
}
double* tlogMoles = &m_TmpPhase[0];
/*
* Might as well recalculate the phase mole vector
* and compare to the stored one. They should be correct.
*/
double* tPhInertMoles = &TPhInertMoles[0];
for (size_t iph = 0; iph < m_numPhases; iph++) {
tlogMoles[iph] = tPhInertMoles[iph];
}
for (size_t kspec = 0; kspec < m_numSpeciesTot; kspec++) {
if (m_speciesUnknownType[kspec] != VCS_SPECIES_TYPE_INTERFACIALVOLTAGE) {
size_t iph = m_phaseID[kspec];
tlogMoles[iph] += molNum[kspec];
}
}
for (size_t iph = 0; iph < m_numPhases; iph++) {
AssertThrowMsg(vcs_doubleEqual(tlogMoles[iph], tPhMoles_ptr[iph]),
"VCS_SOLVE::vcs_dfe",
"phase Moles may be off, iph = " + int2str(iph) + ", " +
fp2str(tlogMoles[iph]) + " " + fp2str(tPhMoles_ptr[iph]));
}
m_TmpPhase.assign(m_TmpPhase.size(), 0.0);
for (size_t iph = 0; iph < m_numPhases; iph++) {
if (tPhMoles_ptr[iph] > 0.0) {
tlogMoles[iph] = log(tPhMoles_ptr[iph]);
}
}
size_t l1, l2;
if (ll != 0) {
l1 = lbot;
l2 = m_numComponents;
} else {
l1 = lbot;
l2 = ltop;
}
/*
* Calculate activity coefficients for all phases that are
* not current. Here we also trigger an update check for each
* VolPhase to see if its mole numbers are current with vcs
*/
for (size_t iphase = 0; iphase < m_numPhases; iphase++) {
vcs_VolPhase* Vphase = m_VolPhaseList[iphase];
Vphase->updateFromVCS_MoleNumbers(stateCalc);
if (!Vphase->m_singleSpecies) {
Vphase->sendToVCS_ActCoeff(stateCalc, &actCoeff_ptr[0]);
}
m_phasePhi[iphase] = Vphase->electricPotential();
}
/* ************************************************************** */
/* **** ALL SPECIES, OR COMPONENTS ****************************** */
/* ************************************************************** */
/*
* Do all of the species when LL = 0. Then we are done for the routine
* When LL ne 0., just do the initial components. We will then
* finish up below with loops over either the major noncomponent
* species or the minor noncomponent species.
*/
for (size_t kspec = l1; kspec < l2; ++kspec) {
size_t iphase = m_phaseID[kspec];
if (m_speciesUnknownType[kspec] == VCS_SPECIES_TYPE_INTERFACIALVOLTAGE) {
AssertThrowMsg(molNum[kspec] == m_phasePhi[iphase], "VCS_SOLVE::vcs_dfe",
"We have an inconsistency!");
AssertThrowMsg(m_chargeSpecies[kspec] == -1.0, "VCS_SOLVE::vcs_dfe",
"We have an unexpected situation!");
feSpecies[kspec] = m_SSfeSpecies[kspec]
+ m_chargeSpecies[kspec] * m_Faraday_dim * m_phasePhi[iphase];
} else {
if (m_SSPhase[kspec]) {
feSpecies[kspec] = m_SSfeSpecies[kspec]
+ m_chargeSpecies[kspec] * m_Faraday_dim * m_phasePhi[iphase];
} else if ((m_speciesStatus[kspec] == VCS_SPECIES_ZEROEDMS) ||
(m_speciesStatus[kspec] == VCS_SPECIES_ZEROEDPHASE)) {
feSpecies[kspec] = m_SSfeSpecies[kspec] - m_lnMnaughtSpecies[kspec]
+ m_chargeSpecies[kspec] * m_Faraday_dim * m_phasePhi[iphase];
} else {
if (molNum[kspec] <= VCS_DELETE_MINORSPECIES_CUTOFF) {
size_t iph = m_phaseID[kspec];
if (tPhMoles_ptr[iph] > 0.0) {
feSpecies[kspec] = m_SSfeSpecies[kspec]
+ log(actCoeff_ptr[kspec] * VCS_DELETE_MINORSPECIES_CUTOFF)
- tlogMoles[m_phaseID[kspec]] - m_lnMnaughtSpecies[kspec]
+ m_chargeSpecies[kspec] * m_Faraday_dim * m_phasePhi[iphase];
} else {
feSpecies[kspec] = m_SSfeSpecies[kspec] - m_lnMnaughtSpecies[kspec]
+ m_chargeSpecies[kspec] * m_Faraday_dim * m_phasePhi[iphase];
}
} else {
feSpecies[kspec] = m_SSfeSpecies[kspec]
+ log(actCoeff_ptr[kspec] * molNum[kspec])
- tlogMoles[m_phaseID[kspec]] - m_lnMnaughtSpecies[kspec]
+ m_chargeSpecies[kspec] * m_Faraday_dim * m_phasePhi[iphase];
}
}
}
}
/* ************************************************ */
/* **** MAJORS ONLY ******************************* */
/* ************************************************ */
if (ll < 0) {
for (size_t irxn = 0; irxn < m_numRxnRdc; ++irxn) {
size_t kspec = m_indexRxnToSpecies[irxn];
if (m_speciesStatus[kspec] != VCS_SPECIES_MINOR) {
size_t iphase = m_phaseID[kspec];
if (m_speciesUnknownType[kspec] == VCS_SPECIES_TYPE_INTERFACIALVOLTAGE) {
AssertThrowMsg(molNum[kspec] == m_phasePhi[iphase], "VCS_SOLVE::vcs_dfe",
"We have an inconsistency!");
AssertThrowMsg(m_chargeSpecies[kspec] == -1.0, "VCS_SOLVE::vcs_dfe",
"We have an unexpected situation!");
feSpecies[kspec] = m_SSfeSpecies[kspec]
+ m_chargeSpecies[kspec] * m_Faraday_dim * m_phasePhi[iphase];
} else {
if (m_SSPhase[kspec]) {
feSpecies[kspec] = m_SSfeSpecies[kspec]
+ m_chargeSpecies[kspec] * m_Faraday_dim * m_phasePhi[iphase];
} else if ((m_speciesStatus[kspec] == VCS_SPECIES_ZEROEDMS) ||
(m_speciesStatus[kspec] == VCS_SPECIES_ZEROEDPHASE)) {
feSpecies[kspec] = m_SSfeSpecies[kspec] - m_lnMnaughtSpecies[kspec]
+ m_chargeSpecies[kspec] * m_Faraday_dim * m_phasePhi[iphase];
} else {
if (molNum[kspec] <= VCS_DELETE_MINORSPECIES_CUTOFF) {
size_t iph = m_phaseID[kspec];
if (tPhMoles_ptr[iph] > 0.0) {
feSpecies[kspec] = m_SSfeSpecies[kspec]
+ log(actCoeff_ptr[kspec] * VCS_DELETE_MINORSPECIES_CUTOFF)
- tlogMoles[m_phaseID[kspec]] - m_lnMnaughtSpecies[kspec]
+ m_chargeSpecies[kspec] * m_Faraday_dim * m_phasePhi[iphase];
} else {
feSpecies[kspec] = m_SSfeSpecies[kspec] - m_lnMnaughtSpecies[kspec]
+ m_chargeSpecies[kspec] * m_Faraday_dim * m_phasePhi[iphase];
}
} else {
feSpecies[kspec] = m_SSfeSpecies[kspec]
+ log(actCoeff_ptr[kspec] * molNum[kspec])
- tlogMoles[m_phaseID[kspec]] - m_lnMnaughtSpecies[kspec]
+ m_chargeSpecies[kspec] * m_Faraday_dim * m_phasePhi[iphase];
}
}
}
}
}
/* ************************************************ */
/* **** MINORS ONLY ******************************* */
/* ************************************************ */
} else if (ll > 0) {
for (size_t irxn = 0; irxn < m_numRxnRdc; ++irxn) {
size_t kspec = m_indexRxnToSpecies[irxn];
if (m_speciesStatus[kspec] == VCS_SPECIES_MINOR) {
size_t iphase = m_phaseID[kspec];
if (m_speciesUnknownType[kspec] == VCS_SPECIES_TYPE_INTERFACIALVOLTAGE) {
AssertThrowMsg(molNum[kspec] == m_phasePhi[iphase], "VCS_SOLVE::vcs_dfe",
"We have an inconsistency!");
AssertThrowMsg(m_chargeSpecies[kspec] == -1.0, "VCS_SOLVE::vcs_dfe",
"We have an unexpected situation!");
feSpecies[kspec] = m_SSfeSpecies[kspec]
+ m_chargeSpecies[kspec] * m_Faraday_dim * m_phasePhi[iphase];
} else {
if (m_SSPhase[kspec]) {
feSpecies[kspec] = m_SSfeSpecies[kspec]
+ m_chargeSpecies[kspec] * m_Faraday_dim * m_phasePhi[iphase];
} else if ((m_speciesStatus[kspec] == VCS_SPECIES_ZEROEDMS) ||
(m_speciesStatus[kspec] == VCS_SPECIES_ZEROEDPHASE)) {
feSpecies[kspec] = m_SSfeSpecies[kspec] - m_lnMnaughtSpecies[kspec]
+ m_chargeSpecies[kspec] * m_Faraday_dim * m_phasePhi[iphase];
} else {
if (molNum[kspec] <= VCS_DELETE_MINORSPECIES_CUTOFF) {
size_t iph = m_phaseID[kspec];
if (tPhMoles_ptr[iph] > 0.0) {
feSpecies[kspec] = m_SSfeSpecies[kspec]
+ log(actCoeff_ptr[kspec] * VCS_DELETE_MINORSPECIES_CUTOFF)
- tlogMoles[m_phaseID[kspec]] - m_lnMnaughtSpecies[kspec]
+ m_chargeSpecies[kspec] * m_Faraday_dim * m_phasePhi[iphase];
} else {
feSpecies[kspec] = m_SSfeSpecies[kspec] - m_lnMnaughtSpecies[kspec]
+ m_chargeSpecies[kspec] * m_Faraday_dim * m_phasePhi[iphase];
}
} else {
feSpecies[kspec] = m_SSfeSpecies[kspec]
+ log(actCoeff_ptr[kspec] * molNum[kspec])
- tlogMoles[m_phaseID[kspec]] - m_lnMnaughtSpecies[kspec]
+ m_chargeSpecies[kspec] * m_Faraday_dim * m_phasePhi[iphase];
}
}
}
}
}
}
}
void VCS_SOLVE::vcs_printSpeciesChemPot(const int stateCalc) const
{
double mfValue = 1.0;
bool zeroedPhase = false;
const double* molNum = &m_molNumSpecies_old[0];
const double* actCoeff_ptr = &m_actCoeffSpecies_old[0];
if (stateCalc == VCS_STATECALC_NEW) {
actCoeff_ptr = &m_actCoeffSpecies_new[0];
molNum = &m_molNumSpecies_new[0];
}
double* tMoles = &m_TmpPhase[0];
const double* tPhInertMoles = &TPhInertMoles[0];
for (size_t iph = 0; iph < m_numPhases; iph++) {
tMoles[iph] = tPhInertMoles[iph];
}
for (size_t kspec = 0; kspec < m_numSpeciesTot; kspec++) {
if (m_speciesUnknownType[kspec] != VCS_SPECIES_TYPE_INTERFACIALVOLTAGE) {
size_t iph = m_phaseID[kspec];
tMoles[iph] += molNum[kspec];
}
}
double RT = m_temperature * GasConstant;
writelog(" --- CHEMICAL POT TABLE (J/kmol) Name PhID MolFR ChemoSS "
" logMF Gamma Elect extra ElectrChem\n");
writelog(" ");
writeline('-', 132);
for (size_t kspec = 0; kspec < m_numSpeciesTot; ++kspec) {
mfValue = 1.0;
size_t iphase = m_phaseID[kspec];
const vcs_VolPhase* Vphase = m_VolPhaseList[iphase];
if ((m_speciesStatus[kspec] == VCS_SPECIES_ZEROEDMS) ||
(m_speciesStatus[kspec] == VCS_SPECIES_ZEROEDPHASE) ||
(m_speciesStatus[kspec] == VCS_SPECIES_ZEROEDSS)) {
zeroedPhase = true;
} else {
zeroedPhase = false;
}
if (tMoles[iphase] > 0.0) {
if (molNum[kspec] <= VCS_DELETE_MINORSPECIES_CUTOFF) {
mfValue = VCS_DELETE_MINORSPECIES_CUTOFF / tMoles[iphase];
} else {
mfValue = molNum[kspec]/tMoles[iphase];
}
} else {
size_t klocal = m_speciesLocalPhaseIndex[kspec];
mfValue = Vphase->moleFraction(klocal);
}
double volts = Vphase->electricPotential();
double elect = m_chargeSpecies[kspec] * m_Faraday_dim * volts;
double comb = - m_lnMnaughtSpecies[kspec];
double total = (m_SSfeSpecies[kspec] + log(mfValue) + elect + log(actCoeff_ptr[kspec]) + comb);
if (zeroedPhase) {
writelog(" --- ** zp *** ");
} else {
writelog(" --- ");
}
writelogf("%-24.24s", m_speciesName[kspec]);
writelogf(" %3d", iphase);
writelogf(" % -12.4e", mfValue);
writelogf(" % -12.4e", m_SSfeSpecies[kspec] * RT);
writelogf(" % -12.4e", log(mfValue) * RT);
writelogf(" % -12.4e", log(actCoeff_ptr[kspec]) * RT);
writelogf(" % -12.4e", elect * RT);
writelogf(" % -12.4e", comb * RT);
writelogf(" % -12.4e\n", total *RT);
}
writelog(" ");
writeline('-', 132);
}
#ifdef DEBUG_MODE
void VCS_SOLVE::prneav() const
{
vector_fp eav(m_numElemConstraints, 0.0);
for (size_t j = 0; j < m_numElemConstraints; ++j) {
for (size_t i = 0; i < m_numSpeciesTot; ++i) {
if (m_speciesUnknownType[i] == VCS_SPECIES_TYPE_INTERFACIALVOLTAGE) {
eav[j] += m_formulaMatrix(i,j) * m_molNumSpecies_old[i];
}
}
}
bool kerr = false;
plogf("--------------------------------------------------");
plogf("ELEMENT ABUNDANCE VECTOR:\n");
plogf(" Element Now Orignal Deviation Type\n");
for (size_t j = 0; j < m_numElemConstraints; ++j) {
plogf(" ");
plogf("%-2.2s", m_elementName[j]);
plogf(" = %15.6E %15.6E %15.6E %3d\n",
eav[j], m_elemAbundancesGoal[j], eav[j] - m_elemAbundancesGoal[j], m_elType[j]);
if (m_elemAbundancesGoal[j] != 0.) {
if (fabs(eav[j] - m_elemAbundancesGoal[j]) > m_elemAbundancesGoal[j] * 5.0e-9) {
kerr = true;
}
} else {
if (fabs(eav[j]) > 1.0e-10) {
kerr = true;
}
}
}
if (kerr) {
plogf("Element abundance check failure\n");
}
plogf("--------------------------------------------------");
plogendl();
}
#endif
double VCS_SOLVE::l2normdg(double dgLocal[]) const
{
if (m_numRxnRdc <= 0) {
return 0.0;
}
double tmp = 0;
for (size_t irxn = 0; irxn < m_numRxnRdc; ++irxn) {
size_t kspec = irxn + m_numComponents;
if (m_speciesStatus[kspec] == VCS_SPECIES_MAJOR || m_speciesStatus[kspec] == VCS_SPECIES_MINOR ||
dgLocal[irxn] < 0.0) {
if (m_speciesStatus[kspec] != VCS_SPECIES_ZEROEDMS) {
tmp += dgLocal[irxn] * dgLocal[irxn];
}
}
}
return std::sqrt(tmp / m_numRxnRdc);
}
double VCS_SOLVE::vcs_tmoles()
{
for (size_t i = 0; i < m_numPhases; i++) {
m_tPhaseMoles_old[i] = TPhInertMoles[i];
}
for (size_t i = 0; i < m_numSpeciesTot; i++) {
if (m_speciesUnknownType[i] == VCS_SPECIES_TYPE_MOLNUM) {
m_tPhaseMoles_old[m_phaseID[i]] += m_molNumSpecies_old[i];
}
}
double sum = 0.0;
for (size_t i = 0; i < m_numPhases; i++) {
sum += m_tPhaseMoles_old[i];
vcs_VolPhase* Vphase = m_VolPhaseList[i];
if (m_tPhaseMoles_old[i] == 0.0) {
Vphase->setTotalMoles(0.0);
} else {
Vphase->setTotalMoles(m_tPhaseMoles_old[i]);
}
}
m_totalMolNum = sum;
return m_totalMolNum;
}
#ifdef DEBUG_MODE
void VCS_SOLVE::check_tmoles() const
{
double sum = 0.0;
for (size_t i = 0; i < m_numPhases; i++) {
double m_tPhaseMoles_old_a = TPhInertMoles[i];
for (size_t k = 0; k < m_numSpeciesTot; k++) {
if (m_speciesUnknownType[k] == VCS_SPECIES_TYPE_MOLNUM && m_phaseID[k] == i) {
m_tPhaseMoles_old_a += m_molNumSpecies_old[k];
}
}
sum += m_tPhaseMoles_old_a;
double denom = m_tPhaseMoles_old[i]+ m_tPhaseMoles_old_a + 1.0E-19;
if (!vcs_doubleEqual(m_tPhaseMoles_old[i]/denom, m_tPhaseMoles_old_a/denom)) {
plogf("check_tmoles: we have found a problem with phase %d: %20.15g, %20.15g\n",
i, m_tPhaseMoles_old[i], m_tPhaseMoles_old_a);
}
}
}
#endif
void VCS_SOLVE::vcs_updateVP(const int vcsState)
{
for (size_t i = 0; i < m_numPhases; i++) {
vcs_VolPhase* Vphase = m_VolPhaseList[i];
if (vcsState == VCS_STATECALC_OLD) {
Vphase->setMolesFromVCSCheck(VCS_STATECALC_OLD,
&m_molNumSpecies_old[0],
&m_tPhaseMoles_old[0]);
} else if (vcsState == VCS_STATECALC_NEW) {
Vphase->setMolesFromVCSCheck(VCS_STATECALC_NEW,
&m_molNumSpecies_new[0],
&m_tPhaseMoles_new[0]);
} else if (DEBUG_MODE_ENABLED) {
throw CanteraError("VCS_SOLVE::vcs_updateVP",
"wrong stateCalc value: {}", vcsState);
}
}
}
bool VCS_SOLVE::vcs_evaluate_speciesType()
{
m_numRxnMinorZeroed = 0;
if (DEBUG_MODE_ENABLED && m_debug_print_lvl >= 2) {
plogf(" --- Species Status decision is reevaluated: All species are minor except for:\n");
} else if (DEBUG_MODE_ENABLED && m_debug_print_lvl >= 5) {
plogf(" --- Species Status decision is reevaluated");
plogendl();
}
for (size_t kspec = 0; kspec < m_numSpeciesTot; ++kspec) {
m_speciesStatus[kspec] = vcs_species_type(kspec);
if (DEBUG_MODE_ENABLED && m_debug_print_lvl >= 5) {
plogf(" --- %-16s: ", m_speciesName[kspec]);
if (kspec < m_numComponents) {
plogf("(COMP) ");
} else {
plogf(" ");
}
plogf(" %10.3g ", m_molNumSpecies_old[kspec]);
const char* sString = vcs_speciesType_string(m_speciesStatus[kspec], 100);
plogf("%s\n", sString);
} else if (DEBUG_MODE_ENABLED && m_debug_print_lvl >= 2) {
if (m_speciesStatus[kspec] != VCS_SPECIES_MINOR) {
switch (m_speciesStatus[kspec]) {
case VCS_SPECIES_COMPONENT:
break;
case VCS_SPECIES_MAJOR:
plogf(" --- Major Species : %-s\n", m_speciesName[kspec]);
break;
case VCS_SPECIES_ZEROEDPHASE:
plogf(" --- Purposely Zeroed-Phase Species (not in problem): %-s\n",
m_speciesName[kspec]);
break;
case VCS_SPECIES_ZEROEDMS:
plogf(" --- Zeroed-MS Phase Species: %-s\n", m_speciesName[kspec]);
break;
case VCS_SPECIES_ZEROEDSS:
plogf(" --- Zeroed-SS Phase Species: %-s\n", m_speciesName[kspec]);
break;
case VCS_SPECIES_DELETED:
plogf(" --- Deleted-Small Species : %-s\n", m_speciesName[kspec]);
break;
case VCS_SPECIES_ACTIVEBUTZERO:
plogf(" --- Zeroed Species in an active MS phase (tmp): %-s\n",
m_speciesName[kspec]);
break;
case VCS_SPECIES_STOICHZERO:
plogf(" --- Zeroed Species in an active MS phase (Stoich Constraint): %-s\n",
m_speciesName[kspec]);
break;
case VCS_SPECIES_INTERFACIALVOLTAGE:
plogf(" --- InterfaceVoltage Species: %-s\n", m_speciesName[kspec]);
break;
default:
throw CanteraError("VCS_SOLVE::vcs_evaluate_speciesType",
"Unknown type: {}", m_speciesStatus[kspec]);
}
}
}
if (kspec >= m_numComponents && m_speciesStatus[kspec] != VCS_SPECIES_MAJOR) {
++m_numRxnMinorZeroed;
}
}
if (DEBUG_MODE_ENABLED && m_debug_print_lvl >= 2) {
plogf(" ---");
plogendl();
}
return (m_numRxnMinorZeroed >= m_numRxnRdc);
}
void VCS_SOLVE::vcs_deltag(const int l, const bool doDeleted,
const int vcsState, const bool alterZeroedPhases)
{
int icase = 0;
size_t irxnl = m_numRxnRdc;
if (doDeleted) {
irxnl = m_numRxnTot;
}
double* deltaGRxn;
double* feSpecies;
double* molNumSpecies;
double* actCoeffSpecies;
if (vcsState == VCS_STATECALC_NEW) {
deltaGRxn = &m_deltaGRxn_new[0];
feSpecies = &m_feSpecies_new[0];
molNumSpecies = &m_molNumSpecies_new[0];
actCoeffSpecies = &m_actCoeffSpecies_new[0];
} else if (vcsState == VCS_STATECALC_OLD) {
deltaGRxn = &m_deltaGRxn_old[0];
feSpecies = &m_feSpecies_old[0];
molNumSpecies = &m_molNumSpecies_old[0];
actCoeffSpecies = &m_actCoeffSpecies_old[0];
} else {
throw CanteraError("VCS_SOLVE::vcs_deltag", "bad vcsState");
}
if (DEBUG_MODE_ENABLED && m_debug_print_lvl >= 2) {
plogf(" --- Subroutine vcs_deltag called for ");
if (l < 0) {
plogf("major noncomponents\n");
} else if (l == 0) {
plogf("all noncomponents\n");
} else {
plogf("minor noncomponents\n");
}
}
/* ************************************************* */
/* **** MAJORS and ZEROED SPECIES ONLY ************* */
/* ************************************************* */
if (l < 0) {
for (size_t irxn = 0; irxn < m_numRxnRdc; ++irxn) {
size_t kspec = irxn + m_numComponents;
if (m_speciesStatus[kspec] != VCS_SPECIES_MINOR) {
icase = 0;
deltaGRxn[irxn] = feSpecies[m_indexRxnToSpecies[irxn]];
double* dtmp_ptr = m_stoichCoeffRxnMatrix.ptrColumn(irxn);
for (kspec = 0; kspec < m_numComponents; ++kspec) {
deltaGRxn[irxn] += dtmp_ptr[kspec] * feSpecies[kspec];
if (molNumSpecies[kspec] < VCS_DELETE_MINORSPECIES_CUTOFF && dtmp_ptr[kspec] < 0.0) {
icase = 1;
}
}
if (icase) {
deltaGRxn[irxn] = std::max(0.0, deltaGRxn[irxn]);
}
}
}
} else if (l == 0) {
/* ************************************************* */
/* **** ALL REACTIONS ****************************** */
/* ************************************************* */
for (size_t irxn = 0; irxn < irxnl; ++irxn) {
icase = 0;
deltaGRxn[irxn] = feSpecies[m_indexRxnToSpecies[irxn]];
double* dtmp_ptr = m_stoichCoeffRxnMatrix.ptrColumn(irxn);
for (size_t kspec = 0; kspec < m_numComponents; ++kspec) {
deltaGRxn[irxn] += dtmp_ptr[kspec] * feSpecies[kspec];
if (molNumSpecies[kspec] < VCS_DELETE_MINORSPECIES_CUTOFF &&
dtmp_ptr[kspec] < 0.0) {
icase = 1;
}
}
if (icase) {
deltaGRxn[irxn] = std::max(0.0, deltaGRxn[irxn]);
}
}
} else {
/* ************************************************* */
/* **** MINORS AND ZEROED SPECIES ****************** */
/* ************************************************* */
for (size_t irxn = 0; irxn < m_numRxnRdc; ++irxn) {
size_t kspec = irxn + m_numComponents;
if (m_speciesStatus[kspec] <= VCS_SPECIES_MINOR) {
icase = 0;
deltaGRxn[irxn] = feSpecies[m_indexRxnToSpecies[irxn]];
double* dtmp_ptr = m_stoichCoeffRxnMatrix.ptrColumn(irxn);
for (kspec = 0; kspec < m_numComponents; ++kspec) {
deltaGRxn[irxn] += dtmp_ptr[kspec] * feSpecies[kspec];
if (m_molNumSpecies_old[kspec] < VCS_DELETE_MINORSPECIES_CUTOFF &&
dtmp_ptr[kspec] < 0.0) {
icase = 1;
}
}
if (icase) {
deltaGRxn[irxn] = std::max(0.0, deltaGRxn[irxn]);
}
}
}
}
/* ************************************************* */
/* **** MULTISPECIES PHASES WITH ZERO MOLES ******** */
/* ************************************************* */
/*
* Massage the free energies for species with zero mole fractions
* in multispecies phases. This section implements the
* Equation 3.8-5 in Smith and Missen, p.59.
* A multispecies phase will exist iff
* 1 < sum_i(exp(-dg_i)/AC_i)
* If DG is negative then that species wants to be reintroduced into
* the calculation.
* For small dg_i, the expression below becomes:
* 1 - sum_i(exp(-dg_i)/AC_i) ~ sum_i((dg_i-1)/AC_i) + 1
*
* So, what we are doing here is equalizing all DG's in a multispecies
* phase whose total mole number has already been zeroed out.
* It must have to do with the case where a complete multispecies
* phase is currently zeroed out. In that case, when one species
* in that phase has a negative DG, then the phase should kick in.
* This code section will cause that to happen, because a negative
* DG will dominate the calculation of SDEL. Then, DG(I) for all
* species in that phase will be forced to be equal and negative.
* Thus, all species in that phase will come into being at the
* same time.
*
* HKM -> The ratio of mole fractions at the reinstatement
* time should be equal to the normalized weighting
* of exp(-dg_i) / AC_i. This should be implemented.
*
* HKM -> There is circular logic here. ActCoeff depends on the
* mole fractions of a phase that does not exist. In actuality
* the proto-mole fractions should be selected from the
* solution of a nonlinear problem with NsPhase unknowns
*
* X_i = exp(-dg[irxn]) / ActCoeff_i / denom
*
* where
* denom = sum_i[ exp(-dg[irxn]) / ActCoeff_i ]
*
* This can probably be solved by successive iteration.
* This should be implemented.
*/
if (alterZeroedPhases && false) {
for (size_t iph = 0; iph < m_numPhases; iph++) {
bool lneed = false;
vcs_VolPhase* Vphase = m_VolPhaseList[iph];
if (! Vphase->m_singleSpecies) {
double sum = 0.0;
for (size_t k = 0; k < Vphase->nSpecies(); k++) {
size_t kspec = Vphase->spGlobalIndexVCS(k);
if (m_speciesUnknownType[kspec] != VCS_SPECIES_TYPE_INTERFACIALVOLTAGE) {
sum += molNumSpecies[kspec];
}
if (sum > 0.0) {
break;
}
}
if (sum == 0.0) {
lneed = true;
}
}
if (lneed) {
double poly = 0.0;
for (size_t k = 0; k < Vphase->nSpecies(); k++) {
size_t kspec = Vphase->spGlobalIndexVCS(k);
// We may need to look at deltaGRxn for components!
if (kspec >= m_numComponents) {
size_t irxn = kspec - m_numComponents;
deltaGRxn[irxn] = clip(deltaGRxn[irxn], -50.0, 50.0);
poly += exp(-deltaGRxn[irxn])/actCoeffSpecies[kspec];
}
}
/*
* Calculate deltaGRxn[] for each species in a zeroed multispecies phase.
* All of the m_deltaGRxn_new[]'s will be equal. If deltaGRxn[] is
* negative, then the phase will come back into existence.
*/
for (size_t k = 0; k < Vphase->nSpecies(); k++) {
size_t kspec = Vphase->spGlobalIndexVCS(k);
if (kspec >= m_numComponents) {
size_t irxn = kspec - m_numComponents;
deltaGRxn[irxn] = 1.0 - poly;
}
}
}
}
}
}
void VCS_SOLVE::vcs_printDeltaG(const int stateCalc)
{
double* deltaGRxn = &m_deltaGRxn_old[0];
double* feSpecies = &m_feSpecies_old[0];
double* molNumSpecies = &m_molNumSpecies_old[0];
const double* tPhMoles_ptr = &m_tPhaseMoles_old[0];
const double* actCoeff_ptr = &m_actCoeffSpecies_old[0];
if (stateCalc == VCS_STATECALC_NEW) {
deltaGRxn = &m_deltaGRxn_new[0];
feSpecies = &m_feSpecies_new[0];
molNumSpecies = &m_molNumSpecies_new[0];
actCoeff_ptr = &m_actCoeffSpecies_new[0];
tPhMoles_ptr = &m_tPhaseMoles_new[0];
}
double RT = m_temperature * GasConstant;
bool zeroedPhase = false;
if (m_debug_print_lvl >= 2) {
plogf(" --- DELTA_G TABLE Components:");
for (size_t j = 0; j < m_numComponents; j++) {
plogf(" %3d ", j);
}
plogf("\n --- Components Moles:");
for (size_t j = 0; j < m_numComponents; j++) {
plogf("%10.3g", m_molNumSpecies_old[j]);
}
plogf("\n --- NonComponent| Moles | ");
for (size_t j = 0; j < m_numComponents; j++) {
plogf("%-10.10s", m_speciesName[j]);
}
plogf("\n");
for (size_t i = 0; i < m_numRxnTot; i++) {
plogf(" --- %3d ", m_indexRxnToSpecies[i]);
plogf("%-10.10s", m_speciesName[m_indexRxnToSpecies[i]]);
if (m_speciesUnknownType[m_indexRxnToSpecies[i]] == VCS_SPECIES_TYPE_INTERFACIALVOLTAGE) {
plogf("| NA |");
} else {
plogf("|%10.3g|", m_molNumSpecies_old[m_indexRxnToSpecies[i]]);
}
for (size_t j = 0; j < m_numComponents; j++) {
plogf(" %6.2f", m_stoichCoeffRxnMatrix(j,i));
}
plogf("\n");
}
plogf(" ");
for (int i=0; i<77; i++) {
plogf("-");
}
plogf("\n");
}
writelog(" --- DeltaG Table (J/kmol) Name PhID MoleNum MolFR "
" ElectrChemStar ElectrChem DeltaGStar DeltaG(Pred) Stability\n");
writelog(" ");
writeline('-', 132);
for (size_t kspec = 0; kspec < m_numSpeciesTot; kspec++) {
size_t irxn = npos;
if (kspec >= m_numComponents) {
irxn = kspec - m_numComponents;
}
double mfValue = 1.0;
size_t iphase = m_phaseID[kspec];
const vcs_VolPhase* Vphase = m_VolPhaseList[iphase];
if ((m_speciesStatus[kspec] == VCS_SPECIES_ZEROEDMS) ||
(m_speciesStatus[kspec] == VCS_SPECIES_ZEROEDPHASE) ||
(m_speciesStatus[kspec] == VCS_SPECIES_ZEROEDSS)) {
zeroedPhase = true;
} else {
zeroedPhase = false;
}
if (tPhMoles_ptr[iphase] > 0.0) {
if (molNumSpecies[kspec] <= VCS_DELETE_MINORSPECIES_CUTOFF) {
mfValue = VCS_DELETE_MINORSPECIES_CUTOFF / tPhMoles_ptr[iphase];
} else {
mfValue = molNumSpecies[kspec] / tPhMoles_ptr[iphase];
}
} else {
size_t klocal = m_speciesLocalPhaseIndex[kspec];
mfValue = Vphase->moleFraction(klocal);
}
if (zeroedPhase) {
writelog(" --- ** zp *** ");
} else {
writelog(" --- ");
}
double feFull = feSpecies[kspec];
if ((m_speciesStatus[kspec] == VCS_SPECIES_ZEROEDMS) ||
(m_speciesStatus[kspec] == VCS_SPECIES_ZEROEDPHASE)) {
feFull += log(actCoeff_ptr[kspec]) + log(mfValue);
}
writelogf("%-24.24s", m_speciesName[kspec]);
writelogf(" %3d", iphase);
if (m_speciesUnknownType[kspec] == VCS_SPECIES_TYPE_INTERFACIALVOLTAGE) {
writelog(" NA ");
} else {
writelogf(" % -12.4e", molNumSpecies[kspec]);
}
writelogf(" % -12.4e", mfValue);
writelogf(" % -12.4e", feSpecies[kspec] * RT);
writelogf(" % -12.4e", feFull * RT);
if (irxn != npos) {
writelogf(" % -12.4e", deltaGRxn[irxn] * RT);
writelogf(" % -12.4e", (deltaGRxn[irxn] + feFull - feSpecies[kspec]) * RT);
if (deltaGRxn[irxn] < 0.0) {
if (molNumSpecies[kspec] > 0.0) {
writelog(" growing");
} else {
writelog(" stable");
}
} else if (deltaGRxn[irxn] > 0.0) {
if (molNumSpecies[kspec] > 0.0) {
writelog(" shrinking");
} else {
writelog(" unstable");
}
} else {
writelog(" balanced");
}
}
writelog(" \n");
}
writelog(" ");
writeline('-', 132);
}
void VCS_SOLVE::vcs_deltag_Phase(const size_t iphase, const bool doDeleted,
const int stateCalc, const bool alterZeroedPhases)
{
double* feSpecies=0;
double* deltaGRxn=0;
double* actCoeffSpecies=0;
if (stateCalc == VCS_STATECALC_NEW) {
feSpecies = &m_feSpecies_new[0];
deltaGRxn = &m_deltaGRxn_new[0];
actCoeffSpecies = &m_actCoeffSpecies_new[0];
} else if (stateCalc == VCS_STATECALC_OLD) {
feSpecies = &m_feSpecies_old[0];
deltaGRxn = &m_deltaGRxn_old[0];
actCoeffSpecies = &m_actCoeffSpecies_old[0];
} else if (DEBUG_MODE_ENABLED) {
throw CanteraError("VCS_SOLVE::vcs_deltag_Phase", "bad stateCalc");
}
size_t irxnl = m_numRxnRdc;
if (doDeleted) {
irxnl = m_numRxnTot;
}
vcs_VolPhase* vPhase = m_VolPhaseList[iphase];
if (DEBUG_MODE_ENABLED && m_debug_print_lvl >= 2) {
plogf(" --- Subroutine vcs_deltag_Phase called for phase %d\n",
iphase);
}
/*
* Single species Phase
*/
if (vPhase->m_singleSpecies) {
size_t kspec = vPhase->spGlobalIndexVCS(0);
AssertThrowMsg(iphase == m_phaseID[kspec], "VCS_SOLVE::vcs_deltag_Phase",
"index error");
if (kspec >= m_numComponents) {
size_t irxn = kspec - m_numComponents;
deltaGRxn[irxn] = feSpecies[kspec];
for (size_t kcomp = 0; kcomp < m_numComponents; ++kcomp) {
deltaGRxn[irxn] += m_stoichCoeffRxnMatrix(kcomp,irxn) * feSpecies[kcomp];
}
}
} else {
/*
* Multispecies Phase
*/
bool zeroedPhase = true;
for (size_t irxn = 0; irxn < irxnl; ++irxn) {
size_t kspec = m_indexRxnToSpecies[irxn];
if (m_speciesUnknownType[kspec] != VCS_SPECIES_TYPE_INTERFACIALVOLTAGE && m_phaseID[kspec] == iphase) {
if (m_molNumSpecies_old[kspec] > 0.0) {
zeroedPhase = false;
}
deltaGRxn[irxn] = feSpecies[kspec];
for (size_t kcomp = 0; kcomp < m_numComponents; ++kcomp) {
deltaGRxn[irxn] += m_stoichCoeffRxnMatrix(kcomp,irxn) * feSpecies[kcomp];
}
}
}
/*
* special section for zeroed phases
*/
/* ************************************************* */
/* **** MULTISPECIES PHASES WITH ZERO MOLES************ */
/* ************************************************* */
/*
* Massage the free energies for species with zero mole fractions
* in multispecies phases. This section implements the
* Equation 3.8-5 in Smith and Missen, p.59.
* A multispecies phase will exist iff
* 1 < sum_i(exp(-dg_i)/AC_i)
* If DG is negative then that species wants to be reintroduced into
* the calculation.
* For small dg_i, the expression below becomes:
* 1 - sum_i(exp(-dg_i)/AC_i) ~ sum_i((dg_i-1)/AC_i) + 1
*
* HKM -> The ratio of mole fractions at the reinstatement
* time should be equal to the normalized weighting
* of exp(-dg_i) / AC_i. This should be implemented.
*
* HKM -> There is circular logic here. ActCoeff depends on the
* mole fractions of a phase that does not exist. In actuality
* the proto-mole fractions should be selected from the
* solution of a nonlinear problem with NsPhase unknowns
*
* X_i = exp(-dg[irxn]) / ActCoeff_i / denom
*
* where
* denom = sum_i[ exp(-dg[irxn]) / ActCoeff_i ]
*
* This can probably be solved by successive iteration.
* This should be implemented.
*
* Calculate dg[] for each species in a zeroed multispecies phase.
* All of the dg[]'s will be equal. If dg[] is negative, then
* the phase will come back into existence.
*/
if (alterZeroedPhases && zeroedPhase) {
double phaseDG = 1.0;
for (size_t irxn = 0; irxn < irxnl; ++irxn) {
size_t kspec = m_indexRxnToSpecies[irxn];
if (m_phaseID[kspec] == iphase) {
deltaGRxn[irxn] = clip(deltaGRxn[irxn], -50.0, 50.0);
phaseDG -= exp(-deltaGRxn[irxn])/actCoeffSpecies[kspec];
}
}
/*
* Overwrite the individual dg's with the phase DG.
*/
for (size_t irxn = 0; irxn < irxnl; ++irxn) {
size_t kspec = m_indexRxnToSpecies[irxn];
if (m_phaseID[kspec] == iphase) {
deltaGRxn[irxn] = 1.0 - phaseDG;
}
}
}
}
}
void VCS_SOLVE::vcs_switch_pos(const bool ifunc, const size_t k1, const size_t k2)
{
if (k1 == k2) {
return;
}
if (DEBUG_MODE_ENABLED && (k1 >= m_numSpeciesTot ||
k2 >= m_numSpeciesTot)) {
plogf("vcs_switch_pos: ifunc = 0: inappropriate args: %d %d\n",
k1, k2);
}
/*
* Handle the index pointer in the phase structures first
*/
vcs_VolPhase* pv1 = m_VolPhaseList[m_phaseID[k1]];
vcs_VolPhase* pv2 = m_VolPhaseList[m_phaseID[k2]];
size_t kp1 = m_speciesLocalPhaseIndex[k1];
size_t kp2 = m_speciesLocalPhaseIndex[k2];
AssertThrowMsg(pv1->spGlobalIndexVCS(kp1) == k1, "VCS_SOLVE::vcs_switch_pos",
"Indexing error");
AssertThrowMsg(pv2->spGlobalIndexVCS(kp2) == k2, "VCS_SOLVE::vcs_switch_pos",
"Indexing error");
pv1->setSpGlobalIndexVCS(kp1, k2);
pv2->setSpGlobalIndexVCS(kp2, k1);
std::swap(m_speciesName[k1], m_speciesName[k2]);
std::swap(m_molNumSpecies_old[k1], m_molNumSpecies_old[k2]);
std::swap(m_speciesUnknownType[k1], m_speciesUnknownType[k2]);
std::swap(m_molNumSpecies_new[k1], m_molNumSpecies_new[k2]);
std::swap(m_SSfeSpecies[k1], m_SSfeSpecies[k2]);
std::swap(m_spSize[k1], m_spSize[k2]);
std::swap(m_deltaMolNumSpecies[k1], m_deltaMolNumSpecies[k2]);
std::swap(m_feSpecies_old[k1], m_feSpecies_old[k2]);
std::swap(m_feSpecies_new[k1], m_feSpecies_new[k2]);
std::swap(m_SSPhase[k1], m_SSPhase[k2]);
std::swap(m_phaseID[k1], m_phaseID[k2]);
std::swap(m_speciesMapIndex[k1], m_speciesMapIndex[k2]);
std::swap(m_speciesLocalPhaseIndex[k1], m_speciesLocalPhaseIndex[k2]);
std::swap(m_actConventionSpecies[k1], m_actConventionSpecies[k2]);
std::swap(m_lnMnaughtSpecies[k1], m_lnMnaughtSpecies[k2]);
std::swap(m_actCoeffSpecies_new[k1], m_actCoeffSpecies_new[k2]);
std::swap(m_actCoeffSpecies_old[k1], m_actCoeffSpecies_old[k2]);
std::swap(m_wtSpecies[k1], m_wtSpecies[k2]);
std::swap(m_chargeSpecies[k1], m_chargeSpecies[k2]);
std::swap(m_speciesThermoList[k1], m_speciesThermoList[k2]);
std::swap(m_PMVolumeSpecies[k1], m_PMVolumeSpecies[k2]);
for (size_t j = 0; j < m_numElemConstraints; ++j) {
std::swap(m_formulaMatrix(k1,j), m_formulaMatrix(k2,j));
}
if (m_useActCoeffJac && k1 != k2) {
for (size_t i = 0; i < m_numSpeciesTot; i++) {
std::swap(m_np_dLnActCoeffdMolNum(k1,i), m_np_dLnActCoeffdMolNum(k2,i));
}
for (size_t i = 0; i < m_numSpeciesTot; i++) {
std::swap(m_np_dLnActCoeffdMolNum(i,k1), m_np_dLnActCoeffdMolNum(i,k2));
}
}
std::swap(m_speciesStatus[k1], m_speciesStatus[k2]);
/*
* Handle the index pointer in the phase structures
*/
if (ifunc) {
/*
* Find the Rxn indices corresponding to the two species
*/
size_t i1 = k1 - m_numComponents;
size_t i2 = k2 - m_numComponents;
if (DEBUG_MODE_ENABLED && (i1 > m_numRxnTot || i2 >= m_numRxnTot)) {
plogf("switch_pos: ifunc = 1: inappropriate noncomp values: %d %d\n",
i1 , i2);
}
for (size_t j = 0; j < m_numComponents; ++j) {
std::swap(m_stoichCoeffRxnMatrix(j,i1), m_stoichCoeffRxnMatrix(j,i2));
}
std::swap(m_scSize[i1], m_scSize[i2]);
for (size_t iph = 0; iph < m_numPhases; iph++) {
std::swap(m_deltaMolNumPhase(iph,i1), m_deltaMolNumPhase(iph,i2));
std::swap(m_phaseParticipation(iph,i1),
m_phaseParticipation(iph,i2));
}
std::swap(m_deltaGRxn_new[i1], m_deltaGRxn_new[i2]);
std::swap(m_deltaGRxn_old[i1], m_deltaGRxn_old[i2]);
std::swap(m_deltaGRxn_tmp[i1], m_deltaGRxn_tmp[i2]);
}
}
double VCS_SOLVE::vcs_birthGuess(const int kspec)
{
size_t irxn = kspec - m_numComponents;
double dx = 0.0;
if (m_speciesUnknownType[kspec] == VCS_SPECIES_TYPE_INTERFACIALVOLTAGE) {
return dx;
}
double w_kspec = VCS_DELETE_MINORSPECIES_CUTOFF;
// Check to make sure that species is zero in the solution vector
// If it isn't, we don't know what's happening
AssertThrowMsg(m_molNumSpecies_old[kspec] == 0.0,
"VCS_SOLVE::vcs_birthGuess", "we shouldn't be here");
int ss = m_SSPhase[kspec];
if (!ss) {
/*
* Logic to handle species in multiple species phases
* we cap the moles here at 1.0E-15 kmol.
*/
bool soldel_ret;
double dxm = vcs_minor_alt_calc(kspec, irxn, &soldel_ret);
dx = std::min(w_kspec + dxm, 1e-15);
} else {
/*
* Logic to handle single species phases
* There is no real way to estimate the moles. So
* we set it to a small number.
*/
dx = 1.0E-30;
}
/*
* Check to see if the current value of the components
* allow the dx just estimated.
* If we are in danger of zeroing a component,
* only go 1/3 the way to zeroing the component with
* this dx. Note, this may mean that dx= 0 coming
* back from this routine. This evaluation should
* be respected.
*/
double* sc_irxn = m_stoichCoeffRxnMatrix.ptrColumn(irxn);
for (size_t j = 0; j < m_numComponents; ++j) {
// Only loop over element constraints that involve positive def. constraints
if (m_speciesUnknownType[j] != VCS_SPECIES_TYPE_INTERFACIALVOLTAGE) {
if (m_molNumSpecies_old[j] > 0.0) {
double tmp = sc_irxn[j] * dx;
if (3.0*(-tmp) > m_molNumSpecies_old[j]) {
dx = std::min(dx, - 0.3333* m_molNumSpecies_old[j] / sc_irxn[j]);
}
}
if (m_molNumSpecies_old[j] <= 0.0 && sc_irxn[j] < 0.0) {
dx = 0.0;
}
}
}
return dx;
}
void VCS_SOLVE::vcs_setFlagsVolPhases(const bool upToDate, const int stateCalc)
{
if (!upToDate) {
for (size_t iph = 0; iph < m_numPhases; iph++) {
m_VolPhaseList[iph]->setMolesOutOfDate(stateCalc);
}
} else {
for (size_t iph = 0; iph < m_numPhases; iph++) {
m_VolPhaseList[iph]->setMolesCurrent(stateCalc);
}
}
}
void VCS_SOLVE::vcs_setFlagsVolPhase(const size_t iph, const bool upToDate,
const int stateCalc)
{
if (!upToDate) {
m_VolPhaseList[iph]->setMolesOutOfDate(stateCalc);
} else {
m_VolPhaseList[iph]->setMolesCurrent(stateCalc);
}
}
void VCS_SOLVE::vcs_updateMolNumVolPhases(const int stateCalc)
{
for (size_t iph = 0; iph < m_numPhases; iph++) {
m_VolPhaseList[iph]->updateFromVCS_MoleNumbers(stateCalc);
}
}
}
Reference in a new issue View git blame Copy permalink