Hand-merge of some things from Dev_Vertex branch that didn't make it in for some reason

# Conflicts:
#	src/main/java/GraphModificationFunctions.java
#	src/main/java/GraphWithMapData.java
#	src/main/java/Simulator.java
#	src/main/java/Vertex.java

readme.md

@@ -20,8 +20,8 @@ The problem of pairing TCRA/TCRB sequences thus reduces to the "assignment probl
 matching on a bipartite graph--the subset of vertex-disjoint edges whose weights sum to the maximum possible value.
 
 This is a well-studied combinatorial optimization problem, with many known solutions.
-The most efficient algorithm known to the author for maximum weight matching of a bipartite graph with strictly integral weights
+The most efficient algorithm known to the author for maximum weight matching of a bipartite graph with strictly integral
-is from Duan and Su (2012). For a graph with m edges, n vertices per side, and maximum integer edge weight N, 
+weights is from Duan and Su (2012). For a graph with m edges, n vertices per side, and maximum integer edge weight N, 
 their algorithm runs in **O(m sqrt(n) log(N))** time. As the graph representation of a pairSEQ experiment is 
 bipartite with integer weights, this algorithm is ideal for BiGpairSEQ.
 
@@ -43,13 +43,13 @@ Run with the command:
 `java -jar BiGpairSEQ_Sim.jar`
 
 Processing sample plates with tens of thousands of sequences may require large amounts 
-of RAM. It is often desirable to increase the JVM maximum heap allocation with the -Xmx flag.
+of RAM. It is often desirable to increase the JVM maximum heap allocation with the `-Xmx` flag.
 For example, to run the program with 32 gigabytes of memory, use the command:
 
 `java -Xmx32G -jar BiGpairSEQ_Sim.jar`
 
 There are a number of command line options, to allow the program to be used in shell scripts. For a full list,
-use the -help flag:
+use the `-help` flag:
 
 `java -jar BiGpairSEQ_Sim.jar -help`
 
@@ -108,7 +108,7 @@ device-specific.)
 
 The program's caching behavior can be controlled in the Options menu. By default, all caching is OFF.
 
-The program can optionally output Graph/Data files in .GraphML format (.graphml) for data portability. This can be 
+The program can optionally output Graph/Data files in GraphML format (.graphml) for data portability. This can be 
 turned on in the Options menu. By default, GraphML output is OFF.
 
 ---
@@ -203,8 +203,13 @@ Options for creating a Graph/Data file:
 
 These files do not have a human-readable structure, and are not portable to other programs.
 
-(For portability to other software, turn on GraphML output in the Options menu. This will produce a .graphml file
+*Optional GraphML output*
-for the weighted graph, with vertex attributes sequence, type, and occupancy data.)
+
+For portability of graph data to other software, turn on [GraphML](http://graphml.graphdrawing.org/index.html) output 
+in the Options menu in interactive mode, or use the `-graphml`command line argument. This will produce a .graphml file 
+for the weighted graph, with vertex attributes for sequence, type, and occupancy data. This graph contains all the data 
+necessary for the BiGpairSEQ matching algorithm. It does not include the data to measure pairing accuracy; for that, 
+compare the matching results to the original Cell Sample .csv file.
 
 ---
 
@@ -259,29 +264,77 @@ Example output:
 P-values are calculated *after* BiGpairSEQ matching is completed, for purposes of comparison only, 
 using the (2021 corrected) formula from the original pairSEQ paper. (Howie, et al. 2015)
 
-### PERFORMANCE
+
-Performance details of the example excerpted above:
+## PERFORMANCE
 
 On a home computer with a Ryzen 5600X CPU, 64GB of 3200MHz DDR4 RAM (half of which was allocated to the Java Virtual Machine), and a PCIe 3.0 SSD, running Linux Mint 20.3 Edge (5.13 kernel), 
 the author ran a BiGpairSEQ simulation of a 96-well sample plate with 30,000 T cells/well comprising ~11,800 alphas and betas,
-taken from a sample of 4,000,000 distinct cells with an exponential frequency distribution.
+taken from a sample of 4,000,000 distinct cells with an exponential frequency distribution (lambda 0.6).
 
 With min/max occupancy threshold of 3 and 94 wells for matching, and no other pre-filtering, BiGpairSEQ identified 5,151 
 correct pairings and 18 incorrect pairings, for an accuracy of 99.652%.
 
-The simulation time was 14'22". If intermediate results were held in memory, this would be equivalent to the total elapsed time.
+The total simulation time was 14'22". If intermediate results were held in memory, this would be equivalent to the total elapsed time.
 
 Since this implementation of BiGpairSEQ writes intermediate results to disk (to improve the efficiency of *repeated* simulations
 with different filtering options), the actual elapsed time was greater. File I/O time was not measured, but took 
 slightly less time than the simulation itself. Real elapsed time from start to finish was under 30 minutes.
 
+As mentioned in the theory section, performance could be improved by implementing a more efficient algorithm for finding
+the maximum weight matching.
+
+## BEHAVIOR WITH RANDOMIZED WELL POPULATIONS
+
+A series of BiGpairSEQ simulations were conducted using a cell sample file of 3.5 million unique T cells. From these cells,
+10 sample plate files were created. All of these sample plates had 96 wells, used an exponential distribution with a lambda of 0.6, and
+had a sequence dropout rate of 10%.
+
+The well populations of the plates were:
+* One sample plate with 1000 T cells/well
+* One sample plate with 2000 T cells/well
+* One sample plate with 3000 T cells/well
+* One sample plate with 4000 T cells/well
+* One sample plate with 5000 T cells/well
+* Five sample plates with each individual well's population randomized, from 1000 to 5000 T cells. (Average population ~3000 T cells/well.)
+
+All BiGpairSEQ simulations were run with a low overlap threshold of 3 and a high overlap threshold of 94.
+No optional filters were used, so pairing was attempted for all sequences with overlaps within the threshold values.
+
+Constant well population plate results:
+
+| |1000 Cell/Well Plate|2000 Cell/Well Plate|3000 Cell/Well Plate|4000 Cell/Well Plate|5000 Cell/Well Plate
+|---|---|---|---|---|---|
+|Total Alphas Found|6407|7330|7936|8278|8553|
+|Total Betas Found|6405|7333|7968|8269|8582|
+|Pairing Attempt Rate|0.661|0.653|0.600|0.579|0.559|
+|Correct Pairing Count|4231|4749|4723|4761|4750|
+|Incorrect Pairing Count|3|34|40|26|29|
+|Pairing Error Rate|0.000709|0.00711|0.00840|0.00543|0.00607|
+|Simulation Time (Seconds)|500|643|700|589|598|
+
+Randomized well population plate results:
+
+| |Random Plate 1 | Random Plate 2|Random Plate 3|Random Plate 4|Random Plate 5|Average|
+|---|---|---|---|---|---|---|
+Total Alphas Found|7853|7904|7964|7898|7917|7907|
+Total Betas Found|7851|7891|7920|7910|7894|7893|
+Pairing Attempt Rate|0.607|0.610|0.601|0.605|0.603|0.605|
+Correct Pairing Count|4718|4782|4721|4755|4731|4741|
+Incorrect Pairing Count|51|35|42|27|29|37|
+Pairing Error Rate|0.0107|0.00727|0.00882|0.00565|0.00609|0.00771|
+Simulation Time (Seconds)|590|677|730|618|615|646|
+
+The average results for the randomized plates are closest to the constant plate with 3000 T cells/well.
+This and several other tests indicate that BiGpairSEQ treats a sample plate with a highly variable number of T cells/well
+roughly as though it had a constant well population equal to the plate's average well population.
+
 ## TODO
 
 * ~~Try invoking GC at end of workloads to reduce paging to disk~~ DONE
 * ~~Hold graph data in memory until another graph is read-in? ABANDONED UNABANDONED~~ DONE
   * ~~*No, this won't work, because BiGpairSEQ simulations alter the underlying graph based on filtering constraints. Changes would cascade with multiple experiments.*~~
   * Might have figured out a way to do it, by taking edges out and then putting them back into the graph. This may actually be possible.
-  * It is possible, though the modifications to the graph incur their own performance penalties. Need testing to see which option is best.
+  * It is possible, though the modifications to the graph incur their own performance penalties. Need testing to see which option is best. It may be computer-specific.
 * ~~Test whether pairing heap (currently used) or Fibonacci heap is more efficient for priority queue in current matching algorithm~~ DONE
   * ~~in theory Fibonacci heap should be more efficient, but complexity overhead may eliminate theoretical advantage~~
   * ~~Add controllable heap-type parameter?~~
@@ -294,14 +347,23 @@ slightly less time than the simulation itself. Real elapsed time from start to f
   * ~~Apache Commons CSV library writes entries a row at a time~~ 
     * _Got this working, but at the cost of a profoundly strange bug in graph occupancy filtering. Have reverted the repo until I can figure out what caused that. Given how easily Thingiverse transposes CSV matrices in R, might not even be worth fixing.
 * ~~Enable GraphML output in addition to serialized object binaries, for data portability~~ DONE
-  * ~~Custom vertex type with attribute for sequence occupancy?~~ ABANDONED
+  * ~~Custom vertex type with attribute for sequence occupancy?~~ DONE
-    * Have a branch where this is implemented, but there's a bug that broke matching. Don't currently have time to fix.
+    * Advantage: would eliminate the need to use maps to associate vertices with sequences, which would make the code easier to understand.
+    * ~~Have a branch where this is implemented, but there's a bug that broke matching. Don't currently have time to fix.~~
 * ~~Re-implement command line arguments, to enable scripting and statistical simulation studies~~ DONE
+* ~~Implement custom Vertex class to simplify code and make it easier to implement different MWM algorithms~~ DONE
+  * This also seems to be faster when using the same algorithm than the version with lots of maps, which is a nice bonus!
 * Re-implement CDR1 matching method
 * Implement Duan and Su's maximum weight matching algorithm
     * Add controllable algorithm-type parameter?
     * This would be fun and valuable, but probably take more time than I have for a hobby project.
+* Implement an algorithm for approximating a maximum weight matching
+  * Some of these run in linear or near-linear time
+  * given that the underlying biological samples have many, many sources of error, this would probably be the most useful option in practice. It seems less mathematically elegant, though, and so less fun for me.
 * Implement Vose's alias method for arbitrary statistical distributions of cells
+  * Should probably refactor to use apache commons rng for this
+* Use commons JCS for caching
+* Parameterize pre-filtering. Currently, sequences present in all wells are filtered out before constructing the graph, which massively reduces graph size. But, ideally, no pre-filtering would be necessary.
   
   
 ## CITATIONS
@@ -314,7 +376,7 @@ slightly less time than the simulation itself. Real elapsed time from start to f
 * [JGraphT](https://jgrapht.org) -- Graph theory data structures and algorithms
 * [JHeaps](https://www.jheaps.org) -- For pairing heap priority queue used in maximum weight matching algorithm
 * [Apache Commons CSV](https://commons.apache.org/proper/commons-csv/) -- For CSV file output
-* [Apache Commons CLI](https://commons.apache.org/proper/commons-cli/) -- To enable command line arguments for scripting. (**Awaiting re-implementation**.)
+* [Apache Commons CLI](https://commons.apache.org/proper/commons-cli/) -- To enable command line arguments for scripting.
 
 ## ACKNOWLEDGEMENTS
 BiGpairSEQ was conceived in collaboration with Dr. Alice MacQueen, who brought the original 

src/main/java/BiGpairSEQ.java

@@ -13,9 +13,10 @@ public class BiGpairSEQ {
     private static boolean cacheCells = false;
     private static boolean cachePlate = false;
     private static boolean cacheGraph = false;
-    private static String priorityQueueHeapType = "FIBONACCI";
+    private static HeapType priorityQueueHeapType = HeapType.FIBONACCI;
     private static boolean outputBinary = true;
     private static boolean outputGraphML = false;
+    private static final String version = "version 3.0";
 
     public static void main(String[] args) {
         if (args.length == 0) {
@@ -156,15 +157,15 @@ public class BiGpairSEQ {
     }
 
     public static String getPriorityQueueHeapType() {
-        return priorityQueueHeapType;
+        return priorityQueueHeapType.name();
     }
 
     public static void setPairingHeap() {
-        priorityQueueHeapType = "PAIRING";
+        priorityQueueHeapType = HeapType.PAIRING;
     }
 
     public static void setFibonacciHeap() {
-        priorityQueueHeapType = "FIBONACCI";
+        priorityQueueHeapType = HeapType.FIBONACCI;
     }
 
     public static boolean outputBinary() {return outputBinary;}
@@ -172,5 +173,5 @@ public class BiGpairSEQ {
 
     public static boolean outputGraphML() {return outputGraphML;}
     public static void setOutputGraphML(boolean b) {outputGraphML = b;}
-
+    public static String getVersion() { return version; }
 }

src/main/java/CellSample.java

@@ -13,8 +13,12 @@ public class CellSample {
         List<Integer> numbersCDR3 = new ArrayList<>();
         List<Integer> numbersCDR1 = new ArrayList<>();
         Integer numDistCDR3s = 2 * numDistinctCells + 1;
+        //Assign consecutive integers for each CDR3. This ensures they are all unique.
         IntStream.range(1, numDistCDR3s + 1).forEach(i -> numbersCDR3.add(i));
+        //After all CDR3s are assigned, start assigning consecutive integers to CDR1s
+        //There will usually be fewer integers in the CDR1 list, which will allow repeats below
         IntStream.range(numDistCDR3s + 1, numDistCDR3s + 1 + (numDistCDR3s / cdr1Freq) + 1).forEach(i -> numbersCDR1.add(i));
+        //randomize the order of the numbers in the lists
         Collections.shuffle(numbersCDR3);
         Collections.shuffle(numbersCDR1);
 
@@ -22,11 +26,15 @@ public class CellSample {
         //two CDR3s, and two CDR1s. First two values are CDR3s (alpha, beta), second two are CDR1s (alpha, beta)
         List<Integer[]> distinctCells = new ArrayList<>();
         for(int i = 0; i < numbersCDR3.size() - 1; i = i + 2){
+            //Go through entire CDR3 list once, make pairs of alphas and betas
             Integer tmpCDR3a = numbersCDR3.get(i);
             Integer tmpCDR3b = numbersCDR3.get(i+1);
+            //Go through (likely shorter) CDR1 list as many times as necessary, make pairs of alphas and betas
             Integer tmpCDR1a = numbersCDR1.get(i % numbersCDR1.size());
             Integer tmpCDR1b = numbersCDR1.get((i+1) % numbersCDR1.size());
+            //Make the array representing the cell
             Integer[] tmp = {tmpCDR3a, tmpCDR3b, tmpCDR1a, tmpCDR1b};
+            //Add the cell to the list of distinct cells
             distinctCells.add(tmp);
         }
         this.cells = distinctCells;

src/main/java/CommandLineInterface.java

@@ -62,15 +62,18 @@ public class CommandLineInterface {
 
             if (line.hasOption("help")) {
                 HelpFormatter formatter = new HelpFormatter();
-                formatter.printHelp("BiGpairSEQ_Sim", mainOptions);
+                formatter.printHelp("BiGpairSEQ_Sim.jar", mainOptions);
                 System.out.println();
-                formatter.printHelp("BiGpairSEQ_SIM -cells", cellOptions);
+                formatter.printHelp("BiGpairSEQ_Sim.jar -cells", cellOptions);
                 System.out.println();
-                formatter.printHelp("BiGpairSEQ_Sim -plate", plateOptions);
+                formatter.printHelp("BiGpairSEQ_Sim.jar -plate", plateOptions);
                 System.out.println();
-                formatter.printHelp("BiGpairSEQ_Sim -graph", graphOptions);
+                formatter.printHelp("BiGpairSEQ_Sim.jar -graph", graphOptions);
                 System.out.println();
-                formatter.printHelp("BiGpairSEQ_Sim -match", matchOptions);
+                formatter.printHelp("BiGpairSEQ_Sim.jar -match", matchOptions);
+            }
+            else if (line.hasOption("version")) {
+                System.out.println("BiGpairSEQ_Sim " + BiGpairSEQ.getVersion());
             }
             else if (line.hasOption("cells")) {
                 line = parser.parse(cellOptions, Arrays.copyOfRange(args, 1, args.length));
@@ -153,17 +156,24 @@ public class CommandLineInterface {
             else if (line.hasOption("match")) { //can add a flag for which match type in future, spit this in two
                 line = parser.parse(matchOptions, Arrays.copyOfRange(args, 1, args.length));
                 String graphFilename = line.getOptionValue("g");
-                String outputFilename = line.getOptionValue("o");
+
+                String outputFilename;
+                if(line.hasOption("o")) {
+                    outputFilename = line.getOptionValue("o");
+                }
+                else {
+                    outputFilename = null;
+                }
                 Integer minThreshold = Integer.parseInt(line.getOptionValue("min"));
                 Integer maxThreshold = Integer.parseInt(line.getOptionValue("max"));
-                Integer minOverlapPct;
+                int minOverlapPct;
                 if (line.hasOption("minpct")) { //see if this filter is being used
                     minOverlapPct = Integer.parseInt(line.getOptionValue("minpct"));
                 }
                 else {
                     minOverlapPct = 0;
                 }
-                Integer maxOccupancyDiff;
+                int maxOccupancyDiff;
                 if (line.hasOption("maxdiff")) { //see if this filter is being used
                     maxOccupancyDiff = Integer.parseInt(line.getOptionValue("maxdiff"));
                 }
@@ -173,10 +183,38 @@ public class CommandLineInterface {
                 GraphWithMapData graph = getGraph(graphFilename);
                 MatchingResult result = Simulator.matchCDR3s(graph, graphFilename, minThreshold, maxThreshold,
                         maxOccupancyDiff, minOverlapPct, false);
-                MatchingFileWriter writer = new MatchingFileWriter(outputFilename, result);
+                if(outputFilename != null){
-                writer.writeResultsToFile();
+                    MatchingFileWriter writer = new MatchingFileWriter(outputFilename, result);
+                    writer.writeResultsToFile();
+                }
                 //can put a bunch of ifs for outputting various things from the MatchingResult to System.out here
                 //after I put those flags in the matchOptions
+                if(line.hasOption("print-metadata")) {
+                    for (String k : result.getMetadata().keySet()) {
+                        System.out.println(k + ": " + result.getMetadata().get(k));
+                    }
+                }
+                if(line.hasOption("print-error")) {
+                    System.out.println("pairing error rate: " + result.getPairingErrorRate());
+                }
+                if(line.hasOption("print-attempt")) {
+                    System.out.println("pairing attempt rate: " +result.getPairingAttemptRate());
+                }
+                if(line.hasOption("print-correct")) {
+                    System.out.println("correct pairings: " + result.getCorrectPairingCount());
+                }
+                if(line.hasOption("print-incorrect")) {
+                    System.out.println("incorrect pairings: " + result.getIncorrectPairingCount());
+                }
+                if(line.hasOption("print-alphas")) {
+                    System.out.println("total alphas found: " + result.getAlphaCount());
+                }
+                if(line.hasOption("print-betas")) {
+                    System.out.println("total betas found: " + result.getBetaCount());
+                }
+                if(line.hasOption("print-time")) {
+                    System.out.println("simulation time (seconds): " + result.getSimulationTime());
+                }
             }
         }
         catch (ParseException exp) {
@@ -216,8 +254,11 @@ public class CommandLineInterface {
                 .longOpt("match-cdr3")
                 .desc("Matches CDR3s. Requires a graph/data file.")
                 .build();
+        Option printVersion = Option.builder("version")
+                .desc("Prints the program version number to stdout").build();
         OptionGroup mainGroup = new OptionGroup();
         mainGroup.addOption(help);
+        mainGroup.addOption(printVersion);
         mainGroup.addOption(makeCells);
         mainGroup.addOption(makePlate);
         mainGroup.addOption(makeGraph);
@@ -297,7 +338,7 @@ public class CommandLineInterface {
                 .desc("Randomize well populations on sample plate. Takes two arguments: the minimum possible population and the maximum possible population.")
                 .hasArgs()
                 .numberOfArgs(2)
-                .argName("minimum maximum")
+                .argName("min> <max")
                 .build();
         Option specificWellPopulations = Option.builder("pop")
                 .desc("The well populations for each section of the sample plate. There will be as many sections as there are populations given.")
@@ -326,22 +367,22 @@ public class CommandLineInterface {
         Options graphOptions = new Options();
         Option cellFilename = Option.builder("c")
                 .longOpt("cell-file")
-                .desc("Cell sample file to use for checking accuracy")
+                .desc("Cell sample file to use for checking pairing accuracy")
                 .hasArg()
                 .argName("filename")
                 .required().build();
         Option plateFilename = Option.builder("p")
                 .longOpt("plate-filename")
-                .desc("Sample plate file (made from given cell sample file) to construct graph from")
+                .desc("Sample plate file from which to construct graph")
                 .hasArg()
                 .argName("filename")
                 .required().build();
         Option outputGraphML = Option.builder("graphml")
-                .desc("Output GraphML file")
+                .desc("(Optional) Output GraphML file")
                 .build();
         Option outputSerializedBinary = Option.builder("nb")
                 .longOpt("no-binary")
-                .desc("Don't output serialized binary file")
+                .desc("(Optional) Don't output serialized binary file")
                 .build();
         graphOptions.addOption(cellFilename);
         graphOptions.addOption(plateFilename);
@@ -379,15 +420,46 @@ public class CommandLineInterface {
                 .hasArg()
                 .argName("number")
                 .build();
-        matchCDR3options.addOption(graphFilename);
+        Option outputFile = Option.builder("o") //can't call the method this time, because this one's optional
-        matchCDR3options.addOption(minOccupancyOverlap);
+                .longOpt("output-file")
-        matchCDR3options.addOption(maxOccupancyOverlap);
+                .hasArg()
-        matchCDR3options.addOption(minOverlapPercent);
+                .argName("filename")
-        matchCDR3options.addOption(maxOccupancyDifference);
+                .desc("(Optional) Name of output the output file. If not present, no file will be written.")
-        matchCDR3options.addOption(outputFileOption());
+                .build();
-        //options for output to System.out
+        matchCDR3options.addOption(graphFilename)
-       //Option printPairingErrorRate = Option.builder()
+                .addOption(minOccupancyOverlap)
+                .addOption(maxOccupancyOverlap)
+                .addOption(minOverlapPercent)
+                .addOption(maxOccupancyDifference)
+                .addOption(outputFile);
 
+        //options for output to System.out
+        Option printAlphaCount = Option.builder().longOpt("print-alphas")
+                .desc("(Optional) Print the number of distinct alpha sequences to stdout.").build();
+        Option printBetaCount = Option.builder().longOpt("print-betas")
+                .desc("(Optional) Print the number of distinct beta sequences to stdout.").build();
+        Option printTime = Option.builder().longOpt("print-time")
+                .desc("(Optional) Print the total simulation time to stdout.").build();
+        Option printErrorRate = Option.builder().longOpt("print-error")
+               .desc("(Optional) Print the pairing error rate to stdout").build();
+        Option printAttempt = Option.builder().longOpt("print-attempt")
+               .desc("(Optional) Print the pairing attempt rate to stdout").build();
+        Option printCorrect = Option.builder().longOpt("print-correct")
+               .desc("(Optional) Print the number of correct pairs to stdout").build();
+        Option printIncorrect = Option.builder().longOpt("print-incorrect")
+               .desc("(Optional) Print the number of incorrect pairs to stdout").build();
+        Option printMetadata = Option.builder().longOpt("print-metadata")
+                       .desc("(Optional) Print a full summary of the matching results to stdout.").build();
+
+       matchCDR3options
+               .addOption(printErrorRate)
+               .addOption(printAttempt)
+               .addOption(printCorrect)
+               .addOption(printIncorrect)
+               .addOption(printMetadata)
+               .addOption(printAlphaCount)
+               .addOption(printBetaCount)
+               .addOption(printTime);
         return matchCDR3options;
     }
 

src/main/java/GraphDataObjectReader.java

@@ -4,7 +4,7 @@ public class GraphDataObjectReader {
 
     private GraphWithMapData data;
     private String filename;
-    private boolean verbose = true;
+
 
     public GraphDataObjectReader(String filename, boolean verbose) throws IOException {
         if(!filename.matches(".*\\.ser")){
@@ -15,10 +15,13 @@ public class GraphDataObjectReader {
             BufferedInputStream fileIn = new BufferedInputStream(new FileInputStream(filename));
                 ObjectInputStream in = new ObjectInputStream(fileIn))
         {
-            System.out.println("Reading graph data from file. This may take some time");
+            if (verbose) {
-            System.out.println("File I/O time is not included in results");
+                System.out.println("Reading graph data from file. This may take some time");
+                System.out.println("File I/O time is not included in results");
+            }
             data = (GraphWithMapData) in.readObject();
         } catch (FileNotFoundException | ClassNotFoundException ex) {
+            System.out.println("Graph/data file " + filename + " not found.");
             ex.printStackTrace();
         }
     }

src/main/java/GraphMLFileWriter.java

@@ -3,8 +3,9 @@ import org.jgrapht.graph.SimpleWeightedGraph;
 import org.jgrapht.nio.Attribute;
 import org.jgrapht.nio.AttributeType;
 import org.jgrapht.nio.DefaultAttribute;
-import org.jgrapht.nio.dot.DOTExporter;
 import org.jgrapht.nio.graphml.GraphMLExporter;
+import org.jgrapht.nio.graphml.GraphMLExporter.AttributeCategory;
+import org.w3c.dom.Attr;
 
 import java.io.BufferedWriter;
 import java.io.IOException;
@@ -12,14 +13,14 @@ import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.StandardOpenOption;
 import java.util.HashMap;
-import java.util.LinkedHashMap;
 import java.util.Map;
 
 public class GraphMLFileWriter {
 
     String filename;
+    SimpleWeightedGraph graph;
     GraphWithMapData data;
-
+    Map<String, Attribute> graphAttributes;
 
     public GraphMLFileWriter(String filename, GraphWithMapData data) {
         if(!filename.matches(".*\\.graphml")){
@@ -27,52 +28,61 @@ public class GraphMLFileWriter {
         }
         this.filename = filename;
         this.data = data;
+        this.graph = data.getGraph();
+        graphAttributes = createGraphAttributes();
     }
 
-//    public void writeGraphToFile() {
+    public GraphMLFileWriter(String filename, SimpleWeightedGraph<Vertex, DefaultWeightedEdge> graph) {
-//        try(BufferedWriter writer = Files.newBufferedWriter(Path.of(filename), StandardOpenOption.CREATE_NEW);
+        if(!filename.matches(".*\\.graphml")){
-//        ){
+            filename = filename + ".graphml";
-//            GraphMLExporter<SimpleWeightedGraph, BufferedWriter> exporter = new GraphMLExporter<>();
+        }
-//            exporter.exportGraph(graph, writer);
+        this.filename = filename;
-//        } catch(IOException ex){
+        this.graph = graph;
-//            System.out.println("Could not make new file named "+filename);
+    }
-//            System.err.println(ex);
+
-//        }
+    private Map<String, Attribute> createGraphAttributes(){
-//    }
+        Map<String, Attribute> ga = new HashMap<>();
+        //Sample plate filename
+        ga.put("sample plate filename", DefaultAttribute.createAttribute(data.getSourceFilename()));
+        // Number of wells
+        ga.put("well count", DefaultAttribute.createAttribute(data.getNumWells().toString()));
+        //Well populations
+        Integer[] wellPopulations = data.getWellPopulations();
+        StringBuilder populationsStringBuilder = new StringBuilder();
+        populationsStringBuilder.append(wellPopulations[0].toString());
+        for(int i = 1; i < wellPopulations.length; i++){
+            populationsStringBuilder.append(", ");
+            populationsStringBuilder.append(wellPopulations[i].toString());
+        }
+        String wellPopulationsString = populationsStringBuilder.toString();
+        ga.put("well populations", DefaultAttribute.createAttribute(wellPopulationsString));
+        return ga;
+    }
 
     public void writeGraphToFile() {
-        SimpleWeightedGraph graph = data.getGraph();
-        Map<Integer, Integer> vertexToAlphaMap = data.getPlateVtoAMap();
-        Map<Integer, Integer> vertexToBetaMap = data.getPlateVtoBMap();
-        Map<Integer, Integer> alphaOccs = data.getAlphaWellCounts();
-        Map<Integer, Integer> betaOccs = data.getBetaWellCounts();
         try(BufferedWriter writer = Files.newBufferedWriter(Path.of(filename), StandardOpenOption.CREATE_NEW);
         ){
             //create exporter. Let the vertex labels be the unique ids for the vertices
-            GraphMLExporter<Integer, SimpleWeightedGraph<Vertex, DefaultWeightedEdge>> exporter = new GraphMLExporter<>(v -> v.toString());
+            GraphMLExporter<Vertex, SimpleWeightedGraph<Vertex, DefaultWeightedEdge>> exporter = new GraphMLExporter<>(v -> v.getVertexLabel().toString());
             //set to export weights
             exporter.setExportEdgeWeights(true);
+            //Set graph attributes
+            exporter.setGraphAttributeProvider( () -> graphAttributes);
             //set type, sequence, and occupancy attributes for each vertex
             exporter.setVertexAttributeProvider( v -> {
                 Map<String, Attribute> attributes = new HashMap<>();
-                if(vertexToAlphaMap.containsKey(v)) {
+                attributes.put("type", DefaultAttribute.createAttribute(v.getType().name()));
-                    attributes.put("type", DefaultAttribute.createAttribute("CDR3 Alpha"));
+                attributes.put("sequence", DefaultAttribute.createAttribute(v.getSequence()));
-                    attributes.put("sequence", DefaultAttribute.createAttribute(vertexToAlphaMap.get(v)));
+                attributes.put("occupancy", DefaultAttribute.createAttribute(v.getOccupancy()));
-                    attributes.put("occupancy", DefaultAttribute.createAttribute(
-                            alphaOccs.get(vertexToAlphaMap.get(v))));
-                }
-                else if(vertexToBetaMap.containsKey(v)) {
-                    attributes.put("type", DefaultAttribute.createAttribute("CDR3 Beta"));
-                    attributes.put("sequence", DefaultAttribute.createAttribute(vertexToBetaMap.get(v)));
-                    attributes.put("occupancy", DefaultAttribute.createAttribute(
-                            betaOccs.get(vertexToBetaMap.get(v))));
-                }
                 return attributes;
             });
             //register the attributes
-            exporter.registerAttribute("type", GraphMLExporter.AttributeCategory.NODE, AttributeType.STRING);
+            for(String s : graphAttributes.keySet()) {
-            exporter.registerAttribute("sequence", GraphMLExporter.AttributeCategory.NODE, AttributeType.STRING);
+                exporter.registerAttribute(s, AttributeCategory.GRAPH, AttributeType.STRING);
-            exporter.registerAttribute("occupancy", GraphMLExporter.AttributeCategory.NODE, AttributeType.STRING);
+            }
+            exporter.registerAttribute("type", AttributeCategory.NODE, AttributeType.STRING);
+            exporter.registerAttribute("sequence", AttributeCategory.NODE, AttributeType.STRING);
+            exporter.registerAttribute("occupancy", AttributeCategory.NODE, AttributeType.STRING);
             //export the graph
             exporter.exportGraph(graph, writer);
         } catch(IOException ex){
@@ -81,4 +91,3 @@ public class GraphMLFileWriter {
         }
     }
 }
-

src/main/java/GraphModificationFunctions.java

@@ -2,23 +2,25 @@ import org.jgrapht.graph.DefaultWeightedEdge;
 import org.jgrapht.graph.SimpleWeightedGraph;
 
 import java.util.ArrayList;
+import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 
 public interface GraphModificationFunctions {
 
-    //remove over- and under-weight edges
+    //remove over- and under-weight edges, return removed edges
-    static List<Integer[]> filterByOverlapThresholds(SimpleWeightedGraph<Integer, DefaultWeightedEdge> graph,
+    static Map<Vertex[], Integer> filterByOverlapThresholds(SimpleWeightedGraph<Vertex, DefaultWeightedEdge> graph,
                                                             int low, int high, boolean saveEdges) {
-        List<Integer[]> removedEdges = new ArrayList<>();
+        Map<Vertex[], Integer> removedEdges = new HashMap<>();
+        //List<Integer[]> removedEdges = new ArrayList<>();
         for (DefaultWeightedEdge e : graph.edgeSet()) {
             if ((graph.getEdgeWeight(e) > high) || (graph.getEdgeWeight(e) < low)) {
                 if(saveEdges) {
-                    Integer source = graph.getEdgeSource(e);
+                    Vertex source = graph.getEdgeSource(e);
-                    Integer target = graph.getEdgeTarget(e);
+                    Vertex target = graph.getEdgeTarget(e);
                     Integer weight = (int) graph.getEdgeWeight(e);
-                    Integer[] edge = {source, target, weight};
+                    Vertex[] edge = {source, target};
-                    removedEdges.add(edge);
+                    removedEdges.put(edge, weight);
                 }
                 else {
                     graph.setEdgeWeight(e, 0.0);
@@ -26,31 +28,27 @@ public interface GraphModificationFunctions {
             }
         }
         if(saveEdges) {
-            for (Integer[] edge : removedEdges) {
+            for (Vertex[] edge : removedEdges.keySet()) {
                 graph.removeEdge(edge[0], edge[1]);
             }
         }
         return removedEdges;
     }
 
-    //Remove edges for pairs with large occupancy discrepancy
+    //Remove edges for pairs with large occupancy discrepancy, return removed edges
-    static List<Integer[]> filterByRelativeOccupancy(SimpleWeightedGraph<Integer, DefaultWeightedEdge> graph,
+    static Map<Vertex[], Integer> filterByRelativeOccupancy(SimpleWeightedGraph<Vertex, DefaultWeightedEdge> graph,
-                                                  Map<Integer, Integer> alphaWellCounts,
-                                                  Map<Integer, Integer> betaWellCounts,
-                                                  Map<Integer, Integer> plateVtoAMap,
-                                                  Map<Integer, Integer> plateVtoBMap,
                                                   Integer maxOccupancyDifference, boolean saveEdges) {
-        List<Integer[]> removedEdges = new ArrayList<>();
+        Map<Vertex[], Integer> removedEdges = new HashMap<>();
         for (DefaultWeightedEdge e : graph.edgeSet()) {
-            Integer alphaOcc = alphaWellCounts.get(plateVtoAMap.get(graph.getEdgeSource(e)));
+            Integer alphaOcc = graph.getEdgeSource(e).getOccupancy();
-            Integer betaOcc = betaWellCounts.get(plateVtoBMap.get(graph.getEdgeTarget(e)));
+            Integer betaOcc = graph.getEdgeTarget(e).getOccupancy();
             if (Math.abs(alphaOcc - betaOcc) >= maxOccupancyDifference) {
                 if (saveEdges) {
-                    Integer source = graph.getEdgeSource(e);
+                    Vertex source = graph.getEdgeSource(e);
-                    Integer target = graph.getEdgeTarget(e);
+                    Vertex target = graph.getEdgeTarget(e);
                     Integer weight = (int) graph.getEdgeWeight(e);
-                    Integer[] edge = {source, target, weight};
+                    Vertex[] edge = {source, target};
-                    removedEdges.add(edge);
+                    removedEdges.put(edge, weight);
                 }
                 else {
                     graph.setEdgeWeight(e, 0.0);
@@ -58,34 +56,30 @@ public interface GraphModificationFunctions {
             }
         }
         if(saveEdges) {
-            for (Integer[] edge : removedEdges) {
+            for (Vertex[] edge : removedEdges.keySet()) {
                 graph.removeEdge(edge[0], edge[1]);
             }
         }
         return removedEdges;
     }
 
-    //Remove edges for pairs where overlap size is significantly lower than the well occupancy
+    //Remove edges for pairs where overlap size is significantly lower than the well occupancy, return removed edges
-    static List<Integer[]> filterByOverlapPercent(SimpleWeightedGraph<Integer, DefaultWeightedEdge> graph,
+    static Map<Vertex[], Integer> filterByOverlapPercent(SimpleWeightedGraph<Vertex, DefaultWeightedEdge> graph,
-                                                         Map<Integer, Integer> alphaWellCounts,
-                                                         Map<Integer, Integer> betaWellCounts,
-                                                         Map<Integer, Integer> plateVtoAMap,
-                                                         Map<Integer, Integer> plateVtoBMap,
                                                          Integer minOverlapPercent,
                                                          boolean saveEdges) {
-        List<Integer[]> removedEdges = new ArrayList<>();
+        Map<Vertex[], Integer> removedEdges = new HashMap<>();
         for (DefaultWeightedEdge e : graph.edgeSet()) {
-            Integer alphaOcc = alphaWellCounts.get(plateVtoAMap.get(graph.getEdgeSource(e)));
+            Integer alphaOcc = graph.getEdgeSource(e).getOccupancy();
-            Integer betaOcc = betaWellCounts.get(plateVtoBMap.get(graph.getEdgeTarget(e)));
+            Integer betaOcc = graph.getEdgeTarget(e).getOccupancy();
             double weight = graph.getEdgeWeight(e);
             double min = minOverlapPercent / 100.0;
             if ((weight / alphaOcc < min) || (weight / betaOcc < min)) {
-                if(saveEdges) {
+                if (saveEdges) {
-                    Integer source = graph.getEdgeSource(e);
+                    Vertex source = graph.getEdgeSource(e);
-                    Integer target = graph.getEdgeTarget(e);
+                    Vertex target = graph.getEdgeTarget(e);
                     Integer intWeight = (int) graph.getEdgeWeight(e);
-                    Integer[] edge = {source, target, intWeight};
+                    Vertex[] edge = {source, target};
-                    removedEdges.add(edge);
+                    removedEdges.put(edge, intWeight);
                 }
                 else {
                     graph.setEdgeWeight(e, 0.0);
@@ -93,18 +87,18 @@ public interface GraphModificationFunctions {
             }
         }
         if(saveEdges) {
-            for (Integer[] edge : removedEdges) {
+            for (Vertex[] edge : removedEdges.keySet()) {
                 graph.removeEdge(edge[0], edge[1]);
             }
         }
         return removedEdges;
     }
 
-    static void addRemovedEdges(SimpleWeightedGraph<Integer, DefaultWeightedEdge> graph,
+    static void addRemovedEdges(SimpleWeightedGraph<Vertex, DefaultWeightedEdge> graph,
-                                       List<Integer[]> removedEdges) {
+                                Map<Vertex[], Integer> removedEdges) {
-        for (Integer[] edge : removedEdges) {
+        for (Vertex[] edge : removedEdges.keySet()) {
             DefaultWeightedEdge e = graph.addEdge(edge[0], edge[1]);
-            graph.setEdgeWeight(e, (double) edge[2]);
+            graph.setEdgeWeight(e, removedEdges.get(edge));
         }
     }
 

src/main/java/GraphWithMapData.java

@@ -6,6 +6,7 @@ import java.util.Map;
 //Can't just write the graph, because I need the occupancy data too.
 //Makes most sense to serialize object and write that to a file.
 //Which means there's no reason to split map data and graph data up.
+//Custom vertex class means a lot of the map data can now be encoded in the graph itself
 public class GraphWithMapData implements java.io.Serializable {
 
     private String sourceFilename;
@@ -15,32 +16,33 @@ public class GraphWithMapData implements java.io.Serializable {
     private Integer alphaCount;
     private Integer betaCount;
     private final Map<Integer, Integer> distCellsMapAlphaKey;
-    private final Map<Integer, Integer> plateVtoAMap;
+//    private final Map<Integer, Integer> plateVtoAMap;
-    private final Map<Integer, Integer> plateVtoBMap;
+//    private final Map<Integer, Integer> plateVtoBMap;
-    private final Map<Integer, Integer> plateAtoVMap;
+//    private final Map<Integer, Integer> plateAtoVMap;
-    private final Map<Integer, Integer> plateBtoVMap;
+//    private final Map<Integer, Integer> plateBtoVMap;
-    private final Map<Integer, Integer> alphaWellCounts;
+//    private final Map<Integer, Integer> alphaWellCounts;
-    private final Map<Integer, Integer> betaWellCounts;
+//    private final Map<Integer, Integer> betaWellCounts;
     private final Duration time;
 
     public GraphWithMapData(SimpleWeightedGraph graph, Integer numWells, Integer[] wellConcentrations,
-                            Integer alphaCount, Integer betaCount,
+                            Map<Integer, Integer> distCellsMapAlphaKey, Integer alphaCount, Integer betaCount, Duration time){
-                            Map<Integer, Integer> distCellsMapAlphaKey, Map<Integer, Integer> plateVtoAMap,
+
-                            Map<Integer,Integer> plateVtoBMap, Map<Integer, Integer> plateAtoVMap,
+//                            Map<Integer, Integer> plateVtoAMap,
-                            Map<Integer, Integer> plateBtoVMap, Map<Integer, Integer> alphaWellCounts,
+//                            Map<Integer,Integer> plateVtoBMap, Map<Integer, Integer> plateAtoVMap,
-                            Map<Integer, Integer> betaWellCounts, Duration time) {
+//                            Map<Integer, Integer> plateBtoVMap, Map<Integer, Integer> alphaWellCounts,
+//                            Map<Integer, Integer> betaWellCounts,) {
         this.graph = graph;
         this.numWells = numWells;
         this.wellPopulations = wellConcentrations;
         this.alphaCount = alphaCount;
         this.betaCount = betaCount;
         this.distCellsMapAlphaKey = distCellsMapAlphaKey;
-        this.plateVtoAMap = plateVtoAMap;
+//        this.plateVtoAMap = plateVtoAMap;
-        this.plateVtoBMap = plateVtoBMap;
+//        this.plateVtoBMap = plateVtoBMap;
-        this.plateAtoVMap = plateAtoVMap;
+//        this.plateAtoVMap = plateAtoVMap;
-        this.plateBtoVMap = plateBtoVMap;
+//        this.plateBtoVMap = plateBtoVMap;
-        this.alphaWellCounts = alphaWellCounts;
+//        this.alphaWellCounts = alphaWellCounts;
-        this.betaWellCounts = betaWellCounts;
+//        this.betaWellCounts = betaWellCounts;
         this.time = time;
     }
 
@@ -68,29 +70,29 @@ public class GraphWithMapData implements java.io.Serializable {
         return distCellsMapAlphaKey;
     }
 
-    public Map<Integer, Integer> getPlateVtoAMap() {
+//    public Map<Integer, Integer> getPlateVtoAMap() {
-        return plateVtoAMap;
+//        return plateVtoAMap;
-    }
+//    }
-
+//
-    public Map<Integer, Integer> getPlateVtoBMap() {
+//    public Map<Integer, Integer> getPlateVtoBMap() {
-        return plateVtoBMap;
+//        return plateVtoBMap;
-    }
+//    }
-
+//
-    public Map<Integer, Integer> getPlateAtoVMap() {
+//    public Map<Integer, Integer> getPlateAtoVMap() {
-        return plateAtoVMap;
+//        return plateAtoVMap;
-    }
+//    }
-
+//
-    public Map<Integer, Integer> getPlateBtoVMap() {
+//    public Map<Integer, Integer> getPlateBtoVMap() {
-        return plateBtoVMap;
+//        return plateBtoVMap;
-    }
+//    }
-
+//
-    public Map<Integer, Integer> getAlphaWellCounts() {
+//    public Map<Integer, Integer> getAlphaWellCounts() {
-        return alphaWellCounts;
+//        return alphaWellCounts;
-    }
+//    }
-
+//
-    public Map<Integer, Integer> getBetaWellCounts() {
+//    public Map<Integer, Integer> getBetaWellCounts() {
-        return betaWellCounts;
+//        return betaWellCounts;
-    }
+//    }
 
     public Duration getTime() {
         return time;

src/main/java/HeapType.java

@@ -0,0 +1,4 @@
+public enum HeapType {
+    FIBONACCI,
+    PAIRING
+}

src/main/java/InteractiveInterface.java

@@ -258,7 +258,7 @@ public class InteractiveInterface {
             cellFile = sc.next();
             System.out.print("\nPlease enter name of an existing sample plate file: ");
             plateFile = sc.next();
-            System.out.println("\nThe graph and occupancy data will be written to a serialized binary file.");
+            System.out.println("\nThe graph and occupancy data will be written to a file.");
             System.out.print("Please enter a name for the output file: ");
             filename = sc.next();
         } catch (InputMismatchException ex) {
@@ -504,7 +504,7 @@ public class InteractiveInterface {
             System.out.println("2) Turn " + getOnOff(!BiGpairSEQ.cachePlate()) + " plate file caching");
             System.out.println("3) Turn " + getOnOff(!BiGpairSEQ.cacheGraph()) + " graph/data file caching");
             System.out.println("4) Turn " + getOnOff(!BiGpairSEQ.outputBinary()) + " serialized binary graph output");
-            System.out.println("5) Turn " + getOnOff(!BiGpairSEQ.outputGraphML()) + " GraphML graph output");
+            System.out.println("5) Turn " + getOnOff(!BiGpairSEQ.outputGraphML()) + " GraphML graph output (for data portability to other programs)");
             System.out.println("6) Maximum weight matching algorithm options");
             System.out.println("0) Return to main menu");
             try {
@@ -570,6 +570,8 @@ public class InteractiveInterface {
     }
 
     private static void acknowledge(){
+        System.out.println("BiGpairSEQ_Sim " + BiGpairSEQ.getVersion());
+        System.out.println();
         System.out.println("This program simulates BiGpairSEQ, a graph theory based adaptation");
         System.out.println("of the pairSEQ algorithm for pairing T cell receptor sequences.");
         System.out.println();

src/main/java/Plate.java

@@ -158,9 +158,9 @@ public class Plate {
     //returns a map of the counts of the sequence at cell index sIndex, in a range of wells
     public Map<Integer, Integer> assayWellsSequenceS(int start, int end, int... sIndices) {
         Map<Integer,Integer> assay = new HashMap<>();
-        for(int pIndex: sIndices){
+        for(int sIndex: sIndices){
             for(int i = start; i < end; i++){
-                countSequences(assay, wells.get(i), pIndex);
+                countSequences(assay, wells.get(i), sIndex);
             }
         }
         return assay;
@@ -169,6 +169,7 @@ public class Plate {
     private void countSequences(Map<Integer, Integer> wellMap, List<Integer[]> well, int... sIndices) {
         for(Integer[] cell : well) {
             for(int sIndex: sIndices){
+                //skip dropout sequences, which have value -1
                 if(cell[sIndex] != -1){
                     wellMap.merge(cell[sIndex], 1, (oldValue, newValue) -> oldValue + newValue);
                 }

src/main/java/SequenceType.java

@@ -0,0 +1,8 @@
+//enum for tagging types of sequences
+//Listed in order that they appear in a cell array, so ordinal() method will return correct index
+public enum SequenceType {
+    CDR3_ALPHA,
+    CDR3_BETA,
+    CDR1_ALPHA,
+    CDR1_BETA
+}

src/main/java/Simulator.java

@@ -18,17 +18,17 @@ import static java.lang.Float.*;
 
 //NOTE: "sequence" in method and variable names refers to a peptide sequence from a simulated T cell
 public class Simulator implements GraphModificationFunctions {
-    private static final int cdr3AlphaIndex = 0;
-    private static final int cdr3BetaIndex = 1;
-    private static final int cdr1AlphaIndex = 2;
-    private static final int cdr1BetaIndex = 3;
 
-    //Make the graph needed for matching CDR3s
+
+    //Make the graph needed for matching sequences.
+    //sourceVertexIndices and targetVertexIndices are indices within the cell to use as for the two sets of vertices
+    //in the bipartite graph. "Source" and "target" are JGraphT terms for the two vertices an edge touches,
+    //even if not directed.
     public static GraphWithMapData makeGraph(CellSample cellSample, Plate samplePlate, boolean verbose) {
         Instant start = Instant.now();
         List<Integer[]> distinctCells = cellSample.getCells();
-        int[] alphaIndex = {cdr3AlphaIndex};
+        int[] alphaIndices = {SequenceType.CDR3_ALPHA.ordinal()};
-        int[] betaIndex = {cdr3BetaIndex};
+        int[] betaIndices = {SequenceType.CDR3_BETA.ordinal()};
 
         int numWells = samplePlate.getSize();
 
@@ -38,14 +38,16 @@ public class Simulator implements GraphModificationFunctions {
         if(verbose){System.out.println("Cell maps made");}
 
         if(verbose){System.out.println("Making well maps");}
-        Map<Integer, Integer> allAlphas = samplePlate.assayWellsSequenceS(alphaIndex);
+
-        Map<Integer, Integer> allBetas = samplePlate.assayWellsSequenceS(betaIndex);
+        Map<Integer, Integer> allAlphas = samplePlate.assayWellsSequenceS(alphaIndices);
+        Map<Integer, Integer> allBetas = samplePlate.assayWellsSequenceS(betaIndices);
         int alphaCount = allAlphas.size();
         if(verbose){System.out.println("All alphas count: " + alphaCount);}
         int betaCount = allBetas.size();
         if(verbose){System.out.println("All betas count: " + betaCount);}
         if(verbose){System.out.println("Well maps made");}
 
+        //ideally we wouldn't do any graph pre-filtering. But sequences present in all wells add a huge number of edges to the graph and don't carry any signal value
         if(verbose){System.out.println("Removing sequences present in all wells.");}
         filterByOccupancyThresholds(allAlphas, 1, numWells - 1);
         filterByOccupancyThresholds(allBetas, 1, numWells - 1);
@@ -78,29 +80,46 @@ public class Simulator implements GraphModificationFunctions {
         //(technically this is only 1/4 of an adjacency matrix, but that's all you need
         //for a bipartite graph, and all the SimpleWeightedBipartiteGraphMatrixGenerator class expects.)
         if(verbose){System.out.println("Creating adjacency matrix");}
-        //Count how many wells each alpha appears in
+        //Count how many wells each alpha sequence appears in
         Map<Integer, Integer> alphaWellCounts = new HashMap<>();
-        //count how many wells each beta appears in
+        //count how many wells each beta sequence appears in
         Map<Integer, Integer> betaWellCounts = new HashMap<>();
         //the adjacency matrix to be used by the graph generator
         double[][] weights = new double[plateVtoAMap.size()][plateVtoBMap.size()];
         countSequencesAndFillMatrix(samplePlate, allAlphas, allBetas, plateAtoVMap,
-                plateBtoVMap, alphaIndex, betaIndex, alphaWellCounts, betaWellCounts, weights);
+                plateBtoVMap, alphaIndices, betaIndices, alphaWellCounts, betaWellCounts, weights);
         if(verbose){System.out.println("Matrix created");}
 
         //create bipartite graph
         if(verbose){System.out.println("Creating graph");}
         //the graph object
-        SimpleWeightedGraph<Integer, DefaultWeightedEdge> graph =
+        SimpleWeightedGraph<Vertex, DefaultWeightedEdge> graph =
                 new SimpleWeightedGraph<>(DefaultWeightedEdge.class);
         //the graph generator
         SimpleWeightedBipartiteGraphMatrixGenerator graphGenerator = new SimpleWeightedBipartiteGraphMatrixGenerator();
         //the list of alpha vertices
-        List<Integer> alphaVertices = new ArrayList<>(plateVtoAMap.keySet()); //This will work because LinkedHashMap preserves order of entry
+        //List<Integer> alphaVertices = new ArrayList<>(plateVtoAMap.keySet()); //This will work because LinkedHashMap preserves order of entry
+        List<Vertex> alphaVertices = new ArrayList<>();
+        //start with map of all alphas mapped to vertex values, get occupancy from the alphaWellCounts map
+        for (Integer seq : plateAtoVMap.keySet()) {
+            Vertex alphaVertex = new Vertex(SequenceType.CDR3_ALPHA, seq, alphaWellCounts.get(seq), plateAtoVMap.get(seq));
+            alphaVertices.add(alphaVertex);
+        }
+        //Sort to make sure the order of vertices in list matches the order of the adjacency matrix
+        Collections.sort(alphaVertices);
+        //Add ordered list of vertices to the graph
         graphGenerator.first(alphaVertices);
         //the list of beta vertices
-        List<Integer> betaVertices = new ArrayList<>(plateVtoBMap.keySet());
+        //List<Integer> betaVertices = new ArrayList<>(plateVtoBMap.keySet());//This will work because LinkedHashMap preserves order of entry
-        graphGenerator.second(betaVertices); //This will work because LinkedHashMap preserves order of entry
+        List<Vertex> betaVertices = new ArrayList<>();
+        for (Integer seq : plateBtoVMap.keySet()) {
+            Vertex betaVertex = new Vertex(SequenceType.CDR3_BETA, seq, betaWellCounts.get(seq), plateBtoVMap.get(seq));
+            betaVertices.add(betaVertex);
+        }
+        //Sort to make sure the order of vertices in list matches the order of the adjacency matrix
+        Collections.sort(betaVertices);
+        //Add ordered list of vertices to the graph
+        graphGenerator.second(betaVertices);
         //use adjacency matrix of weight created previously
         graphGenerator.weights(weights);
         graphGenerator.generateGraph(graph);
@@ -110,9 +129,7 @@ public class Simulator implements GraphModificationFunctions {
         Duration time = Duration.between(start, stop);
 
         //create GraphWithMapData object
-        GraphWithMapData output = new GraphWithMapData(graph, numWells, samplePlate.getPopulations(), alphaCount, betaCount,
+        GraphWithMapData output = new GraphWithMapData(graph, numWells, samplePlate.getPopulations(), distCellsMapAlphaKey, alphaCount, betaCount, time);
-                distCellsMapAlphaKey, plateVtoAMap, plateVtoBMap, plateAtoVMap,
-                plateBtoVMap, alphaWellCounts, betaWellCounts, time);
         //Set source file name in graph to name of sample plate
         output.setSourceFilename(samplePlate.getFilename());
         //return GraphWithMapData object
@@ -124,61 +141,67 @@ public class Simulator implements GraphModificationFunctions {
                                             Integer highThreshold, Integer maxOccupancyDifference,
                                             Integer minOverlapPercent, boolean verbose) {
         Instant start = Instant.now();
-        List<Integer[]> removedEdges = new ArrayList<>();
+        SimpleWeightedGraph<Vertex, DefaultWeightedEdge> graph = data.getGraph();
+        Map<Vertex[], Integer> removedEdges = new HashMap<>();
         boolean saveEdges = BiGpairSEQ.cacheGraph();
         int numWells = data.getNumWells();
-        Integer alphaCount = data.getAlphaCount();
+        //Integer alphaCount = data.getAlphaCount();
-        Integer betaCount = data.getBetaCount();
+        //Integer betaCount = data.getBetaCount();
         Map<Integer, Integer> distCellsMapAlphaKey = data.getDistCellsMapAlphaKey();
-        Map<Integer, Integer> plateVtoAMap = data.getPlateVtoAMap();
+        Set<Vertex> alphas = new HashSet<>();
-        Map<Integer, Integer> plateVtoBMap = data.getPlateVtoBMap();
+        Set<Vertex> betas = new HashSet<>();
-        Map<Integer, Integer> alphaWellCounts = data.getAlphaWellCounts();
+        for(Vertex v: graph.vertexSet()) {
-        Map<Integer, Integer> betaWellCounts = data.getBetaWellCounts();
+            if (SequenceType.CDR3_ALPHA.equals(v.getType())){
-        SimpleWeightedGraph<Integer, DefaultWeightedEdge> graph = data.getGraph();
+                alphas.add(v);
+            }
+            else {
+                betas.add(v);
+            }
+        }
+        Integer graphAlphaCount = alphas.size();
+        Integer graphBetaCount = betas.size();
 
         //remove edges with weights outside given overlap thresholds, add those to removed edge list
         if(verbose){System.out.println("Eliminating edges with weights outside overlap threshold values");}
-        removedEdges.addAll(GraphModificationFunctions.filterByOverlapThresholds(graph, lowThreshold, highThreshold, saveEdges));
+        removedEdges.putAll(GraphModificationFunctions.filterByOverlapThresholds(graph, lowThreshold, highThreshold, saveEdges));
         if(verbose){System.out.println("Over- and under-weight edges removed");}
 
         //remove edges between vertices with too small an overlap size, add those to removed edge list
         if(verbose){System.out.println("Eliminating edges with weights less than " + minOverlapPercent.toString() +
                 " percent of vertex occupancy value.");}
-        removedEdges.addAll(GraphModificationFunctions.filterByOverlapPercent(graph, alphaWellCounts, betaWellCounts,
+        removedEdges.putAll(GraphModificationFunctions.filterByOverlapPercent(graph, minOverlapPercent, saveEdges));
-                plateVtoAMap, plateVtoBMap, minOverlapPercent, saveEdges));
         if(verbose){System.out.println("Edges with weights too far below a vertex occupancy value removed");}
 
         //Filter by relative occupancy
         if(verbose){System.out.println("Eliminating edges between vertices with occupancy difference > "
                 + maxOccupancyDifference);}
-        removedEdges.addAll(GraphModificationFunctions.filterByRelativeOccupancy(graph, alphaWellCounts, betaWellCounts,
+        removedEdges.putAll(GraphModificationFunctions.filterByRelativeOccupancy(graph, maxOccupancyDifference, saveEdges));
-                plateVtoAMap, plateVtoBMap, maxOccupancyDifference, saveEdges));
         if(verbose){System.out.println("Edges between vertices of with excessively different occupancy values " +
                 "removed");}
 
-        //Find Maximum Weighted Matching
+        //Find Maximum Weight Matching
         //using jheaps library class PairingHeap for improved efficiency
-        if(verbose){System.out.println("Finding maximum weighted matching");}
+        if(verbose){System.out.println("Finding maximum weight matching");}
         MaximumWeightBipartiteMatching maxWeightMatching;
         //Use correct heap type for priority queue
         String heapType = BiGpairSEQ.getPriorityQueueHeapType();
         switch (heapType) {
             case "PAIRING" -> {
                 maxWeightMatching = new MaximumWeightBipartiteMatching(graph,
-                        plateVtoAMap.keySet(),
+                        alphas,
-                        plateVtoBMap.keySet(),
+                        betas,
                         i -> new PairingHeap(Comparator.naturalOrder()));
             }
             case "FIBONACCI" -> {
                 maxWeightMatching = new MaximumWeightBipartiteMatching(graph,
-                        plateVtoAMap.keySet(),
+                        alphas,
-                        plateVtoBMap.keySet(),
+                        betas,
                         i -> new FibonacciHeap(Comparator.naturalOrder()));
             }
             default -> {
                 maxWeightMatching = new MaximumWeightBipartiteMatching(graph,
-                        plateVtoAMap.keySet(),
+                        alphas,
-                        plateVtoBMap.keySet());
+                        betas);
             }
         }
         //get the matching
@@ -208,11 +231,14 @@ public class Simulator implements GraphModificationFunctions {
         Map<Integer, Integer> matchMap = new HashMap<>();
         while(weightIter.hasNext()) {
             e = weightIter.next();
-            Integer source = graph.getEdgeSource(e);
+            Vertex source = graph.getEdgeSource(e);
-            Integer target = graph.getEdgeTarget(e);
+            Vertex target = graph.getEdgeTarget(e);
+            //Integer source = graph.getEdgeSource(e);
+            //Integer target = graph.getEdgeTarget(e);
             //The match map is all matches found, not just true matches!
-            matchMap.put(plateVtoAMap.get(source), plateVtoBMap.get(target));
+            matchMap.put(source.getSequence(), target.getSequence());
-            check = plateVtoBMap.get(target).equals(distCellsMapAlphaKey.get(plateVtoAMap.get(source)));
+            check = target.getSequence().equals(distCellsMapAlphaKey.get(source.getSequence()));
+            //check = plateVtoBMap.get(target).equals(distCellsMapAlphaKey.get(plateVtoAMap.get(source)));
             if(check) {
                 trueCount++;
             }
@@ -220,17 +246,19 @@ public class Simulator implements GraphModificationFunctions {
                 falseCount++;
             }
             List<String> result = new ArrayList<>();
-            result.add(plateVtoAMap.get(source).toString());
+            //alpha sequence
+            result.add(source.getSequence().toString());
             //alpha well count
-            result.add(alphaWellCounts.get(plateVtoAMap.get(source)).toString());
+            result.add(source.getOccupancy().toString());
-            result.add(plateVtoBMap.get(target).toString());
+            //beta sequence
+            result.add(target.getSequence().toString());
             //beta well count
-            result.add(betaWellCounts.get(plateVtoBMap.get(target)).toString());
+            result.add(target.getOccupancy().toString());
             //overlap count
             result.add(Double.toString(graph.getEdgeWeight(e)));
             result.add(Boolean.toString(check));
-            double pValue = Equations.pValue(numWells, alphaWellCounts.get(plateVtoAMap.get(source)),
+            double pValue = Equations.pValue(numWells, source.getOccupancy(),
-                    betaWellCounts.get(plateVtoBMap.get(target)), graph.getEdgeWeight(e));
+                    target.getOccupancy(), graph.getEdgeWeight(e));
             BigDecimal pValueTrunc = new BigDecimal(pValue, mc);
             result.add(pValueTrunc.toString());
             allResults.add(result);
@@ -238,18 +266,20 @@ public class Simulator implements GraphModificationFunctions {
 
         //Metadata comments for CSV file
         String algoType = "LEDA book with heap: " + heapType;
-        int min = Math.min(alphaCount, betaCount);
+        int min = Math.min(graphAlphaCount, graphBetaCount);
+        //matching weight
+        BigDecimal totalMatchingWeight = maxWeightMatching.getMatchingWeight();
         //rate of attempted matching
         double attemptRate = (double) (trueCount + falseCount) / min;
         BigDecimal attemptRateTrunc = new BigDecimal(attemptRate, mc);
         //rate of pairing error
         double pairingErrorRate = (double) falseCount / (trueCount + falseCount);
         BigDecimal pairingErrorRateTrunc;
-        if(pairingErrorRate == NaN || pairingErrorRate == POSITIVE_INFINITY || pairingErrorRate == NEGATIVE_INFINITY) {
+        if(Double.isFinite(pairingErrorRate)) {
-            pairingErrorRateTrunc = new BigDecimal(-1, mc);
+            pairingErrorRateTrunc = new BigDecimal(pairingErrorRate, mc);
         }
         else{
-            pairingErrorRateTrunc = new BigDecimal(pairingErrorRate, mc);
+            pairingErrorRateTrunc = new BigDecimal(-1, mc);
         }
         //get list of well populations
         Integer[] wellPopulations = data.getWellPopulations();
@@ -269,9 +299,12 @@ public class Simulator implements GraphModificationFunctions {
         metadata.put("sample plate filename", data.getSourceFilename());
         metadata.put("graph filename", dataFilename);
         metadata.put("algorithm type", algoType);
+        metadata.put("matching weight", totalMatchingWeight.toString());
         metadata.put("well populations", wellPopulationsString);
-        metadata.put("total alphas found", alphaCount.toString());
+        metadata.put("total alphas on plate", data.getAlphaCount().toString());
-        metadata.put("total betas found", betaCount.toString());
+        metadata.put("total betas on plate", data.getBetaCount().toString());
+        metadata.put("alphas in graph (after pre-filtering)", graphAlphaCount.toString());
+        metadata.put("betas in graph (after pre-filtering)", graphBetaCount.toString());
         metadata.put("high overlap threshold", highThreshold.toString());
         metadata.put("low overlap threshold", lowThreshold.toString());
         metadata.put("minimum overlap percent", minOverlapPercent.toString());

src/main/java/Vertex.java

@@ -1,23 +1,97 @@
+import java.io.Serializable;
 
+public class Vertex implements Serializable, Comparable<Vertex> {
+    private  SequenceType type;
+    private  Integer vertexLabel;
+    private  Integer sequence;
+    private  Integer occupancy;
 
-public class Vertex {
+    public Vertex(Integer vertexLabel) {
-    private final Integer vertexLabel;
+        this.vertexLabel = vertexLabel;
-    private final Integer sequence;
+    }
-    private final Integer occupancy;
+    public Vertex(String vertexLabel) {
+        this.vertexLabel = Integer.parseInt((vertexLabel));
+    }
 
-    public Vertex(Integer vertexLabel, Integer sequence, Integer occupancy) {
+    public Vertex(SequenceType type, Integer sequence, Integer occupancy, Integer vertexLabel) {
+        this.type = type;
         this.vertexLabel = vertexLabel;
         this.sequence = sequence;
         this.occupancy = occupancy;
     }
 
-    public Integer getVertexLabel() { return vertexLabel; }
+
+    public SequenceType getType() {
+        return type;
+    }
+
+    public void setType(String type) {
+        this.type = SequenceType.valueOf(type);
+    }
+
+    public Integer getVertexLabel() {
+        return vertexLabel;
+    }
+
+    public void setVertexLabel(String label) {
+        this.vertexLabel = Integer.parseInt(label);
+    }
 
     public Integer getSequence() {
+
         return sequence;
     }
 
+    public void setSequence(String sequence) {
+        this.sequence = Integer.parseInt(sequence);
+    }
+
     public Integer getOccupancy() {
         return occupancy;
     }
+
+    public void setOccupancy(String occupancy) {
+        this.occupancy = Integer.parseInt(occupancy);
+    }
+
+    @Override //adapted from JGraphT example code
+    public int hashCode()
+    {
+        return (sequence == null) ? 0 : sequence.hashCode();
+    }
+
+    @Override //adapted from JGraphT example code
+    public boolean equals(Object obj)
+    {
+        if (this == obj)
+            return true;
+        if (obj == null)
+            return false;
+        if (getClass() != obj.getClass())
+            return false;
+        Vertex other = (Vertex) obj;
+        if (sequence == null) {
+            return other.sequence == null;
+        } else {
+            return sequence.equals(other.sequence);
+        }
+    }
+
+
+    @Override //adapted from JGraphT example code
+    public String toString()
+    {
+        StringBuilder sb = new StringBuilder();
+        sb.append("(").append(vertexLabel)
+                .append(", Type: ").append(type.name())
+                .append(", Sequence: ").append(sequence)
+                .append(", Occupancy: ").append(occupancy).append(")");
+        return sb.toString();
+    }
+
+    @Override
+    public int compareTo(Vertex other) {
+        return this.vertexLabel - other.getVertexLabel();
+    }
+
 }