research/cantera
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
cantera/Cantera/src/importCTML.cpp
Dave Goodwin 32fed991cf -
2003-05-13 19:43:30 +00:00

828 lines
25 KiB
C++
Executable file
Raw Blame History

/*
* @file importCTML.cpp
*
* $Author$
* $Revision$
* $Date$
*/
// Copyright 2002 California Institute of Technology
#ifdef WIN32
#pragma warning(disable:4786)
#pragma warning(disable:4503)
#endif
#include "importCTML.h"
#include "mix_defs.h"
#include <time.h>
// STL includes
#include <map>
#include <string>
#include <vector>
using namespace std;
// Cantera includes
#include "speciesThermoTypes.h"
#include "ThermoPhase.h"
#include "ThermoFactory.h"
#include "SpeciesThermoFactory.h"
#include "KineticsFactory.h"
#include "reaction_defs.h"
#include "ReactionData.h"
#include "global.h"
#include "stringUtils.h"
#include "xml.h"
#include "ctml.h"
using namespace ctml;
#include <stdio.h>
namespace Cantera {
typedef vector<XML_Node*> nodeset_t;
typedef XML_Node node_t;
static int intValue(string val) {
return atoi(stripws(val).c_str());
}
static doublereal fpValue(string val) {
return atof(stripws(val).c_str());
}
/// Number of reactant molecules
static int nReacMolecules(ReactionData& r) {
return accumulate(r.rstoich.begin(), r.rstoich.end(), 0);
}
const doublereal DefaultPref = 1.01325e5; // one atm
/**
* Get an XML tree from a file. If successful, a pointer to the
* document root is returned. If not, a null pointer is returned.
*/
XML_Node* get_XML(string file) {
string inname = findInputFile(file);
if (inname == "") return 0;
ifstream fin(inname.c_str());
XML_Node* rootPtr = new XML_Node;
try {
rootPtr->build(fin);
}
catch (...) {
return 0;
}
fin.close();
return rootPtr;
}
/**
* Install a NASA polynomial thermodynamic property
* parameterization for species k.
*/
void installNasaThermo(SpeciesThermo& sp, int k, XML_Node& f) {
doublereal tmin, tmid, tmax;
tmin = fpValue(f["Tmin"]);
tmid = fpValue(f["Tmid"]);
tmax = fpValue(f["Tmax"]);
vector<XML_Node*> fa;
f.getChildren("floatArray",fa);
vector_fp c0, c1;
getFloatArray(*fa[0], c0, false);
getFloatArray(*fa[1], c1, false);
array_fp c(15);
c[0] = tmid;
doublereal p0 = OneAtm;
if ((*fa[0])["title"] == "low") {
c[1] = c0[5];
c[2] = c0[6];
copy(c0.begin(), c0.begin()+5, c.begin() + 3);
c[8] = c1[5];
c[9] = c1[6];
copy(c1.begin(), c1.begin()+5, c.begin() + 10);
}
else {
c[1] = c1[5];
c[2] = c1[6];
copy(c1.begin(), c1.begin()+5, c.begin() + 3);
c[8] = c0[5];
c[9] = c0[6];
copy(c0.begin(), c0.begin()+5, c.begin() + 10);
}
sp.install(k, NASA, c.begin(), tmin, tmax, p0);
}
/**
* Install a Shomate polynomial thermodynamic property
* parameterization for species k.
*/
void installShomateThermo(SpeciesThermo& sp, int k, XML_Node& f) {
doublereal tmin, tmid, tmax;
tmin = fpValue(f["Tmin"]);
tmid = fpValue(f["Tmid"]);
tmax = fpValue(f["Tmax"]);
vector<XML_Node*> fa;
f.getChildren("floatArray",fa);
vector_fp c0, c1;
getFloatArray(*fa[0], c0, false);
getFloatArray(*fa[1], c1, false);
array_fp c(15);
c[0] = tmid;
doublereal p0 = OneAtm;
if ((*fa[0])["title"] == "low") {
copy(c0.begin(), c0.end(), c.begin() + 1);
copy(c1.begin(), c1.end(), c.begin() + 8);
}
else {
copy(c1.begin(), c1.end(), c.begin() + 1);
copy(c0.begin(), c0.end(), c.begin() + 8);
}
sp.install(k, SHOMATE, c.begin(), tmin, tmax, p0);
}
/**
* Install a Shomate polynomial thermodynamic property
* parameterization for species k.
*/
void installSimpleThermo(SpeciesThermo& sp, int k, XML_Node& f) {
doublereal tmin, tmax;
tmin = fpValue(f["Tmin"]);
tmax = fpValue(f["Tmax"]);
if (tmax == 0.0) tmax = 1.0e30;
//map<string, doublereal> fp;
//getFloats(f, fp);
vector_fp c(4);
c[0] = getFloat(f, "t0", "-");
c[1] = getFloat(f, "h0", "-");
c[2] = getFloat(f, "s0", "-");
c[3] = getFloat(f, "cp0", "-");
doublereal p0 = OneAtm;
sp.install(k, SIMPLE, c.begin(), tmin, tmax, p0);
}
bool installSpecies(int k, XML_Node& s, thermo_t& p, SpeciesThermo& spthermo, int rule) {
// get the composition of the species
XML_Node& a = s.child("atomArray");
map<string,string> comp;
getMap(a, comp);
// check that all elements in the species
// exist in 'p'
map<string,string>::const_iterator _b = comp.begin();
for (; _b != comp.end(); ++_b) {
if (p.elementIndex(_b->first) < 0) {
if (rule == 0)
throw CanteraError("installSpecies",
"species " + s["name"] +
" contains undeclared element " + _b->first);
else
return false;
}
}
int m, nel = p.nElements();
vector_fp ecomp(nel, 0.0);
for (m = 0; m < nel; m++) {
ecomp[m] = atoi(comp[p.elementName(m)].c_str());
}
/*
* Define a map and get all of the floats in the
* current XML species block
*/
map<string, double> fd;
getFloats(s, fd);
/*
* Set a default for the size parameter to one
*/
if (fd["size"] == 0.0) fd["size"] = 1.0;
p.addUniqueSpecies(s["name"], ecomp.begin(),
fd["charge"], fd["size"]);
// get thermo
XML_Node& thermo = s.child("thermo");
vector<XML_Node*> tp = thermo.children();
int nc = tp.size();
if (nc == 1) {
XML_Node& f = *tp[0];
if (f.name() == "NASA") {
installNasaThermo(spthermo, k, f);
}
else if (f.name() == "Shomate") {
installShomateThermo(spthermo, k, f);
}
else if (f.name() == "const_cp") {
installSimpleThermo(spthermo, k, f);
}
else
throw CanteraError("importCTML",
"Unsupported species thermo parameterization"
" for species "+s["name"]);
}
else
throw CanteraError("importCTML",
"Multiple thermo parameterizations given for "
"species "+s["name"]);
return true;
}
/**
* Get the reactants or products of a reaction.
*/
bool getReagents(XML_Node& rxn, kinetics_t& kin, int rp,
string default_phase,
vector_int& spnum, vector_int& stoich, vector_fp& order,
int rule) {
string rptype;
if (rp == 1) rptype = "reactants";
else rptype = "products";
XML_Node& rg = rxn.child(rptype);
vector<string> key, val;
getPairs(rg, key, val);
int ns = key.size();
int stch, isp;
doublereal ord;
string ph, sp;
for (int n = 0; n < ns; n++) {
sp = key[n];
ph = ""; //snode["phase"];
//if (ph == "") ph = default_phase;
isp = kin.kineticsSpeciesIndex(sp,"<any>");
if (isp < 0) {
if (rule == 1)
return false;
else {
throw CanteraError("getReagents",
"undeclared reactant or product species "+sp);
return false;
}
}
spnum.push_back(isp);
stch = atoi(val[n].c_str());
stoich.push_back(stch);
ord = doublereal(stch);
order.push_back(ord);
}
return true;
}
void getArrhenius(XML_Node& node, int& order, doublereal& A, doublereal& b,
doublereal& E) {
// get rxn order to do unit conversion for pre-exponential
order = intValue(node["order"]);
//nodeset_t c = node.children();
vector<string> abe;
getStringArray(node, abe);
A = fpValue(abe[0]);
b = fpValue(abe[1]);
E = fpValue(abe[2]);
string u = (*node.parent())["units"];
string eu = (*node.parent())["Eunits"];
doublereal cmult = 1.0;
if (u != "") {
if (u == "mol,cm,s")
cmult = 1.0e-6 / CtMoles_per_mole;
else if (u == "molec,cm,s")
cmult = 1.0e-6*Avogadro;
else
throw CanteraError("getArrhenius","unknown units for A");
}
A *= pow(cmult, order - 1);
doublereal gasConstant = 1.0;
if (eu != "") {
if (eu == "cal/mol")
gasConstant = 1.987;
else if (eu == "kcal/mol")
gasConstant = 1.987e-3;
else if (eu == "J/mol")
gasConstant = 8.314;
else if (eu == "kJ/mol")
gasConstant = 8.314e-3;
else if (eu == "K")
gasConstant = 1.0;
else if (eu == "eV")
gasConstant = 1.0/11600.0;
else
throw CanteraError("getArrhenius",
"unknown units for activation energy: "+eu);
}
E /= gasConstant;
}
/**
* Get falloff parameters for a reaction.
*/
void getFalloff(node_t& f, ReactionData& rdata) {
string type = f["type"];
vector<string> p;
getStringArray(f,p);
vector_fp c;
int np = p.size();
for (int n = 0; n < np; n++) {
c.push_back(fpValue(p[n]));
}
if (type == "Troe") {
if (np == 4) rdata.falloffType = TROE4_FALLOFF;
else rdata.falloffType = TROE3_FALLOFF;
}
else if (type == "SRI") {
if (np == 5) rdata.falloffType = SRI5_FALLOFF;
else rdata.falloffType = SRI3_FALLOFF;
}
rdata.falloffParameters = c;
}
/**
* Get the enhanced collision efficiencies. It is assumed that the
* reaction mechanism is homogeneous, so that all species belong
* to phase(0) of 'kin'.
*/
void getEfficiencies(node_t& eff, kinetics_t& kin, ReactionData& rdata) {
// set the default collision efficiency
rdata.default_3b_eff = fpValue(eff["default"]);
vector<string> key, val;
getPairs(eff, key, val);
int ne = key.size();
//map<string, doublereal> e;
//getFloats(eff, e, false);
//map<string, doublereal>::const_iterator bb = e.begin(), ee = e.end();
string nm;
string phse = kin.thermo(0).id();
int n, k;
for (n = 0; n < ne; n++) { // ; bb != ee; ++bb) {
nm = key[n];// bb->first;
k = kin.kineticsSpeciesIndex(nm, phse);
rdata.thirdBodyEfficiencies[k] = fpValue(val[n]); // bb->second;
}
}
/**
* Get the rate coefficient for a reaction.
*/
void getRateCoefficient(node_t& kf, kinetics_t& kin, ReactionData& rdata) {
int nc = kf.nChildren();
const nodeset_t& kf_children = kf.children();
vector_fp clow(3,0.0), chigh(3,0.0);
int nr = nReacMolecules(rdata);
for (int m = 0; m < nc; m++) {
node_t& c = *kf_children[m];
string nm = c.name();
int order=0;
if (nm == "Arrhenius") {
vector_fp coeff(3);
getArrhenius(c, order, coeff[0], coeff[1], coeff[2]);
if (order == 0) order = nr;
if (order == nr || rdata.reactionType == THREE_BODY_RXN)
chigh = coeff;
else if (order == nr + 1) clow = coeff;
else {
cerr << "\n\n\n" << endl;
kf.write(cerr);
throw CanteraError("importCTML",
"wrong Arrhenius coeff order");
}
}
else if (nm == "falloff") {
getFalloff(c, rdata);
}
else if (nm == "efficiencies") {
getEfficiencies(c, kin, rdata);
}
}
if (rdata.reactionType == CHEMACT_RXN)
rdata.rateCoeffParameters = clow;
else
rdata.rateCoeffParameters = chigh;
if (rdata.reactionType == FALLOFF_RXN)
rdata.auxRateCoeffParameters = clow;
else if (rdata.reactionType == CHEMACT_RXN)
rdata.auxRateCoeffParameters = chigh;
}
/**
* Create a new ThermoPhase object.
*/
ThermoPhase* newPhase(XML_Node& xmlphase) {
XML_Node& th = xmlphase.child("thermo");
string model = th["model"];
ThermoPhase* t = newThermoPhase(model);
importPhase(xmlphase, t);
return t;
}
/**
* Set the thermodynamic state.
*/
static void setState(XML_Node& phase, ThermoPhase* th) {
if (!phase.hasChild("state")) return;
XML_Node state = phase.child("state");
doublereal t, p, rho;
string comp = getString(state,"moleFractions");
if (comp != "")
th->setMoleFractionsByName(comp);
else {
comp = getString(state,"massFractions");
if (comp != "")
th->setMassFractionsByName(comp);
}
t = getFloat(state, "temperature", "temperature");
if (t > 0.0) th->setTemperature(t);
p = getFloat(state, "pressure", "pressure");
if (p > 0.0) th->setPressure(p);
rho = getFloat(state, "density", "density");
if (rho > 0.0) th->setDensity(rho);
}
/**
* Import a phase specification.
*/
bool importPhase(XML_Node& phase, ThermoPhase* th) {
if (phase.name() != "phase")
throw CanteraError("importPhase",
"Current XML_Node is not a phase element.");
th->setID(phase.id()); // set the 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",
"unphysical number of dimensions: "+phase["dim"]);
th->setNDim(idim);
}
else
th->setNDim(3); // default
// equation of state
if (phase.hasChild("thermo")) {
XML_Node& eos = phase.child("thermo");
if (eos["model"] == "Incompressible") {
if (th->eosType() == cIncompressible) {
map<string, doublereal> d;
getFloats(eos, d);
doublereal rho = d["density"];
th->setParameters(1, &rho);
}
else {
throw CanteraError("importCTML",
"wrong equation of state type");
}
}
else if (eos["model"] == "Surface") {
if (th->eosType() == cSurf) {
map<string, doublereal> d;
//getFloats(eos, d);
doublereal n = fpValue(eos("site_density"));
th->setParameters(1, &n);
}
else {
throw CanteraError("importCTML",
"wrong equation of state type");
}
}
}
/*************************************************
* Add the elements.
************************************************/
// get the declared element names
XML_Node& elements = phase.child("elementArray");
vector<string> enames;
getStringArray(elements, enames);
// // element database defaults to elements.xml
string element_database; // = "elements.xml";
if (elements.hasAttrib("datasrc"))
element_database = elements["datasrc"];
XML_Node* db = find_XML(element_database,&phase.root(),"","",
"elementData");
int nel = enames.size();
int i;
string enm;
for (i = 0; i < nel; i++) {
XML_Node* e = db->findByAttr("name",enames[i]);
if (e) {
th->addUniqueElement(*e);
}
else {
throw CanteraError("importPhase","no data for element "
+enames[i]);
}
}
delete db;
db = 0;
/***************************************************************
* Add the species. First get the speciesArray element, then
* the species database.
***************************************************************/
XML_Node& species = phase.child("speciesArray");
int sprule = 0;
if (species.hasChild("skip")) {
XML_Node& sk = species.child("skip");
string eskip = sk["element"];
if (eskip == "undeclared") {
sprule = 1;
}
}
db = find_XML(species["datasrc"], &phase.root(), species["idRef"],
"","speciesData");
/*******************************************************
* Set the species thermo manager.
* Function 'newSpeciesThermoMgr' looks at the species
* in the database to see what thermodynamic property
* parameterizations are used, and selects a class
* that can handle the parameterizations found.
******************************************************/
delete &th->speciesThermo();
SpeciesThermo* spth = newSpeciesThermoMgr(db);
th->setSpeciesThermo(spth);
SpeciesThermo& spthermo = th->speciesThermo();
/*
* Get the array of species name strings.
*/
vector<string> spnames;
getStringArray(species, spnames);
int nsp = spnames.size();
map<string,bool> declared;
string name;
int k = 0;
for (i = 0; i < nsp; i++) {
name = spnames[i];
// Check that every species is only declared once
if (declared[name]) {
throw CanteraError("importPhase",
"duplicate species: "+name);
}
declared[name] = true;
/*
* Find the species in the database by name.
*/
XML_Node* s = db->findByAttr("name",spnames[i]);
if (s) {
if (installSpecies(k, *s, *th, spthermo, sprule))
++k;
}
else {
throw CanteraError("importPhase","no data for species "
+name);
}
}
th->freezeSpecies();
th->initThermo();
setState(phase, th);
th->saveSpeciesData(db);
return true;
}
bool installReaction(int i, XML_Node& r, Kinetics* k,
string default_phase, int rule) {
Kinetics& kin = *k;
ReactionData rdata;
rdata.reactionType = ELEMENTARY_RXN;
vector_int reac, prod;
string eqn, type;
int nn, eqlen;
vector_fp dummy;
eqn = r("equation");
eqlen = eqn.size();
for (nn = 0; nn < eqlen; nn++) {
if (eqn[nn] == '[') eqn[nn] = '<';
if (eqn[nn] == ']') eqn[nn] = '>';
}
bool ok;
// get the reactants
ok = getReagents(r, kin, 1, default_phase, rdata.reactants,
rdata.rstoich, rdata.order, rule);
// get the products
ok = ok && getReagents(r, kin, -1, default_phase, rdata.products,
rdata.pstoich, dummy, rule);
if (!ok) {
cout << "skipping " << eqn << endl;
return false;
}
rdata.equation = eqn;
rdata.reversible = false;
rdata.number = i;
rdata.rxn_number = i;
string typ = r["type"];
if (typ == "falloff") {
rdata.reactionType = FALLOFF_RXN;
rdata.falloffType = SIMPLE_FALLOFF;
}
else if (typ == "chemAct") {
rdata.reactionType = CHEMACT_RXN;
rdata.falloffType = SIMPLE_FALLOFF;
}
else if (typ == "threeBody") {
rdata.reactionType = THREE_BODY_RXN;
}
else if (typ != "")
throw CanteraError("installReaction",
"Unknown reaction type: " + typ);
string isrev = r["reversible"];
if (isrev == "yes" || isrev == "true")
rdata.reversible = true;
getRateCoefficient(r.child("rateCoeff"), kin, rdata);
kin.addReaction(rdata);
return true;
}
bool installReactionArrays(XML_Node& p, Kinetics& kin,
string default_phase) {
vector<XML_Node*> rarrays;
int itot = 0;
p.getChildren("reactionArray",rarrays);
int na = rarrays.size();
if (na == 0) return false;
for (int n = 0; n < na; n++) {
XML_Node& rxns = *rarrays[n];
XML_Node* rdata = find_XML(rxns["datasrc"],&rxns.root(),
"","","reactionData");
int rxnrule = 0;
if (rxns.hasChild("skip")) {
XML_Node& sk = rxns.child("skip");
string sskip = sk["species"];
if (sskip == "undeclared") {
rxnrule = 1;
}
}
vector<XML_Node*> incl;
rxns.getChildren("include",incl);
int ninc = incl.size();
for (int nii = 0; nii < ninc; nii++) {
int nrxns = 0;
XML_Node& ii = *incl[nii];
vector<string> rxn_ids;
string pref = ii["prefix"];
int imin = atoi(ii["min"].c_str());
int imax = atoi(ii["max"].c_str());
if (imin != 0 && imax != 0) {
nrxns = imax - imin + 1;
for (int nn=0; nn<nrxns; nn++) {
rxn_ids.push_back(pref+int2str(imin+nn));
}
}
int i;
for (i = 0; i < nrxns; i++) {
XML_Node* r = rdata->findID(rxn_ids[i],1);
if (r) {
if (installReaction(itot, *r, &kin,
default_phase, rxnrule)) ++itot;
}
}
}
}
kin.finalize();
return true;
}
/**
* Import a reaction mechanism for a phase or an interface.
*/
bool importKinetics(XML_Node& phase, vector<ThermoPhase*> th,
Kinetics* k) {
Kinetics& kin = *k;
// This phase will be the default one
string default_phase = phase["id"];
// if other phases are involved in the reaction mechanism,
// they must be listed in a 'phaseArray' child
// element. Homogeneous mechanisms do not need to include a
// phaseArray element.
vector<string> phase_ids;
if (phase.hasChild("phaseArray")) {
XML_Node& pa = phase.child("phaseArray");
getStringArray(pa, phase_ids);
}
phase_ids.push_back(default_phase);
int np = phase_ids.size();
int nt = th.size();
// for each referenced phase, attempt to find its id among those
// phases specified.
bool phase_ok;
string phase_id;
for (int n = 0; n < np; n++) {
phase_id = phase_ids[n];
phase_ok = false;
// loop over the supplied 'ThermoPhase' objects representing
// phases, to find an object with the same id.
for (int m = 0; m < nt; m++) {
if (th[m]->id() == phase_id) {
phase_ok = true;
// if no phase with this id has been added to
//the kinetics manager yet, then add this one
if (kin.phaseIndex(phase_id) < 0) {
kin.addPhase(*th[m]);
}
}
}
if (!phase_ok) {
throw CanteraError("importKinetics",
"phase "+phase_id+" not found.");
}
}
// allocates arrays, etc. Must be called after the phases have
// been added to 'kin', so that the number of species in each
// phase is known.
kin.init();
// Install the reactions.
return installReactionArrays(phase, kin, default_phase);
}
/**
* Build a single-phase solution.
*/
bool buildSolutionFromXML(XML_Node& root, string id, string nm,
ThermoPhase* th, Kinetics* k) {
XML_Node* x;
x = find_XML("", &root, id, "", nm);
if (!x) return false;
importPhase(*x, th);
vector<ThermoPhase*> phases(1);
phases[0] = th;
importKinetics(*x, phases, k);
return true;
}
}
Reference in a new issue View git blame Copy permalink