Seed Mechanisms reactions now added to core or edge properly.

Previously, they were all placed on the edge. This was a problem when a reaction
should have been in the core (based on all reagents being in the core in
the condition file). Such reactions are now placed in the core.

Also, we now add both forward and reverse directions, if reverse directions exist.

The addReactionSet(LinkedHashSet) method did almost exactly what I needed, but
it would discard reactions that had a reactant not in the core (you couldn't
have something entirely in the edge). Rather than change the behaviour
of that method (which is used elsewhere) I made a new method: addReactionSetFromSeed

Author: rwest

source/RMG/jing/rxnSys/CoreEdgeReactionModel.java

@@ -164,7 +164,7 @@ else if (rxnType == -1) {
 
         return;
     }
-    
+	
     //## operation addReactedReaction(Reaction) 
     public void addReactedReaction(Reaction p_reaction) throws InvalidReactedReactionException {
         //#[ operation addReactedReaction(Reaction) 
@@ -243,23 +243,32 @@ public void addReactionSet(LinkedHashSet p_reactionSet) {
         	int rxnType = categorizeReaction(rxn);
         	if (rxnType == 1) {
         		addReactedReaction(rxn);
+				//Logger.info(String.format("Adding to model core: %s",rxn));
         	}
         	else if (rxnType == -1) {
         		addUnreactedReaction(rxn);
+				//Logger.info(String.format("Adding to model edge: %s",rxn));
         	}
-        	
+			else {
+				Logger.warning(String.format("Adding to neither edge nor core: %s",rxn));
+			}
+			
         	//also add the reverse reaction 
         	if (rxn.hasReverseReaction()){
         		Reaction reverse = (Reaction)rxn.getReverseReaction();
         		rxnType = categorizeReaction(reverse);
         		if (rxnType == 1){
         			addReactedReaction(reverse);
+					//Logger.info(String.format("Adding to model core: %s",reverse));
         		}
         		else if (rxnType == -1){
         			addUnreactedReaction(reverse);
+					//Logger.info(String.format("Adding to model edge: %s",reverse));
         		}
+				else {
+					Logger.warning(String.format("Adding to neither edge nor core: %s",reverse));
+				}
         	}
-        	
         }
 
         return;
@@ -279,7 +288,46 @@ public void addReaction(Reaction p_reaction){
     	else
     		addUnreactedReaction(p_reaction);
     }
-    
+
+	
+	//## operation addReactionSetFromSeed(HashSet) 
+	/*
+	  This is like addReactionSet(p_reactionSet) but it insists on adding
+	  the reaction *somewhere*, either the core or the edge. It should be
+	 particularly useful for reaction sets that come from seed mechanisms.
+	  Adds both the forward and reverse reactions.
+	*/
+    public void addReactionSetFromSeed(LinkedHashSet p_reactionSet) {
+        //#[ operation addReactionSetFromSeed(HashSet)
+        for (Iterator iter = p_reactionSet.iterator(); iter.hasNext(); ) {
+        	Reaction rxn = (Reaction)iter.next();
+			int rxnType = categorizeReaction(rxn);
+        	if (rxnType == 1) {
+        		addReactedReaction(rxn);
+				Logger.info(String.format("Adding to model core: %s",rxn));
+        	}
+        	else {
+        		addUnreactedReaction(rxn);
+				Logger.info(String.format("Adding to model edge: %s",rxn));
+        	}
+        	//also add the reverse reaction
+        	if (rxn.hasReverseReaction()){
+        		Reaction reverse = (Reaction)rxn.getReverseReaction();
+        		rxnType = categorizeReaction(reverse);
+        		if (rxnType == 1){
+        			addReactedReaction(reverse);
+					Logger.info(String.format("Adding to model core: %s",reverse));
+        		}
+        		else {
+        			addUnreactedReaction(reverse);
+					Logger.info(String.format("Adding to model edge: %s",reverse));
+        		}
+        	}
+        }
+        return;
+        //#]
+    }
+
     //## operation addUnreactedReaction(Reaction) 
     public void addUnreactedReaction(Reaction p_reaction) throws InvalidUnreactedReactionException {
         //#[ operation addUnreactedReaction(Reaction) 

source/RMG/jing/rxnSys/ReactionModelGenerator.java

@@ -3553,9 +3553,9 @@ public void initializeCoreEdgeModel() {
 
 		// Add the species and reactions from the seed mechanisms, if they exist, to the edge.
     	if (hasSeedMechanisms()) {
-			Logger.info("Adding seed mechanisms to edge");
+			Logger.info("Adding seed mechanisms.");
     		cerm.addUnreactedSpeciesSet(getSeedMechanism().getSpeciesSet());
-    		cerm.addUnreactedReactionSet(getSeedMechanism().getReactionSet());
+    		cerm.addReactionSetFromSeed(getSeedMechanism().getReactionSet());
 			// Store the seed mechanism in the CERM so that we can access it from there when writing chemkin files:
 			cerm.setSeedMechanism(getSeedMechanism());
     	}