public static TemplateReaction makeTemplateReaction( Structure p_structureSp, Kinetics[] p_kinetics, ReactionTemplate p_template, Structure p_structure) { double PT = System.currentTimeMillis(); // Look for pre-existing reaction in Template's reactionDictionaryByStructure. TemplateReaction reaction = p_template.getReactionFromStructure(p_structureSp); Global.getReacFromStruc = Global.getReacFromStruc + (System.currentTimeMillis() - PT) / 1000 / 60; if (reaction == null) { // Create a new reaction. reaction = new TemplateReaction(p_structureSp, p_kinetics, p_template); if (reaction.isBackward()) { Logger.info( "Created new reverse " + p_template.getName() + " reaction: " + reaction.toString()); TemplateReaction reverse = reaction.generateReverseForBackwardReaction(p_structure, p_structureSp); if (reverse == null) return null; reaction.setReverseReaction(reverse); } else { Logger.info( "Created new forwards " + p_template.getName() + " reaction: " + reaction.toString()); ReactionTemplate fRT = reaction.getReactionTemplate(); ReactionTemplate rRT = null; if (fRT.isNeutral()) rRT = fRT; else rRT = fRT.getReverseReactionTemplate(); if (rRT != null) { TemplateReaction reverse = new TemplateReaction(p_structureSp.generateReverseStructure(), p_kinetics, rRT); reaction.setReverseReaction(reverse); reverse.setReverseReaction(reaction); rRT.addReaction(reverse); } } if (!reaction.repOk()) { throw new InvalidTemplateReactionException(); } p_template.addReaction(reaction); } Global.makeTR += (System.currentTimeMillis() - PT) / 1000 / 60; if (!reaction.repOk()) { throw new InvalidTemplateReactionException(); } return reaction; }
// ## operation generateReverseForBackwardReaction() private TemplateReaction generateReverseForBackwardReaction(Structure fs, Structure fsSp) { // #[ operation generateReverseForBackwardReaction() // we need to only generate reverse reaction for backward reaction, so that we wont be stuck // into a self loop. if (!this.isBackward()) { return null; } ReactionTemplate fRT = getReactionTemplate(); ReactionTemplate rRT = null; if (fRT.isForward()) { return null; } else if (fRT.isNeutral()) { rRT = fRT; } else if (fRT.isBackward()) { rRT = fRT.getReverseReactionTemplate(); } else { throw new InvalidReactionTemplateDirectionException(); // Structure fs = getStructure(); } LinkedList freactant = fs.getReactantList(); LinkedList fproduct = fs.getProductList(); Structure rs = new Structure(fproduct, freactant, -1 * this.getDirection()); Structure rsSp = new Structure(fsSp.products, fsSp.reactants, -1 * this.getDirection()); // If it's in the reverse ReactionTemplate.reactionDictionaryByStructure then just return that // one. TemplateReaction rr = rRT.getReactionFromStructure(rsSp); if (rr != null) { rr.setReverseReaction(this); return rr; } int rNum = fproduct.size(); Kinetics[] k = rRT.findReverseRateConstant(rs); // If that didnt work, what to do.... if (k == null && rRT.name.equals("R_Recombination")) { ChemGraph cg = ((ChemGraph) fproduct.get(0)); Graph g = cg.getGraph(); Node n = (Node) g.getCentralNodeAt(2); if (n == null) { cg = ((ChemGraph) fproduct.get(1)); g = cg.getGraph(); n = (Node) g.getCentralNodeAt(2); } g.clearCentralNode(); g.setCentralNode(1, n); k = rRT.findRateConstant(rs); } else if (k == null && rRT.name.equals("H_Abstraction")) { ChemGraph cg1 = ((ChemGraph) fproduct.get(0)); Graph g1 = cg1.getGraph(); Node n3 = (Node) g1.getCentralNodeAt(3); if (n3 == null) { cg1 = ((ChemGraph) fproduct.get(1)); g1 = cg1.getGraph(); n3 = (Node) g1.getCentralNodeAt(3); Node n2 = (Node) g1.getCentralNodeAt(2); g1.clearCentralNode(); g1.setCentralNode(1, n3); g1.setCentralNode(2, n2); ChemGraph cg2 = ((ChemGraph) fproduct.get(0)); Graph g2 = cg2.getGraph(); Node n1 = (Node) g2.getCentralNodeAt(1); g2.clearCentralNode(); g2.setCentralNode(3, n1); } else { Node n2 = (Node) g1.getCentralNodeAt(2); g1.clearCentralNode(); g1.setCentralNode(1, n3); g1.setCentralNode(2, n2); ChemGraph cg2 = ((ChemGraph) fproduct.get(1)); Graph g2 = cg2.getGraph(); Node n1 = (Node) g2.getCentralNodeAt(1); g2.clearCentralNode(); g2.setCentralNode(3, n1); } k = rRT.findRateConstant(rs); } /* * Added by MRH on 27-Aug-2009 This hard-coding is necessary for rxn family templates that are labeled * "thermo_consistence". After the chemgraphs are mutated, the central nodes for the products are not correct * (see example below). These hard-coded portions are necessary for RMG to find Kinetics for the structure. * Example: CH4 + H CH4 1 *1 C 0 {2,S} {3,S} {4,S} {5,S} 2 *2 H 0 {1,S} 3 H 0 {1,S} 4 H 0 {1,S} 5 H 0 {1,S} H 1 * *3 H 1 After RMG has "reactChemGraph" and "mutate" the chemgraphs of the reactants, the products would look * as such: prod1 1 *1 C 1 {2,S} {3,S} {4,S} 2 H 0 {1,S} 3 H 0 {1,S} 4 H 0 {1,S} prod2 1 *3 H 0 {2,S} 2 *2 H 0 * {1,S} Assuming the reaction as written (CH4+H=CH3+H2) is endothermic at 298K, RMG will label this structure * as direction=-1 (backward). When attempting to find Kinetics for the backward reaction, RMG will try to match * the prod1 graph against the generic graphs X_H and Y_rad_birad. It cannot match Y_rad_birad (because there is * no *3 node) and it cannot match X_H (because there is no *2 node). Thus, a "null" Kinetics will be returned * from the findReverseRateConstant call. We then relabel the central nodes on prod1 and prod2 and attempt to * get Kinetics for this structure. I am adding the following bit of code to work with the new reaction family * Aaron Vandeputte is adding to RMG: "". */ else if (k == null && rRT.name.equals("intra_substitutionS_isomerization")) { ChemGraph cg1 = ((ChemGraph) fproduct.get(0)); Graph g1 = cg1.getGraph(); Node n1 = (Node) g1.getCentralNodeAt(1); Node n2 = (Node) g1.getCentralNodeAt(2); Node n3 = (Node) g1.getCentralNodeAt(3); Node n4 = (Node) g1.getCentralNodeAt(4); Node n5 = (Node) g1.getCentralNodeAt(5); Node n6 = (Node) g1.getCentralNodeAt(6); Node n7 = (Node) g1.getCentralNodeAt(7); g1.clearCentralNode(); g1.setCentralNode(1, n1); g1.setCentralNode(2, n3); g1.setCentralNode(3, n2); if (n7 != null) { g1.setCentralNode(7, n4); g1.setCentralNode(6, n5); g1.setCentralNode(5, n6); g1.setCentralNode(4, n7); } else if (n6 != null) { g1.setCentralNode(6, n4); g1.setCentralNode(5, n5); g1.setCentralNode(4, n6); } else if (n5 != null) { g1.setCentralNode(5, n4); g1.setCentralNode(4, n5); } else if (n4 != null) g1.setCentralNode(4, n4); k = rRT.findRateConstant(rs); } // Adding another elseif statement for Aaron Vandeputte rxn family // RMG expects to find *1 and *2 in the same ChemGraph (for this rxn family) // but will instead find *1 and *3 in the same ChemGraph (if we've reached this far) // Need to switch *2 and *3 else if (k == null && (rRT.name.equals("substitutionS") || rRT.name.equals("Substitution_O"))) { ChemGraph cg1 = ((ChemGraph) fproduct.get(0)); ChemGraph cg2 = ((ChemGraph) fproduct.get(1)); Graph g1 = cg1.getGraph(); Graph g2 = cg2.getGraph(); Node n3 = (Node) g1.getCentralNodeAt(3); if (n3 == null) { // Switch the identities of cg1/g1 and cg2/g2 cg1 = ((ChemGraph) fproduct.get(1)); g1 = cg1.getGraph(); cg2 = ((ChemGraph) fproduct.get(0)); g2 = cg2.getGraph(); n3 = (Node) g1.getCentralNodeAt(3); } Node n1 = (Node) g1.getCentralNodeAt(1); g1.clearCentralNode(); g1.setCentralNode(2, n3); g1.setCentralNode(1, n1); Node n2 = (Node) g2.getCentralNodeAt(2); g2.clearCentralNode(); g2.setCentralNode(3, n2); k = rRT.findRateConstant(rs); } else if (k == null && rRT.name.equals("intra_H_migration")) { ChemGraph cg = ((ChemGraph) fproduct.get(0)); Graph g = cg.getGraph(); // Current max is 8 identified nodes Node n1 = (Node) g.getCentralNodeAt(1); Node n2 = (Node) g.getCentralNodeAt(2); Node n3 = (Node) g.getCentralNodeAt(3); Node n4 = (Node) g.getCentralNodeAt(4); Node n5 = (Node) g.getCentralNodeAt(5); Node n6 = (Node) g.getCentralNodeAt(6); Node n7 = (Node) g.getCentralNodeAt(7); Node n8 = (Node) g.getCentralNodeAt(8); g.clearCentralNode(); // Swap the locations of the central nodes 1 and 2 g.setCentralNode(1, n2); g.setCentralNode(2, n1); // Retain the location of the central node at 3 g.setCentralNode(3, n3); if (n8 != null) { g.setCentralNode(4, n5); g.setCentralNode(5, n4); g.setCentralNode(6, n8); g.setCentralNode(7, n7); g.setCentralNode(8, n6); } else if (n7 != null) { g.setCentralNode(4, n5); g.setCentralNode(5, n4); g.setCentralNode(6, n7); g.setCentralNode(7, n6); } else if (n6 != null) { g.setCentralNode(4, n5); g.setCentralNode(5, n4); g.setCentralNode(6, n6); } else if (n5 != null) { // Swap the locations of the central nodes 4 and 5, if node 5 exists g.setCentralNode(4, n5); g.setCentralNode(5, n4); } else if (n4 != null) { // if only central node 4 exists, retain that location g.setCentralNode(4, n4); } k = rRT.findRateConstant(rs); // rr = rRT.calculateForwardRateConstant(cg, rs); // if (!rr.isForward()) { // String err = "Backward:" // + structure.toString() // + String.valueOf(structure // .calculateKeq(new Temperature(298, "K"))) // + '\n'; // err = err // + "Forward:" // + rr.structure.toString() // + String.valueOf(rr.structure // .calculateKeq(new Temperature(298, "K"))); // throw new InvalidReactionDirectionException(err); // } // rr.setReverseReaction(this); // rRT.addReaction(rr); // return rr; } else if (k == null && rRT.name.equals("H_shift_cyclopentadiene")) { ChemGraph cg = ((ChemGraph) fproduct.get(0)); Graph g = cg.getGraph(); // Current max is 6 identified nodes Node n1 = (Node) g.getCentralNodeAt(1); Node n2 = (Node) g.getCentralNodeAt(2); Node n3 = (Node) g.getCentralNodeAt(3); Node n4 = (Node) g.getCentralNodeAt(4); Node n5 = (Node) g.getCentralNodeAt(5); Node n6 = (Node) g.getCentralNodeAt(6); g.clearCentralNode(); // Swap the locations of the central nodes 1 to 6 g.setCentralNode(1, n2); g.setCentralNode(2, n1); g.setCentralNode(3, n5); g.setCentralNode(4, n4); g.setCentralNode(5, n3); g.setCentralNode(6, n6); k = rRT.findRateConstant(rs); } if (k == null) { Logger.error( "Couldn't find the rate constant for reaction: " + rs.toChemkinString(true) + " with " + rRT.name); // System.exit(0); return null; } rr = new TemplateReaction(rsSp, k, rRT); if (!rr.isForward()) { String err = "Backward:" + structure.toString() + String.valueOf(structure.calculateKeq(new Temperature(298, "K"))) + '\n'; err = err + "Forward:" + rr.structure.toString() + String.valueOf(rr.structure.calculateKeq(new Temperature(298, "K"))); throw new InvalidReactionDirectionException(err); } rr.setReverseReaction(this); rRT.addReaction(rr); return rr; // #] }