static void remove_node_right(SgBTreeNode **root, SgBTreeNode *n) { SgBTreeNode *l = n->left, *r = n->right, *p = n->parent; SgBTreeNode *rx = NULL; sg_free(n); r->parent = p; if (p != LAST) { if (p->left == n) p->left = r; else p->right = r; } if (l != LAST) { l->parent = r; if (r->left != LAST) { for (rx = l; rx->right != LAST; rx = rx->right) {} rx->right = r->left; r->left->parent = rx; } r->left = l; } if (rx) equilibrate(rx, &l); equilibrate(r, &r); if (p == LAST) *root = r; else equilibrate(p, root); }
static void remove_node_left(SgBTreeNode **root, SgBTreeNode *n) { SgBTreeNode *l = n->left, *r = n->right, *p = n->parent; SgBTreeNode *lx = NULL; sg_free(n); l->parent = p; if (p != LAST) { if (p->left == n) p->left = l; else p->right = l; } if (r != LAST) { r->parent = l; if (l->right != LAST) { for (lx = r; lx->left != LAST; lx = lx->left) {} lx->left = l->right; l->right->parent = lx; } l->right = r; } if (lx) equilibrate(lx, &r); equilibrate(l, &l); if (p == LAST) *root = l; else equilibrate(p, root); }
SgInt sg_btree_insert(SgBTree *h, void *key, void *data) { SgBTreeNode *p = LAST, *c = h->root, *n; SgCmpFun const cmpf = h->cmpf; SgInt r; for (; c != LAST;) { p = c; r = cmpf(key, c->key); if (r < 0) c = c->left; else if (r > 0) c = c->right; else return -1; } n = sg_alloc(sizeof(SgBTreeNode) + sizeof(void*)); n->left = LAST; n->right = LAST; n->parent = p; n->mlevel = 1; n->key = key; n->data[0] = data; if (p == LAST) h->root = n; else { if (r < 0) p->left = n; else p->right = n; equilibrate(p, &h->root); } return 0; }
SgInt sg_btree_insert_node(SgBTree *h, SgBTreeNode *n) { SgBTreeNode *p = LAST, *c = h->root; SgCmpFun const cmpf = h->cmpf; SgInt r; if (n == LAST) return 0; for (; c != LAST;) { p = c; r = cmpf(n->key, c->key); if (r < 0) c = c->left; else if (r > 0) c = c->right; else return -1; } n->parent = p; if (p == LAST) h->root = n; else { if (r < 0) p->left = n; else p->right = n; equilibrate(p, &h->root); } return 0; }
static void equilibrate(SgBTreeNode *n, SgBTreeNode **root) { SgBTreeNode *p, *f; SgSize lml, rml; SgSize r; for (;; n = p) { p = n->parent; f = NULL; lml = n->left->mlevel; rml = n->right->mlevel; if (lml < rml) { n->mlevel = rml + 1; if ((r = rml - lml) == 1) { if (rml > 1 && p->left == n) f = rotate_left(n); } else { f = rotate_left(n); if (r > 2) equilibrate(n, &f); } } else if (lml > rml) { n->mlevel = lml + 1; if ((r = lml - rml) == 1) { if (lml > 1 && p->right == n) f = rotate_right(n); } else { f = rotate_right(n); if (r > 2) equilibrate(n, &f); } } else n->mlevel = (lml > rml ? lml : rml) + 1; if (n == *root) { if (f) *root = f; break; } } }
static void remove_leaf(SgBTreeNode **root, SgBTreeNode *n) { SgBTreeNode *p = n->parent; sg_free(n); if (p == LAST) { *root = LAST; return; } if (p->left == n) p->left = LAST; else p->right = LAST; equilibrate(p, root); }
void sg_btree_detach_subtree(SgBTree *h, SgBTreeNode *n) { SgBTreeNode *p = n->parent; if (n == LAST) return; if (p == LAST) { h->root = LAST; return; } n->parent = LAST; if (p->left == n) p->left = LAST; else p->right = LAST; equilibrate(p, &h->root); }
/* * Set a single-phase chemical solution to chemical equilibrium. * This is a convenience function that uses one or the other of * the two chemical equilibrium solvers. * * @param s The object to set to an equilibrium state * * @param XY An integer specifying the two properties to be held * constant. * * @param estimateEquil integer indicating whether the solver * should estimate its own initial condition. * If 0, the initial mole fraction vector * in the %ThermoPhase object is used as the * initial condition. * If 1, the initial mole fraction vector * is used if the element abundances are * satisfied. * if -1, the initial mole fraction vector * is thrown out, and an estimate is * formulated. * * @param printLvl Determines the amount of printing that * gets sent to stdout from the vcs package * (Note, you may have to compile with debug * flags to get some printing). * * @param solver The equilibrium solver to use. If solver = 0, * the ChemEquil solver will be used, and if * solver = 1, the vcs_MultiPhaseEquil solver will * be used (slower than ChemEquil, * but more stable). If solver < 0 (default, then * ChemEquil will be tried first, and if it fails * vcs_MultiPhaseEquil will be tried. * * @param maxsteps The maximum number of steps to take to find * the solution. * * @param maxiter For the MultiPhaseEquil solver only, this is * the maximum number of outer temperature or * pressure iterations to take when T and/or P is * not held fixed. * * @param loglevel Controls amount of diagnostic output. loglevel * = 0 suppresses diagnostics, and increasingly-verbose * messages are written as loglevel increases. The * messages are written to a file in HTML format for viewing * in a web browser. @see HTML_logs */ int vcs_equilibrate(thermo_t& s, const char* XY, int estimateEquil, int printLvl, int solver, doublereal rtol, int maxsteps, int maxiter, int loglevel) { MultiPhase* m = 0; int retn = 1; int retnSub = 0; beginLogGroup("equilibrate", loglevel); // retry: addLogEntry("Single-phase equilibrate function"); { beginLogGroup("arguments"); addLogEntry("phase",s.id()); addLogEntry("XY",XY); addLogEntry("solver",solver); addLogEntry("rtol",rtol); addLogEntry("maxsteps",maxsteps); addLogEntry("maxiter",maxiter); addLogEntry("loglevel",loglevel); endLogGroup("arguments"); } if (solver == 2) { m = new MultiPhase; try { /* * Set the kmoles of the phase to 1.0, arbitrarily. * It actually doesn't matter. */ m->addPhase(&s, 1.0); m->init(); retn = vcs_equilibrate(*m, XY, estimateEquil, printLvl, solver, rtol, maxsteps, maxiter, loglevel); if (retn == 1) { addLogEntry("MultiPhaseEquil solver succeeded."); } else { addLogEntry("MultiPhaseEquil solver returned an error code: ", retn); } delete m; } catch (CanteraError& err) { err.save(); addLogEntry("MultiPhaseEquil solver failed."); delete m; throw err; } } else if (solver == 1) { m = new MultiPhase; try { m->addPhase(&s, 1.0); m->init(); (void) equilibrate(*m, XY, rtol, maxsteps, maxiter, loglevel-1); if (loglevel > 0) { addLogEntry("MultiPhaseEquil solver succeeded."); } delete m; retn = 1; } catch (CanteraError& err) { err.save(); if (loglevel > 0) { addLogEntry("MultiPhaseEquil solver failed."); } delete m; throw err; } } else if (solver == 0) { ChemEquil* e = new ChemEquil; try { e->options.maxIterations = maxsteps; e->options.relTolerance = rtol; bool useThermoPhaseElementPotentials = false; if (estimateEquil == 0) { useThermoPhaseElementPotentials = true; } retnSub = e->equilibrate(s, XY, useThermoPhaseElementPotentials, loglevel-1); if (retnSub < 0) { if (loglevel > 0) { addLogEntry("ChemEquil solver failed."); } delete e; throw CanteraError("equilibrate", "ChemEquil equilibrium solver failed"); } retn = 1; s.setElementPotentials(e->elementPotentials()); delete e; if (loglevel > 0) { addLogEntry("ChemEquil solver succeeded."); } } catch (CanteraError& err) { err.save(); if (loglevel > 0) { addLogEntry("ChemEquil solver failed."); } delete e; throw err; } } else { throw CanteraError("vcs_equilibrate", "unknown solver"); } /* * We are here only for a success */ endLogGroup("equilibrate"); return retn; }
int vcs_equilibrate(thermo_t& s, const char* XY, int estimateEquil, int printLvl, int solver, doublereal rtol, int maxsteps, int maxiter, int loglevel) { warn_deprecated("vcs_equilibrate", "Use ThermoPhase::equilibrate instead. " "To be removed after Cantera 2.2."); MultiPhase* m = 0; int retn = 1; if (solver == 2) { m = new MultiPhase; try { /* * Set the kmoles of the phase to 1.0, arbitrarily. * It actually doesn't matter. */ m->addPhase(&s, 1.0); m->init(); retn = vcs_equilibrate(*m, XY, estimateEquil, printLvl, solver, rtol, maxsteps, maxiter, loglevel); delete m; } catch (CanteraError& err) { err.save(); delete m; throw err; } } else if (solver == 1) { m = new MultiPhase; try { m->addPhase(&s, 1.0); m->init(); (void) equilibrate(*m, XY, rtol, maxsteps, maxiter, loglevel-1); delete m; retn = 1; } catch (CanteraError& err) { err.save(); delete m; throw err; } } else if (solver == 0) { ChemEquil* e = new ChemEquil; try { e->options.maxIterations = maxsteps; e->options.relTolerance = rtol; bool useThermoPhaseElementPotentials = false; if (estimateEquil == 0) { useThermoPhaseElementPotentials = true; } int retnSub = e->equilibrate(s, XY, useThermoPhaseElementPotentials, loglevel-1); if (retnSub < 0) { delete e; throw CanteraError("equilibrate", "ChemEquil equilibrium solver failed"); } retn = 1; s.setElementPotentials(e->elementPotentials()); delete e; } catch (CanteraError& err) { err.save(); delete e; throw err; } } else { throw CanteraError("vcs_equilibrate", "unknown solver"); } /* * We are here only for a success */ return retn; }
/* * Set a single-phase chemical solution to chemical equilibrium. * This is a convenience function that uses one or the other of * the two chemical equilibrium solvers. * * @param s The object to set to an equilibrium state * * @param XY An integer specifying the two properties to be held * constant. * * @param solver The equilibrium solver to use. If solver = 0, * the ChemEquil solver will be used, and if solver = 1, the * MultiPhaseEquil solver will be used (slower than ChemEquil, * but more stable). If solver < 0 (default, then ChemEquil will * be tried first, and if it fails MultiPhaseEquil will be tried. * * @param maxsteps The maximum number of steps to take to find * the solution. * * @param maxiter For the MultiPhaseEquil solver only, this is * the maximum number of outer temperature or pressure iterations * to take when T and/or P is not held fixed. * * @param loglevel Controls amount of diagnostic output. loglevel * = 0 suppresses diagnostics, and increasingly-verbose messages * are written as loglevel increases. The messages are written to * a file in HTML format for viewing in a web browser. * @see HTML_logs * * @ingroup equil */ int equilibrate(thermo_t& s, const char* XY, int solver, doublereal rtol, int maxsteps, int maxiter, int loglevel) { MultiPhase* m = 0; ChemEquil* e = 0; bool redo = true; int retn = -1; int nAttempts = 0; int retnSub = 0; if (loglevel > 0) { beginLogGroup("equilibrate", loglevel); addLogEntry("Single-phase equilibrate function"); { beginLogGroup("arguments"); addLogEntry("phase",s.id()); addLogEntry("XY",XY); addLogEntry("solver",solver); addLogEntry("rtol",rtol); addLogEntry("maxsteps",maxsteps); addLogEntry("maxiter",maxiter); addLogEntry("loglevel",loglevel); endLogGroup("arguments"); } } while (redo) { if (solver >= 2) { #ifdef WITH_VCSNONIDEAL int printLvlSub = 0; int estimateEquil = 0; m = new MultiPhase; try { m->addPhase(&s, 1.0); m->init(); nAttempts++; vcs_equilibrate(*m, XY, estimateEquil, printLvlSub, solver, rtol, maxsteps, maxiter, loglevel-1); redo = false; if (loglevel > 0) addLogEntry("VCSnonideal solver succeeded."); delete m; retn = nAttempts; } catch (CanteraError &err) { if (loglevel > 0) addLogEntry("VCSnonideal solver failed."); delete m; if (nAttempts < 2) { if (loglevel > 0) addLogEntry("Trying single phase ChemEquil solver."); solver = -1; } else { if (loglevel > 0) endLogGroup("equilibrate"); throw err; } } #else throw CanteraError("equilibrate", "VCSNonIdeal solver called, but not compiled"); #endif } else if (solver == 1) { m = new MultiPhase; try { m->addPhase(&s, 1.0); m->init(); nAttempts++; (void) equilibrate(*m, XY, rtol, maxsteps, maxiter, loglevel-1); redo = false; if (loglevel > 0) addLogEntry("MultiPhaseEquil solver succeeded."); delete m; retn = nAttempts; } catch (CanteraError &err) { if (loglevel > 0) addLogEntry("MultiPhaseEquil solver failed."); delete m; if (nAttempts < 2) { if (loglevel > 0) addLogEntry("Trying single phase ChemEquil solver."); solver = -1; } else { if (loglevel > 0) endLogGroup("equilibrate"); throw err; } } } else { // solver <= 0 /* * Call the element potential solver */ e = new ChemEquil; try { e->options.maxIterations = maxsteps; e->options.relTolerance = rtol; nAttempts++; bool useThermoPhaseElementPotentials = true; retnSub = e->equilibrate(s,XY, useThermoPhaseElementPotentials, loglevel-1); if (retnSub < 0) { if (loglevel > 0) addLogEntry("ChemEquil solver failed."); if (nAttempts < 2) { if (loglevel > 0) addLogEntry("Trying MultiPhaseEquil solver."); solver = 1; } else { throw CanteraError("equilibrate", "Both equilibrium solvers failed"); } } retn = nAttempts; s.setElementPotentials(e->elementPotentials()); redo = false; delete e; if (loglevel > 0) addLogEntry("ChemEquil solver succeeded."); } catch (CanteraError &err) { delete e; if (loglevel > 0) addLogEntry("ChemEquil solver failed."); // If ChemEquil fails, try the MultiPhase solver if (solver < 0) { if (loglevel > 0) addLogEntry("Trying MultiPhaseEquil solver."); solver = 1; } else { redo = false; if (loglevel > 0) endLogGroup("equilibrate"); throw err; } } } } // while (redo) /* * We are here only for a success */ if (loglevel > 0) endLogGroup("equilibrate"); return retn; }
int equilibrate(thermo_t& s, const char* XY, int solver, doublereal rtol, int maxsteps, int maxiter, int loglevel) { bool redo = true; int retn = -1; int nAttempts = 0; int retnSub = 0; if (loglevel > 0) { beginLogGroup("equilibrate", loglevel); addLogEntry("Single-phase equilibrate function"); { beginLogGroup("arguments"); addLogEntry("phase",s.id()); addLogEntry("XY",XY); addLogEntry("solver",solver); addLogEntry("rtol",rtol); addLogEntry("maxsteps",maxsteps); addLogEntry("maxiter",maxiter); addLogEntry("loglevel",loglevel); endLogGroup("arguments"); } } while (redo) { if (solver >= 2) { int printLvlSub = 0; int estimateEquil = 0; try { MultiPhase m; m.addPhase(&s, 1.0); m.init(); nAttempts++; vcs_equilibrate(m, XY, estimateEquil, printLvlSub, solver, rtol, maxsteps, maxiter, loglevel-1); redo = false; if (loglevel > 0) { addLogEntry("VCSnonideal solver succeeded."); } retn = nAttempts; } catch (CanteraError& err) { err.save(); if (loglevel > 0) { addLogEntry("VCSnonideal solver failed."); } if (nAttempts < 2) { if (loglevel > 0) { addLogEntry("Trying single phase ChemEquil solver."); } solver = -1; } else { if (loglevel > 0) { endLogGroup("equilibrate"); } throw err; } } } else if (solver == 1) { try { MultiPhase m; m.addPhase(&s, 1.0); m.init(); nAttempts++; equilibrate(m, XY, rtol, maxsteps, maxiter, loglevel-1); redo = false; if (loglevel > 0) { addLogEntry("MultiPhaseEquil solver succeeded."); } retn = nAttempts; } catch (CanteraError& err) { err.save(); if (loglevel > 0) { addLogEntry("MultiPhaseEquil solver failed."); } if (nAttempts < 2) { if (loglevel > 0) { addLogEntry("Trying single phase ChemEquil solver."); } solver = -1; } else { if (loglevel > 0) { endLogGroup("equilibrate"); } throw err; } } } else { // solver <= 0 /* * Call the element potential solver */ try { ChemEquil e; e.options.maxIterations = maxsteps; e.options.relTolerance = rtol; nAttempts++; bool useThermoPhaseElementPotentials = true; retnSub = e.equilibrate(s, XY, useThermoPhaseElementPotentials, loglevel-1); if (retnSub < 0) { if (loglevel > 0) { addLogEntry("ChemEquil solver failed."); } if (nAttempts < 2) { if (loglevel > 0) { addLogEntry("Trying MultiPhaseEquil solver."); } solver = 1; } else { throw CanteraError("equilibrate", "Both equilibrium solvers failed"); } } retn = nAttempts; s.setElementPotentials(e.elementPotentials()); redo = false; if (loglevel > 0) { addLogEntry("ChemEquil solver succeeded."); } } catch (CanteraError& err) { err.save(); if (loglevel > 0) { addLogEntry("ChemEquil solver failed."); } // If ChemEquil fails, try the MultiPhase solver if (solver < 0) { if (loglevel > 0) { addLogEntry("Trying MultiPhaseEquil solver."); } solver = 1; } else { redo = false; if (loglevel > 0) { endLogGroup("equilibrate"); } throw err; } } } } // while (redo) /* * We are here only for a success */ if (loglevel > 0) { endLogGroup("equilibrate"); } return retn; }