better parser for solver-generated observables

Author: danv61

vcell-client/src/main/java/cbit/vcell/client/data/SimulationWorkspaceModelInfo.java

@@ -379,17 +379,17 @@ public void populateDataSymbolMetadata(ColumnDescription[] cdArray) {
 				String columnName = cd.getName();
 				ModelCategoryType filterCategory = null;	// parse name to find the filter category
 				SsldUtils.LangevinResult lr = SsldUtils.LangevinResult.fromString(columnName);
-				if(!(lr.qualifier.equals("FREE") || lr.qualifier.equals("BOUND") || lr.qualifier.equals("TOTAL"))) {
-					System.out.println("Ignoring LangevinResult token: " + columnName);
+				if(lr.qualifier.equals(SsldUtils.Qualifier.NONE)) {
+					System.out.println("Ignoring LangevinResult token: " + columnName + ", qualifier missing");
 					continue;
 				}
 				if(!lr.molecule.isEmpty() && lr.site.isEmpty() && lr.state.isEmpty()) {
 					filterCategory = BioModelCategoryType.Molecules;
-				} else if(lr.qualifier.equals("FREE") && !lr.molecule.isEmpty() && !lr.site.isEmpty() && !lr.state.isEmpty()) {
+				} else if(lr.qualifier.equals(SsldUtils.Qualifier.FREE) && !lr.molecule.isEmpty() && !lr.site.isEmpty() && !lr.state.isEmpty()) {
 					filterCategory = BioModelCategoryType.FreeSites;
-				} else if(lr.qualifier.equals("BOUND") && !lr.molecule.isEmpty() && !lr.site.isEmpty() && !lr.state.isEmpty()) {
+				} else if(lr.qualifier.equals(SsldUtils.Qualifier.BOUND) && !lr.molecule.isEmpty() && !lr.site.isEmpty() && !lr.state.isEmpty()) {
 					filterCategory = BioModelCategoryType.BoundSites;
-				} else if(lr.qualifier.equals("TOTAL") && !lr.molecule.isEmpty() && !lr.site.isEmpty() && !lr.state.isEmpty()) {
+				} else if(lr.qualifier.equals(SsldUtils.Qualifier.TOTAL) && !lr.molecule.isEmpty() && !lr.site.isEmpty() && !lr.state.isEmpty()) {
 					filterCategory = BioModelCategoryType.TotalSites;
 				}
 				VCUnitDefinition unit = null;

vcell-core/src/main/java/org/vcell/model/ssld/SsldUtils.java

@@ -24,43 +24,74 @@
 
 public class SsldUtils {
 
+    public enum Qualifier {
+        FREE, BOUND, TOTAL, NONE;
+        public static Qualifier fromPrefix(String s) {
+            for (Qualifier q : values()) {
+                if (q != NONE && q.name().equals(s)) {
+                    return q;
+                }
+            }
+            return NONE;
+        }
+    }
+
     // result entry from langevin output
     public static class LangevinResult {
-        public final String qualifier;
+        public final Qualifier qualifier;
         public final String molecule;
         public final String site;
         public final String state;
 
         public static LangevinResult fromString(String str) {
-            if(str == null || str.length() == 0) {
+            if (str == null || str.isEmpty()) {
                 throw new RuntimeException("Langevin generated molecules name must contain some text");
             }
-            String qualifier = "";
-            String molecule = "";
+
+            // Step 1: split only on DOUBLE underscore
+            String[] parts = str.split("__");
+
+            String first = parts[0];
+
+            // Step 2: find first underscore
+            int idx = first.indexOf('_');
+
+            Qualifier qualifier = Qualifier.NONE;
+            String molecule;
+
+            if (idx > 0) {
+                String prefix = first.substring(0, idx);
+                qualifier = Qualifier.fromPrefix(prefix);
+
+                if (qualifier != Qualifier.NONE) {
+                    // Valid qualifier found
+                    molecule = first.substring(idx + 1);
+                } else {
+                    // Not a valid qualifier → whole thing is molecule
+                    molecule = first;
+                }
+            } else {
+                // No underscore at all → no qualifier
+                molecule = first;
+            }
+
             String site = "";
             String state = "";
 
-            String[] tokens = str.split("_{1,2}");
-            if(tokens.length <1 || tokens.length > 4) {
-                throw new RuntimeException("Langevin generated molecules name must have between one and 4 tokens");
+            if (parts.length >= 2) {
+                site = parts[1];
             }
-            for (int i=0; i<tokens.length; i++) {
-                String token = tokens[i];
-                if(i == 0) {
-                    qualifier = token;
-                } else if(i == 1) {
-                    molecule = token;
-                } else if(i == 2) {
-                    site = token;
-                } else if(i == 3) {
-                    state = token;
-                }
+            if (parts.length >= 3) {
+                state = parts[2];
             }
-           LangevinResult lr = new LangevinResult(qualifier, molecule, site, state);
-            return lr;
+            if (parts.length > 3) {
+                throw new RuntimeException("Too many '__' sections in: " + str);
+            }
+
+            return new LangevinResult(qualifier, molecule, site, state);
         }
 
-        public LangevinResult(String qualifier, String molecule, String site, String state) {
+        public LangevinResult(Qualifier qualifier, String molecule, String site, String state) {
             this.qualifier = qualifier;
             this.molecule = molecule;
             this.site = site;