自学教程：C++ CanteraError函数代码示例

doublereal MolarityIonicVPSSTP::err(const std::string& msg) const{    throw CanteraError("MolarityIonicVPSSTP","Base class method "                       +msg+" called. Equation of state type: "+int2str(eosType()));    return 0;}

PDSS*VPSSMgr_General::returnPDSS_ptr(size_t k, const XML_Node& speciesNode,                                const XML_Node* const phaseNode_ptr, bool& doST){    PDSS* kPDSS = 0;    doST = true;    GeneralSpeciesThermo* genSpthermo = dynamic_cast<GeneralSpeciesThermo*>(m_spthermo);    const XML_Node* const ss = speciesNode.findByName("standardState");    if (!ss) {        VPSSMgr::installSTSpecies(k, speciesNode, phaseNode_ptr);        kPDSS = new PDSS_IdealGas(m_vptp_ptr, k, speciesNode, *phaseNode_ptr, true);        return kPDSS;    }    std::string model = (*ss)["model"];    if (model == "constant_incompressible") {        VPSSMgr::installSTSpecies(k, speciesNode, phaseNode_ptr);        kPDSS = new PDSS_ConstVol(m_vptp_ptr, k, speciesNode, *phaseNode_ptr, true);        if (!kPDSS) {            throw CanteraError("VPSSMgr_General::returnPDSS_ptr", "new PDSS_ConstVol failed");        }    } else if (model == "waterIAPWS" || model == "waterPDSS") {        // VPSSMgr::installSTSpecies(k, speciesNode, phaseNode_ptr);        kPDSS = new PDSS_Water(m_vptp_ptr, 0);        if (!genSpthermo) {            throw CanteraError("VPSSMgr_General::returnPDSS_ptr",                               "failed dynamic cast");        }        genSpthermo->installPDSShandler(k, kPDSS, this);        m_useTmpRefStateStorage = false;    } else if (model == "HKFT") {        doST = false;        kPDSS = new PDSS_HKFT(m_vptp_ptr, k, speciesNode, *phaseNode_ptr, true);        if (!genSpthermo) {            throw CanteraError("VPSSMgr_General::returnPDSS_ptr",                               "failed dynamic cast");        }        genSpthermo->installPDSShandler(k, kPDSS, this);    } else if (model == "IonFromNeutral") {        if (!genSpthermo) {            throw CanteraError("VPSSMgr_General::returnPDSS_ptr",                               "failed dynamic cast");        }        doST = false;        kPDSS = new PDSS_IonsFromNeutral(m_vptp_ptr, k, speciesNode, *phaseNode_ptr, true);        if (!kPDSS) {            throw CanteraError("VPSSMgr_General::returnPDSS_ptr",                               "new PDSS_IonsFromNeutral failed");        }        genSpthermo->installPDSShandler(k, kPDSS, this);    } else if (model == "constant" || model == "temperature_polynomial" || model == "density_temperature_polynomial") {        VPSSMgr::installSTSpecies(k, speciesNode, phaseNode_ptr);        kPDSS = new PDSS_SSVol(m_vptp_ptr, k, speciesNode, *phaseNode_ptr, true);        if (!kPDSS) {            throw CanteraError("VPSSMgr_General::returnPDSS_ptr", "new PDSS_SSVol failed");        }    } else {        throw CanteraError("VPSSMgr_General::returnPDSS_ptr",                           "unknown standard state formulation: " + model);    }    return kPDSS;}

void vcs_VolPhase::resize(const size_t phaseNum, const size_t nspecies,                          const size_t numElem, const char* const phaseName,                          const double molesInert){    AssertThrowMsg(nspecies > 0, "vcs_VolPhase::resize", "nspecies Error");    setTotalMolesInert(molesInert);    m_phi = 0.0;    m_phiVarIndex = npos;    if (phaseNum == VP_ID_) {        if (strcmp(PhaseName.c_str(), phaseName)) {            throw CanteraError("vcs_VolPhase::resize",                               "Strings are different: " + PhaseName + " " +                               phaseName + " :unknown situation");        }    } else {        VP_ID_ = phaseNum;        if (!phaseName) {            std::stringstream sstmp;            sstmp << "Phase_" << VP_ID_;            PhaseName = sstmp.str();        } else {            PhaseName = phaseName;        }    }    if (nspecies > 1) {        m_singleSpecies = false;    } else {        m_singleSpecies = true;    }    if (m_numSpecies == nspecies && numElem == m_numElemConstraints) {        return;    }    m_numSpecies = nspecies;    if (nspecies > 1) {        m_singleSpecies = false;    }    IndSpecies.resize(nspecies, npos);    if (ListSpeciesPtr.size() >= m_numSpecies) {        for (size_t i = 0; i < m_numSpecies; i++) {            if (ListSpeciesPtr[i]) {                delete ListSpeciesPtr[i];                ListSpeciesPtr[i] = 0;            }        }    }    ListSpeciesPtr.resize(nspecies, 0);    for (size_t i = 0; i < nspecies; i++) {        ListSpeciesPtr[i] = new vcs_SpeciesProperties(phaseNum, i, this);    }    Xmol_.resize(nspecies, 0.0);    creationMoleNumbers_.resize(nspecies, 0.0);    creationGlobalRxnNumbers_.resize(nspecies, npos);    for (size_t i = 0; i < nspecies; i++) {        Xmol_[i] = 1.0/nspecies;        creationMoleNumbers_[i] = 1.0/nspecies;        if (IndSpecies[i] >= m_numElemConstraints) {            creationGlobalRxnNumbers_[i] = IndSpecies[i] - m_numElemConstraints;        } else {            creationGlobalRxnNumbers_[i] = npos;        }    }    SS0ChemicalPotential.resize(nspecies, -1.0);    StarChemicalPotential.resize(nspecies, -1.0);    StarMolarVol.resize(nspecies, -1.0);    PartialMolarVol.resize(nspecies, -1.0);    ActCoeff.resize(nspecies, 1.0);    np_dLnActCoeffdMolNumber.resize(nspecies, nspecies, 0.0);    m_speciesUnknownType.resize(nspecies, VCS_SPECIES_TYPE_MOLNUM);    m_UpToDate            = false;    m_vcsStateStatus      = VCS_STATECALC_OLD;    m_UpToDate_AC         = false;    m_UpToDate_VolStar    = false;    m_UpToDate_VolPM      = false;    m_UpToDate_GStar      = false;    m_UpToDate_G0         = false;    elemResize(numElem);}

void importPhase(XML_Node& phase, ThermoPhase* th){    // Check the the supplied XML node in fact represents a phase.    if (phase.name() != "phase") {        throw CanteraError("importPhase",                           "Current const XML_Node named, " + phase.name() +                           ", is not a phase element.");    }    // In this section of code, we get the reference to the phase XML tree    // within the ThermoPhase object. Then, we clear it and fill it with the    // current information that we are about to use to construct the object. We    // will then be able to resurrect the information later by calling xml().    th->setXMLdata(phase);    // set the id attribute of the phase to the 'id' attribute in the XML tree.    th->setID(phase.id());    th->setName(phase.id());    // Number of spatial dimensions. Defaults to 3 (bulk phase)    if (phase.hasAttrib("dim")) {        int idim = intValue(phase["dim"]);        if (idim < 1 || idim > 3) {            throw CanteraError("importPhase",                               "phase, " + th->id() +                               ", has unphysical number of dimensions: " + phase["dim"]);        }        th->setNDim(idim);    } else {        th->setNDim(3); // default    }    // Set equation of state parameters. The parameters are specific to each    // subclass of ThermoPhase, so this is done by method setParametersFromXML    // in each subclass.    const XML_Node& eos = phase.child("thermo");    if (phase.hasChild("thermo")) {        th->setParametersFromXML(eos);    } else {        throw CanteraError("importPhase",                           " phase, " + th->id() +                           ", XML_Node does not have a /"thermo/" XML_Node");    }    VPStandardStateTP* vpss_ptr = 0;    int ssConvention = th->standardStateConvention();    if (ssConvention == cSS_CONVENTION_VPSS) {        vpss_ptr = dynamic_cast <VPStandardStateTP*>(th);        if (vpss_ptr == 0) {            throw CanteraError("importPhase",                               "phase, " + th->id() + ", was VPSS, but dynamic cast failed");        }    }    // Add the elements.    if (ssConvention != cSS_CONVENTION_SLAVE) {        installElements(*th, phase);    }    // Add the species.    //    // Species definitions may be imported from multiple sources. For each one,    // a speciesArray element must be present.    vector<XML_Node*> sparrays = phase.getChildren("speciesArray");    if (ssConvention != cSS_CONVENTION_SLAVE && sparrays.empty()) {        throw CanteraError("importPhase",                           "phase, " + th->id() + ", has zero /"speciesArray/" XML nodes./n"                           + " There must be at least one speciesArray nodes "                           "with one or more species");    }    vector<XML_Node*> dbases;    vector_int sprule(sparrays.size(),0);    // Default behavior when importing from CTI/XML is for undefined elements to    // be treated as an error    th->throwUndefinedElements();    // loop over the speciesArray elements    for (size_t jsp = 0; jsp < sparrays.size(); jsp++) {        const XML_Node& speciesArray = *sparrays[jsp];        // If the speciesArray element has a child element        //        //   <skip element="undeclared">        //        // then set sprule[jsp] to 1, so that any species with an undeclared        // element will be quietly skipped when importing species. Additionally,        // if the skip node has the following attribute:        //        // <skip species="duplicate">        //        // then duplicate species names will not cause Cantera to throw an        // exception. Instead, the duplicate entry will be discarded.        if (speciesArray.hasChild("skip")) {            const XML_Node& sk = speciesArray.child("skip");            string eskip = sk["element"];            if (eskip == "undeclared") {                sprule[jsp] = 1;            }            string dskip = sk["species"];//.........这里部分代码省略.........

doublereal Domain1D::initialValue(size_t n, size_t j){    throw CanteraError("Domain1D::initialValue",                       "base class method called!");    return 0.0;}

/* * initThermoXML()                (virtual from ThermoPhase) *   Import and initialize a ThermoPhase object * * @param phaseNode This object must be the phase node of a *             complete XML tree *             description of the phase, including all of the *             species data. In other words while "phase" must *             point to an XML phase object, it must have *             sibling nodes "speciesData" that describe *             the species in the phase. * @param id   ID of the phase. If nonnull, a check is done *             to see if phaseNode is pointing to the phase *             with the correct id. */void MixedSolventElectrolyte::initThermoXML(XML_Node& phaseNode, const std::string& id){    string subname = "MixedSolventElectrolyte::initThermoXML";    string stemp;    if ((int) id.size() > 0) {        string idp = phaseNode.id();        if (idp != id) {            throw CanteraError(subname, "phasenode and Id are incompatible");        }    }    /*     * Check on the thermo field. Must have:     * <thermo model="MixedSolventElectrolyte" />     */    if (!phaseNode.hasChild("thermo")) {        throw CanteraError(subname, "no thermo XML node");    }    XML_Node& thermoNode = phaseNode.child("thermo");    string mStringa = thermoNode.attrib("model");    string mString = lowercase(mStringa);    if (mString != "MixedSolventElectrolyte") {        throw CanteraError(subname, "Unknown thermo model: " + mStringa);    }    /*     * Go get all of the coefficients and factors in the     * activityCoefficients XML block     */    XML_Node* acNodePtr = 0;    if (thermoNode.hasChild("activityCoefficients")) {        XML_Node& acNode = thermoNode.child("activityCoefficients");        acNodePtr = &acNode;        string mStringa = acNode.attrib("model");        string mString = lowercase(mStringa);        if (mString != "margules") {            throw CanteraError(subname.c_str(),                               "Unknown activity coefficient model: " + mStringa);        }        size_t n = acNodePtr->nChildren();        for (size_t i = 0; i < n; i++) {            XML_Node& xmlACChild = acNodePtr->child(i);            stemp = xmlACChild.name();            string nodeName = lowercase(stemp);            /*             * Process a binary salt field, or any of the other XML fields             * that make up the Pitzer Database. Entries will be ignored             * if any of the species in the entry isn't in the solution.             */            if (nodeName == "binaryneutralspeciesparameters") {                readXMLBinarySpecies(xmlACChild);            }        }    }    /*     * Go down the chain     */    MolarityIonicVPSSTP::initThermoXML(phaseNode, id);}

void MargulesVPSSTP::readXMLBinarySpecies(XML_Node& xmLBinarySpecies){    string xname = xmLBinarySpecies.name();    if (xname != "binaryNeutralSpeciesParameters") {        throw CanteraError("MargulesVPSSTP::readXMLBinarySpecies",                           "Incorrect name for processing this routine: " + xname);    }    string aName = xmLBinarySpecies.attrib("speciesA");    if (aName == "") {        throw CanteraError("MargulesVPSSTP::readXMLBinarySpecies", "no speciesA attrib");    }    string bName = xmLBinarySpecies.attrib("speciesB");    if (bName == "") {        throw CanteraError("MargulesVPSSTP::readXMLBinarySpecies", "no speciesB attrib");    }    vector_fp vParams;    double h0 = 0.0;    double h1 = 0.0;    double s0 = 0.0;    double s1 = 0.0;    double vh0 = 0.0;    double vh1 = 0.0;    double vs0 = 0.0;    double vs1 = 0.0;    for (size_t iChild = 0; iChild < xmLBinarySpecies.nChildren(); iChild++) {        XML_Node& xmlChild = xmLBinarySpecies.child(iChild);        string nodeName = toLowerCopy(xmlChild.name());        // Process the binary species interaction parameters.        // They are in subblocks labeled:        //           excessEnthalpy        //           excessEntropy        //           excessVolume_Enthalpy        //           excessVolume_Entropy        // Other blocks are currently ignored.        // @TODO determine a policy about ignoring blocks that should or shouldn't be there.        if (nodeName == "excessenthalpy") {            // Get the string containing all of the values            getFloatArray(xmlChild, vParams, true, "toSI", "excessEnthalpy");            if (vParams.size() != 2) {                throw CanteraError("MargulesVPSSTP::readXMLBinarySpecies"                    "excessEnthalpy for {} : {}: wrong number of params found."                    " Need 2", aName, bName);            }            h0 = vParams[0];            h1 = vParams[1];        } else if (nodeName == "excessentropy") {            // Get the string containing all of the values            getFloatArray(xmlChild, vParams, true, "toSI", "excessEntropy");            if (vParams.size() != 2) {                throw CanteraError("MargulesVPSSTP::readXMLBinarySpecies"                    "excessEntropy for {} : {}: wrong number of params found."                    " Need 2", aName, bName);            }            s0 = vParams[0];            s1 = vParams[1];        } else if (nodeName == "excessvolume_enthalpy") {            // Get the string containing all of the values            getFloatArray(xmlChild, vParams, true, "toSI", "excessVolume_Enthalpy");            if (vParams.size() != 2) {                throw CanteraError("MargulesVPSSTP::readXMLBinarySpecies"                    "excessVolume_Enthalpy for {} : {}: wrong number of params"                    "  found. Need 2", aName, bName);            }            vh0 = vParams[0];            vh1 = vParams[1];        } else if (nodeName == "excessvolume_entropy") {            // Get the string containing all of the values            getFloatArray(xmlChild, vParams, true, "toSI", "excessVolume_Entropy");            if (vParams.size() != 2) {                throw CanteraError("MargulesVPSSTP::readXMLBinarySpecies"                    "excessVolume_Entropy for {} : {}: wrong number of params"                    " found. Need 2", aName, bName);            }            vs0 = vParams[0];            vs1 = vParams[1];        }    }    addBinaryInteraction(aName, bName, h0, h1, s0, s1, vh0, vh1, vs0, vs1);}

size_t Phase::addElement(const std::string& symbol, doublereal weight,                         int atomic_number, doublereal entropy298,                         int elem_type){    // Look up the atomic weight if not given    if (weight == 0.0) {        try {            weight = getElementWeight(symbol);        } catch (CanteraError&) {            // assume this is just a custom element with zero atomic weight        }    } else if (weight == -12345.0) {        weight = getElementWeight(symbol);    }    // Try to look up the standard entropy if not given. Fail silently.    if (entropy298 == ENTROPY298_UNKNOWN) {        try {            XML_Node* db = get_XML_File("elements.xml");            XML_Node* elnode = db->findByAttr("name", symbol);            if (elnode && elnode->hasChild("entropy298")) {                entropy298 = fpValueCheck(elnode->child("entropy298")["value"]);            }        } catch (CanteraError&) {        }    }    // Check for duplicates    auto iter = find(m_elementNames.begin(), m_elementNames.end(), symbol);    if (iter != m_elementNames.end()) {        size_t m = iter - m_elementNames.begin();        if (m_atomicWeights[m] != weight) {            throw CanteraError("Phase::addElement",                "Duplicate elements ({}) have different weights", symbol);        } else {            // Ignore attempt to add duplicate element with the same weight            return m;        }    }    // Add the new element    m_atomicWeights.push_back(weight);    m_elementNames.push_back(symbol);    m_atomicNumbers.push_back(atomic_number);    m_entropy298.push_back(entropy298);    if (symbol == "E") {        m_elem_type.push_back(CT_ELEM_TYPE_ELECTRONCHARGE);    } else {        m_elem_type.push_back(elem_type);    }    m_mm++;    // Update species compositions    if (m_kk) {        vector_fp old(m_speciesComp);        m_speciesComp.resize(m_kk*m_mm, 0.0);        for (size_t k = 0; k < m_kk; k++) {            size_t m_old = m_mm - 1;            for (size_t m = 0; m < m_old; m++) {                m_speciesComp[k * m_mm + m] = old[k * (m_old) + m];            }            m_speciesComp[k * (m_mm) + (m_mm-1)] = 0.0;        }    }    return m_mm-1;}

bool Phase::addSpecies(shared_ptr<Species> spec) {    if (m_species.find(toLowerCopy(spec->name)) != m_species.end()) {        throw CanteraError("Phase::addSpecies",            "Phase '{}' already contains a species named '{}'.",            m_name, spec->name);    }    vector_fp comp(nElements());    for (const auto& elem : spec->composition) {        size_t m = elementIndex(elem.first);        if (m == npos) { // Element doesn't exist in this phase            switch (m_undefinedElementBehavior) {            case UndefElement::ignore:                return false;            case UndefElement::add:                addElement(elem.first);                comp.resize(nElements());                m = elementIndex(elem.first);                break;            case UndefElement::error:            default:                throw CanteraError("Phase::addSpecies",                    "Species '{}' contains an undefined element '{}'.",                    spec->name, elem.first);            }        }        comp[m] = elem.second;    }    m_speciesNames.push_back(spec->name);    m_species[toLowerCopy(spec->name)] = spec;    m_speciesIndices[toLowerCopy(spec->name)] = m_kk;    m_speciesCharge.push_back(spec->charge);    size_t ne = nElements();    double wt = 0.0;    const vector_fp& aw = atomicWeights();    if (spec->charge != 0.0) {        size_t eindex = elementIndex("E");        if (eindex != npos) {            doublereal ecomp = comp[eindex];            if (fabs(spec->charge + ecomp) > 0.001) {                if (ecomp != 0.0) {                    throw CanteraError("Phase::addSpecies",                                       "Input charge and element E compositions differ "                                       "for species " + spec->name);                } else {                    // Just fix up the element E composition based on the input                    // species charge                    comp[eindex] = -spec->charge;                }            }        } else {            addElement("E", 0.000545, 0, 0.0, CT_ELEM_TYPE_ELECTRONCHARGE);            ne = nElements();            eindex = elementIndex("E");            comp.resize(ne);            comp[ne - 1] = - spec->charge;        }    }    for (size_t m = 0; m < ne; m++) {        m_speciesComp.push_back(comp[m]);        wt += comp[m] * aw[m];    }    // Some surface phases may define species representing empty sites    // that have zero molecular weight. Give them a very small molecular    // weight to avoid dividing by zero.    wt = std::max(wt, Tiny);    m_molwts.push_back(wt);    m_rmolwts.push_back(1.0/wt);    m_kk++;    // Ensure that the Phase has a valid mass fraction vector that sums to    // one. We will assume that species 0 has a mass fraction of 1.0 and mass    // fraction of all other species is 0.0.    if (m_kk == 1) {        m_y.push_back(1.0);        m_ym.push_back(m_rmolwts[0]);        m_mmw = 1.0 / m_ym[0];    } else {        m_y.push_back(0.0);        m_ym.push_back(0.0);    }    invalidateCache();    return true;}

 /*  * Calculate the constant volume heat capacity  * in mks units of J kmol-1 K-1  */ doublereal  PDSS_IonsFromNeutral::cv_mole() const {   throw CanteraError("PDSS_IonsFromNeutral::cv_mole()", "unimplemented");   return 0.0; }

/*! *  This is called if a 'Shomate' node is found in the XML input. * *  @param nodes        vector of 1 or 2 'Shomate' XML_Nodes, each defining the *      coefficients for a temperature range */static SpeciesThermoInterpType* newShomateThermoFromXML(    vector<XML_Node*>& nodes){    bool dualRange = false;    if (nodes.size() == 2) {        dualRange = true;    }    double tmin0 = fpValue(nodes[0]->attrib("Tmin"));    double tmax0 = fpValue(nodes[0]->attrib("Tmax"));    doublereal p0 = OneAtm;    if (nodes[0]->hasAttrib("P0")) {        p0 = fpValue(nodes[0]->attrib("P0"));    }    if (nodes[0]->hasAttrib("Pref")) {        p0 = fpValue(nodes[0]->attrib("Pref"));    }    p0 = OneAtm;    double tmin1 = tmax0;    double tmax1 = tmin1 + 0.0001;    if (dualRange) {        tmin1 = fpValue(nodes[1]->attrib("Tmin"));        tmax1 = fpValue(nodes[1]->attrib("Tmax"));    }    vector_fp c0, c1;    doublereal tmin, tmid, tmax;    if (fabs(tmax0 - tmin1) < 0.01) {        tmin = tmin0;        tmid = tmax0;        tmax = tmax1;        getFloatArray(nodes[0]->child("floatArray"), c0, false);        if (dualRange) {            getFloatArray(nodes[1]->child("floatArray"), c1, false);        } else {            if(c0.size() != 7)            {              throw CanteraError("installShomateThermoFromXML",                                 "Shomate thermo requires 7 coefficients in float array.");            }            c1.resize(7,0.0);            copy(c0.begin(), c0.begin()+7, c1.begin());        }    } else if (fabs(tmax1 - tmin0) < 0.01) {        tmin = tmin1;        tmid = tmax1;        tmax = tmax0;        getFloatArray(nodes[1]->child("floatArray"), c0, false);        getFloatArray(nodes[0]->child("floatArray"), c1, false);    } else {        throw CanteraError("installShomateThermoFromXML",                           "non-continuous temperature ranges.");    }    if(c0.size() != 7 || c1.size() != 7)    {      throw CanteraError("installShomateThermoFromXML",                         "Shomate thermo requires 7 coefficients in float array.");    }    vector_fp c(15);    c[0] = tmid;    copy(c0.begin(), c0.begin()+7, c.begin() + 1);    copy(c1.begin(), c1.begin()+7, c.begin() + 8);    return newSpeciesThermoInterpType(SHOMATE, tmin, tmax, p0, &c[0]);}

void VCS_SOLVE::vcs_nondim_TP(){    if (m_unitsState == VCS_DIMENSIONAL_G) {        m_unitsState = VCS_NONDIMENSIONAL_G;        double tf = 1.0 / vcs_nondimMult_TP(m_VCS_UnitsFormat, m_temperature);        for (size_t i = 0; i < m_numSpeciesTot; ++i) {            /*             *        Modify the standard state and total chemical potential data,             *        FF(I), to make it dimensionless, i.e., mu / RT.             *        Thus, we may divide it by the temperature.             */            m_SSfeSpecies[i] *= tf;            m_deltaGRxn_new[i] *= tf;            m_deltaGRxn_old[i] *= tf;            m_feSpecies_old[i] *= tf;        }        m_Faraday_dim = vcs_nondim_Farad(m_VCS_UnitsFormat, m_temperature);        /*         * Scale the total moles if necessary:         *  First find out the total moles         */        double tmole_orig = vcs_tmoles();        /*         * Then add in the total moles of elements that are goals. Either one         * or the other is specified here.         */        double esum = 0.0;        for (size_t i = 0; i < m_numElemConstraints; ++i) {            if (m_elType[i] == VCS_ELEM_TYPE_ABSPOS) {                esum += fabs(m_elemAbundancesGoal[i]);            }        }        tmole_orig += esum;        /*         * Ok now test out the bounds on the total moles that this program can         * handle. These are a bit arbitrary. However, it would seem that any         * reasonable input would be between these two numbers below.         */        if (tmole_orig < 1.0E-200 || tmole_orig > 1.0E200) {            throw CanteraError("VCS_SOLVE::vcs_nondim_TP",                               "Total input moles ," + fp2str(tmole_orig) +                               "is outside the range handled by vcs./n");        }        // Determine the scale of the problem        if (tmole_orig > 1.0E4) {            m_totalMoleScale = tmole_orig / 1.0E4;        } else if (tmole_orig < 1.0E-4) {            m_totalMoleScale = tmole_orig / 1.0E-4;        } else {            m_totalMoleScale = 1.0;        }        if (m_totalMoleScale != 1.0) {            if (m_VCS_UnitsFormat == VCS_UNITS_MKS) {                if (DEBUG_MODE_ENABLED && m_debug_print_lvl >= 2) {                    plogf("  --- vcs_nondim_TP() called: USING A MOLE SCALE OF %g until further notice", m_totalMoleScale);                    plogendl();                }                for (size_t i = 0; i < m_numSpeciesTot; ++i) {                    if (m_speciesUnknownType[i] != VCS_SPECIES_TYPE_INTERFACIALVOLTAGE) {                        m_molNumSpecies_old[i] *= (1.0 / m_totalMoleScale);                    }                }                for (size_t i = 0; i < m_numElemConstraints; ++i) {                    m_elemAbundancesGoal[i] *= (1.0 / m_totalMoleScale);                }                for (size_t iph = 0; iph < m_numPhases; iph++) {                    TPhInertMoles[iph] *= (1.0 / m_totalMoleScale);                    if (TPhInertMoles[iph] != 0.0) {                        vcs_VolPhase* vphase = m_VolPhaseList[iph];                        vphase->setTotalMolesInert(TPhInertMoles[iph]);                    }                }            }            vcs_tmoles();        }    }}

 void ConstDensityThermo::setToEquilState(const doublereal* lambda_RT) {     throw CanteraError("setToEquilState","not yet impl."); }

// critical densitydoublereal PDSS_IdealGas::critDensity() const {    throw CanteraError("PDSS_IdealGas::critDensity()", "unimplemented");    return (0.0);}

  /*   *   *  @param   file    Pointer to the file   *  @param   debug   Turn on debug printing   *   *  @ingroup inputfiles   */  void ct2ctml(const char* file, const int debug) {#ifdef HAS_NO_PYTHON    /*     *  Section to bomb out if python is not     *  present in the computation environment.     */    string ppath = file;    throw CanteraError("ct2ctml", 		       "python cti to ctml conversion requested for file, " + ppath +		       ", but not available in this computational environment");#endif    time_t aclock;    time( &aclock );    int ia = static_cast<int>(aclock);    string path =  tmpDir()+"/.cttmp"+int2str(ia)+".pyw";    ofstream f(path.c_str());    if (!f) {      throw CanteraError("ct2ctml","cannot open "+path+" for writing.");    }    f << "from ctml_writer import */n"      << "import sys, os, os.path/n"      << "file = /"" << file << "/"/n"      << "base = os.path.basename(file)/n"      << "root, ext = os.path.splitext(base)/n"      << "dataset(root)/n"      << "execfile(file)/n"      << "write()/n";    f.close();    string logfile = tmpDir()+"/ct2ctml.log";#ifdef _WIN32    string cmd = pypath() + " " + "/"" + path + "/"" + "> " + logfile + " 2>&1";#else    string cmd = "sleep " + sleep() + "; " + "/"" + pypath() + "/"" +       " " + "/"" + path + "/"" + " &> " + logfile;#endif#ifdef DEBUG_PATHS    writelog("ct2ctml: executing the command " + cmd + "/n");#endif    if (debug > 0) {      writelog("ct2ctml: executing the command " + cmd + "/n");      writelog("ct2ctml: the Python command is: " + pypath() + "/n");    }    int ierr = 0;    try {      ierr = system(cmd.c_str());    }    catch (...) {      ierr = -10;	  if (debug > 0) {	    writelog("ct2ctml: command execution failed./n");	  }    }    /*     * This next section may seem a bit weird. However, it is in     * response to an issue that arises when running cantera with     * cygwin, using cygwin's python intepreter. Basically, the     * xml file is written to the local directory by the last     * system command. Then, the xml file is read immediately     * after by an ifstream() c++ command. Unfortunately, it seems     * that the directory info is not being synched fast enough so     * that the ifstream() read fails, even though the file is     * actually there. Putting in a sleep system call here fixes     * this problem. Also, having the xml file pre-existing fixes     * the problem as well. There may be more direct ways to fix     * this bug; however, I am not aware of them.     * HKM -> During the solaris port, I found the same thing.     *        It probably has to do with NFS syncing problems.     *        3/3/06     */#ifndef _WIN32    string sss = sleep();    if (debug > 0) {      writelog("sleeping for " + sss + " secs+/n");    }    cmd = "sleep " + sss;    try {      ierr = system(cmd.c_str());    }    catch (...) {      ierr = -10;      writelog("ct2ctml: command execution failed./n");    }#else    // This command works on windows machines if Windows.h and Winbase.h are included    // Sleep(5000);#endif    // show the contents of the log file on the screen    try {//.........这里部分代码省略.........

/*! *   @param spDataNodeList   Output vector of pointer to XML_Nodes which contain *       the species XML_Nodes for the species in the current phase. *   @param spNamesList      Output Vector of strings, which contain the names *       of the species in the phase *   @param spRuleList       Output Vector of ints, which contain the value of *       sprule for each species in the phase *   @param spArray_names    Vector of pointers to the XML_Nodes which contains *                           the names of the species in the phase *   @param spArray_dbases   Input vector of pointers to species data bases. We *                           search each data base for the required species *                           names *   @param  sprule          Input vector of sprule values */static void formSpeciesXMLNodeList(std::vector<XML_Node*> &spDataNodeList,                                   std::vector<std::string> &spNamesList,                                   vector_int &spRuleList,                                   const std::vector<XML_Node*> spArray_names,                                   const std::vector<XML_Node*> spArray_dbases,                                   const vector_int sprule){    // used to check that each species is declared only once    std::map<std::string, bool> declared;    for (size_t jsp = 0; jsp < spArray_dbases.size(); jsp++) {        const XML_Node& speciesArray = *spArray_names[jsp];        // Get the top XML for the database        const XML_Node* db = spArray_dbases[jsp];        // Get the array of species name strings and then count them        std::vector<std::string> spnames;        getStringArray(speciesArray, spnames);        size_t nsp = spnames.size();        // if 'all' is specified as the one and only species in the        // spArray_names field, then add all species defined in the        // corresponding database to the phase        if (nsp == 1 && spnames[0] == "all") {            std::vector<XML_Node*> allsp = db->getChildren("species");            nsp = allsp.size();            spnames.resize(nsp);            for (size_t nn = 0; nn < nsp; nn++) {                string stemp = (*allsp[nn])["name"];                if (!declared[stemp] || sprule[jsp] < 10) {                    declared[stemp] = true;                    spNamesList.push_back(stemp);                    spDataNodeList.push_back(allsp[nn]);                    spRuleList.push_back(sprule[jsp]);                }            }        } else if (nsp == 1 && spnames[0] == "unique") {            std::vector<XML_Node*> allsp = db->getChildren("species");            nsp = allsp.size();            spnames.resize(nsp);            for (size_t nn = 0; nn < nsp; nn++) {                string stemp = (*allsp[nn])["name"];                if (!declared[stemp]) {                    declared[stemp] = true;                    spNamesList.push_back(stemp);                    spDataNodeList.push_back(allsp[nn]);                    spRuleList.push_back(sprule[jsp]);                }            }        } else {            std::map<std::string, XML_Node*> speciesNodes;            for (size_t k = 0; k < db->nChildren(); k++) {                XML_Node& child = db->child(k);                speciesNodes[child["name"]] = &child;            }            for (size_t k = 0; k < nsp; k++) {                string stemp = spnames[k];                if (!declared[stemp] || sprule[jsp] < 10) {                    declared[stemp] = true;                    // Find the species in the database by name.                    auto iter = speciesNodes.find(stemp);                    if (iter == speciesNodes.end()) {                        throw CanteraError("importPhase","no data for species, /""                                           + stemp + "/"");                    }                    spNamesList.push_back(stemp);                    spDataNodeList.push_back(iter->second);                    spRuleList.push_back(sprule[jsp]);                }            }        }    }}

void ck2cti(const std::string& in_file, const std::string& thermo_file,            const std::string& transport_file, const std::string& id_tag){    string python_output;    int python_exit_code;    try {        exec_stream_t python;        python.set_wait_timeout(exec_stream_t::s_all, 1800000); // 30 minutes        python.start(pypath(), "-i");        stringstream output_stream;        ostream& pyin = python.in();        pyin << "if True:/n" << // Use this so that the rest is a single block                "    import sys/n" <<                "    sys.stderr = sys.stdout/n" <<                "    try:/n" <<                "        from cantera import ck2cti/n" <<                "    except ImportError:/n" <<                "        print('sys.path: ' + repr(sys.path))/n" <<                "        raise/n"                "    ck2cti.Parser().convertMech(r'" << in_file << "',";        if (thermo_file != "" && thermo_file != "-") {            pyin << " thermoFile=r'" << thermo_file << "',";        }        if (transport_file != "" && transport_file != "-") {            pyin << " transportFile=r'" << transport_file << "',";        }        pyin << " phaseName='" << id_tag << "',";        pyin << " permissive=True,";        pyin << " quiet=True)/n";        pyin << "    sys.exit(0)/n/n";        pyin << "sys.exit(7)/n";        python.close_in();        std::string line;        while (python.out().good()) {            std::getline(python.out(), line);            output_stream << line << std::endl;;        }        python.close();        python_exit_code = python.exit_code();        python_output = trimCopy(output_stream.str());    } catch (std::exception& err) {        // Report failure to execute Python        stringstream message;        message << "Error executing python while converting input file:/n";        message << "Python command was: '" << pypath() << "'/n";        message << err.what() << std::endl;        throw CanteraError("ct2ctml", message.str());    }    if (python_exit_code != 0) {        // Report a failure in the conversion process        stringstream message;        message << "Error converting input file /"" << in_file << "/" to CTI./n";        message << "Python command was: '" << pypath() << "'/n";        message << "The exit code was: " << python_exit_code << "/n";        if (python_output.size() > 0) {            message << "-------------- start of converter log --------------/n";            message << python_output << std::endl;            message << "--------------- end of converter log ---------------";        } else {            message << "The command did not produce any output." << endl;        }        throw CanteraError("ck2cti", message.str());    }    if (python_output.size() > 0) {        // Warn if there was any output from the conversion process        stringstream message;        message << "Warning: Unexpected output from CTI converter/n";        message << "-------------- start of converter log --------------/n";        message << python_output << std::endl;        message << "--------------- end of converter log ---------------/n";        writelog(message.str());    }}

compositionMap parseCompString(const std::string& ss,                               const std::vector<std::string>& names){    compositionMap x;    for (size_t k = 0; k < names.size(); k++) {        x[names[k]] = 0.0;    }    size_t start = 0;    size_t stop = 0;    size_t left = 0;    while (stop < ss.size()) {        size_t colon = ss.find(':', left);        if (colon == npos) {            break;        }        size_t valstart = ss.find_first_not_of(" /t/n", colon+1);        stop = ss.find_first_of(", ;/n/t", valstart);        std::string name = ba::trim_copy(ss.substr(start, colon-start));        if (!names.empty() && x.find(name) == x.end()) {            throw CanteraError("parseCompString",                "unknown species '" + name + "'");        }        double value;        try {            value = fpValueCheck(ss.substr(valstart, stop-valstart));        } catch (CanteraError&) {            // If we have a key containing a colon, we expect this to fail. In            // this case, take the current substring as part of the key and look            // to the right of the next colon for the corresponding value.            // Otherwise, this is an invalid composition string.            std::string testname = ss.substr(start, stop-start);            if (testname.find_first_of(" /n/t") != npos) {                // Space, tab, and newline are never allowed in names                throw;            } else if (ss.substr(valstart, stop-valstart).find(':') != npos) {                left = colon + 1;                stop = 0; // Force another iteration of this loop                continue;            } else {                throw;            }        }        if (getValue(x, name, 0.0) != 0.0) {            throw CanteraError("parseCompString",                               "Duplicate key: '" + name + "'.");        }        x[name] = value;        start = ss.find_first_not_of(", ;/n/t", stop+1);        left = start;    }    if (left != start) {        throw CanteraError("parseCompString", "Unable to parse key-value pair:"            "/n'{}'", ss.substr(start, stop));    }    if (stop != npos && !ba::trim_copy(ss.substr(stop)).empty()) {        throw CanteraError("parseCompString", "Found non-key:value data "            "in composition string: '" + ss.substr(stop) + "'");    }    return x;}

static std::string call_ctml_writer(const std::string& text, bool isfile){    std::string file, arg;    if (isfile) {        file = text;        arg = "r'" + text + "'";    } else {        file = "<string>";        arg = "text=r'''" + text + "'''";    }    string python_output, error_output;    int python_exit_code;    try {        exec_stream_t python;        python.set_wait_timeout(exec_stream_t::s_all, 1800000); // 30 minutes        stringstream output_stream, error_stream;        python.start(pypath(), "");        ostream& pyin = python.in();        pyin << "from __future__ import print_function/n"                "if True:/n"                "    import sys/n"                "    try:/n"                "        from cantera import ctml_writer/n"                "    except ImportError:/n"                "        print('sys.path: ' + repr(sys.path) + '//n', file=sys.stderr)/n"                "        raise/n"                "    ctml_writer.convert(";        pyin << arg << ", outName='STDOUT')/n";        pyin << "    sys.exit(0)/n/n";        pyin << "sys.exit(7)/n";        python.close_in();        std::string line;        while (python.out().good()) {            std::getline(python.out(), line);            output_stream << line << std::endl;        }#ifdef _WIN32        // Sleeping for 1 ms prevents a (somewhat inexplicable) deadlock while        // reading from the stream.        Sleep(1);#endif        while (python.err().good()) {            std::getline(python.err(), line);            error_stream << line << std::endl;        }        python.close();        python_exit_code = python.exit_code();        error_output = trimCopy(error_stream.str());        python_output = output_stream.str();    } catch (std::exception& err) {        // Report failure to execute Python        stringstream message;        message << "Error executing python while converting input file:/n";        message << "Python command was: '" << pypath() << "'/n";        message << err.what() << std::endl;        throw CanteraError("ct2ctml_string", message.str());    }    if (python_exit_code != 0) {        // Report a failure in the conversion process        stringstream message;        message << "Error converting input file /"" << file << "/" to CTML./n";        message << "Python command was: '" << pypath() << "'/n";        message << "The exit code was: " << python_exit_code << "/n";        if (error_output.size() > 0) {            message << "-------------- start of converter log --------------/n";            message << error_output << std::endl;            message << "--------------- end of converter log ---------------";        } else {            message << "The command did not produce any output." << endl;        }        throw CanteraError("ct2ctml_string", message.str());    }    if (error_output.size() > 0) {        // Warn if there was any output from the conversion process        stringstream message;        message << "Warning: Unexpected output from CTI converter/n";        message << "-------------- start of converter log --------------/n";        message << error_output << std::endl;        message << "--------------- end of converter log ---------------/n";        writelog(message.str());    }    return python_output;}

  /*   * @param m String message   */  void Kinetics::err(std::string m) const {    throw CanteraError("Kinetics::" + m, 		       "The default Base class method was called, when "		       "the inherited class's method should "		       "have been called");  }

doublereal PDSS_IdealGas::pressure() const{    throw CanteraError("PDSS_IdealGas::pressure()", "unimplemented");}

  doublereal VPStandardStateTP::err(std::string msg) const {    throw CanteraError("VPStandardStateTP","Base class method "		       +msg+" called. Equation of state type: "+int2str(eosType()));    return 0;  }

  /*   * initThermoXML()                 (virtual from ThermoPhase)   *   *  This gets called from importPhase(). It processes the XML file   *  after the species are set up. This is the main routine for   *  reading in activity coefficient parameters.   *   * @param phaseNode This object must be the phase node of a   *             complete XML tree   *             description of the phase, including all of the   *             species data. In other words while "phase" must   *             point to an XML phase object, it must have   *             sibling nodes "speciesData" that describe   *             the species in the phase.   * @param id   ID of the phase. If nonnull, a check is done   *             to see if phaseNode is pointing to the phase   *             with the correct id.   */  void MineralEQ3::initThermoXML(XML_Node& phaseNode, std::string id) {    /*     * Find the Thermo XML node      */    if (!phaseNode.hasChild("thermo")) {      throw CanteraError("HMWSoln::initThermoXML",			 "no thermo XML node");    }       std::vector<const XML_Node *> xspecies = speciesData();    const XML_Node *xsp = xspecies[0];    XML_Node *aStandardState = 0;    if (xsp->hasChild("standardState")) {      aStandardState = &xsp->child("standardState");    } else {      throw CanteraError("MineralEQ3::initThermoXML",			 "no standard state mode");    }    doublereal volVal = 0.0;    string smodel = (*aStandardState)["model"];    if (smodel != "constantVolume") {      throw CanteraError("MineralEQ3::initThermoXML",			 "wrong standard state mode");    }    if (aStandardState->hasChild("V0_Pr_Tr")) {      XML_Node& aV = aStandardState->child("V0_Pr_Tr");      string Aunits = "";      double Afactor = toSI("cm3/gmol");      if (aV.hasAttrib("units")) {	Aunits = aV.attrib("units");	Afactor = toSI(Aunits);       }      volVal = ctml::getFloat(*aStandardState, "V0_Pr_Tr");      m_V0_pr_tr= volVal;      volVal *= Afactor;      m_speciesSize[0] = volVal;    } else {      throw CanteraError("MineralEQ3::initThermoXML",			 "wrong standard state mode");    }    doublereal rho = molecularWeight(0) / volVal;    setDensity(rho);        const XML_Node &sThermo = xsp->child("thermo");    const XML_Node &MinEQ3node = sThermo.child("MinEQ3");       m_deltaG_formation_pr_tr =      ctml::getFloatDefaultUnits(MinEQ3node, "DG0_f_Pr_Tr", "cal/gmol", "actEnergy");    m_deltaH_formation_pr_tr =      ctml::getFloatDefaultUnits(MinEQ3node, "DH0_f_Pr_Tr", "cal/gmol", "actEnergy");    m_Entrop_pr_tr = ctml::getFloatDefaultUnits(MinEQ3node, "S0_Pr_Tr", "cal/gmol/K");    m_a = ctml::getFloatDefaultUnits(MinEQ3node, "a", "cal/gmol/K");    m_b = ctml::getFloatDefaultUnits(MinEQ3node, "b", "cal/gmol/K2");    m_c = ctml::getFloatDefaultUnits(MinEQ3node, "c", "cal-K/gmol");      convertDGFormation();    }

void MolarityIonicVPSSTP::calcPseudoBinaryMoleFractions() const{    size_t k;    size_t kCat;    size_t kMax;    doublereal sumCat;    doublereal sumAnion;    doublereal chP, chM;    doublereal sum = 0.0;    doublereal sumMax;    switch (PBType_) {    case PBTYPE_PASSTHROUGH:        for (k = 0; k < m_kk; k++) {            PBMoleFractions_[k] = moleFractions_[k];        }        break;    case PBTYPE_SINGLEANION:        sumCat = 0.0;        sumAnion = 0.0;        for (k = 0; k < m_kk; k++) {            moleFractionsTmp_[k] = moleFractions_[k];        }        kMax = npos;        sumMax = 0.0;        for (k = 0; k < cationList_.size(); k++) {            kCat = cationList_[k];            chP = m_speciesCharge[kCat];            if (moleFractions_[kCat] > sumMax) {                kMax = k;                sumMax = moleFractions_[kCat];            }            sumCat += chP * moleFractions_[kCat];        }        k = anionList_[0];        chM = m_speciesCharge[k];        sumAnion = moleFractions_[k] * chM;        sum = sumCat - sumAnion;        if (fabs(sum) > 1.0E-16) {            moleFractionsTmp_[cationList_[kMax]] -= sum / m_speciesCharge[kMax];            sum = 0.0;            for (k = 0; k < numCationSpecies_; k++) {                sum +=  moleFractionsTmp_[k];            }            for (k = 0; k < numCationSpecies_; k++) {                moleFractionsTmp_[k]/= sum;            }        }        for (k = 0; k < numCationSpecies_; k++) {            PBMoleFractions_[k] = moleFractionsTmp_[cationList_[k]];        }        for (k = 0; k <  numPassThroughSpecies_; k++) {            PBMoleFractions_[neutralPBindexStart + k] = moleFractions_[passThroughList_[k]];        }        sum = std::max(0.0, PBMoleFractions_[0]);        for (k = 1; k < numPBSpecies_; k++) {            sum += PBMoleFractions_[k];        }        for (k = 0; k < numPBSpecies_; k++) {            PBMoleFractions_[k] /= sum;        }        break;    case PBTYPE_SINGLECATION:        throw CanteraError("eosType", "Unknown type");        break;    case PBTYPE_MULTICATIONANION:        throw CanteraError("eosType", "Unknown type");        break;    default:        throw CanteraError("eosType", "Unknown type");        break;    }}