Merge remote-tracking branch 'origin/master'

parameterized sequence indices
update TODO
2022-09-21 13:16:52 -05:00 · 2022-09-21 13:15:49 -05:00 · 2022-09-21 18:09:37 +00:00 · 2022-03-05 12:03:31 -06:00 · 2022-03-04 16:14:17 -06:00 · 2022-03-02 23:35:24 -06:00
15 changed files with 1066 additions and 523 deletions
--- a/readme.md
+++ b/readme.md
@@ -12,7 +12,7 @@ Unlike pairSEQ, which calculates p-values for every TCR alpha/beta overlap and c
 against a null distribution, BiGpairSEQ does not do any statistical calculations
 directly.
-BiGpairSEQ creates a [weightd bipartite graph](https://en.wikipedia.org/wiki/Bipartite_graph) representing the sample plate.
+BiGpairSEQ creates a [weighted bipartite graph](https://en.wikipedia.org/wiki/Bipartite_graph) representing the sample plate.
 The distinct TCRA and TCRB sequences form the two sets of vertices. Every TCRA/TCRB pair that share a well
 are connected by an edge, with the edge weight set to the number of wells in which both sequences appear.
 (Sequences present in *all* wells are filtered out prior to creating the graph, as there is no signal in their occupancy pattern.)
@@ -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.
@@ -29,17 +29,13 @@ Unfortunately, it's a fairly new algorithm, and not yet implemented by the graph
 So this program instead uses the Fibonacci heap-based algorithm of Fredman and Tarjan (1987), which has a worst-case
 runtime of **O(n (n log(n) + m))**. The algorithm is implemented as described in Melhorn and Näher (1999).
 The current version of the program uses a pairing heap instead of a Fibonacci heap for its priority queue,
 which has lower theoretical efficiency but also lower complexity overhead, and is often equivalently performant
 in practice.
 ## USAGE
 ### RUNNING THE PROGRAM
 [Download the current version of BiGpairSEQ_Sim.](https://gitea.ejsf.synology.me/efischer/BiGpairSEQ/releases)
-BiGpairSEQ_Sim is an executable .jar file. Requires Java 11 or higher. [OpenJDK 17](https://jdk.java.net/17/)
+BiGpairSEQ_Sim is an executable .jar file. Requires Java 14 or higher. [OpenJDK 17](https://jdk.java.net/17/)
 recommended.
 Run with the command:
@@ -47,13 +43,18 @@ 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`
-Once running, BiGpairSEQ_Sim has an interactive, menu-driven CLI for generating files and simulating TCR pairing. The
+There are a number of command line options, to allow the program to be used in shell scripts. For a full list,
-main menu looks like this:
+use the `-help` flag:
 `java -jar BiGpairSEQ_Sim.jar -help`
 If no command line arguments are given, BiGpairSEQ_Sim will launch with an interactive, menu-driven CLI for 
 generating files and simulating TCR pairing. The main menu looks like this:
 ```
 --------BiGPairSEQ SIMULATOR--------
@@ -65,10 +66,24 @@ Please select an option:
 2) Generate a sample plate of T cells
 3) Generate CDR3 alpha/beta occupancy data and overlap graph
 4) Simulate bipartite graph CDR3 alpha/beta matching (BiGpairSEQ)
 8) Options
 9) About/Acknowledgments
 0) Exit
 ```
 By default, the Options menu looks like this:
 ```
 --------------OPTIONS---------------
 1) Turn on cell sample file caching
 2) Turn on plate file caching
 3) Turn on graph/data file caching
 4) Turn off serialized binary graph output
 5) Turn on GraphML graph output
 6) Maximum weight matching algorithm options
 0) Return to main menu
 ```
 ### INPUT/OUTPUT
 To run the simulation, the program reads and writes 4 kinds of files:
@@ -77,19 +92,26 @@ To run the simulation, the program reads and writes 4 kinds of files:
 * Graph/Data files in binary object serialization format
 * Matching Results files in CSV format
-These files are often generated in sequence. To save file I/O time, the most recent instance of each of these four
+These files are often generated in sequence. When entering filenames, it is not necessary to include the file extension
-files either generated or read from disk is cached in program memory. This is especially important for Graph/Data files,
+(.csv or .ser). When reading or writing files, the program will automatically add the correct extension to any filename 
-which can be several gigabytes in size. Since some simulations may require running multiple, 
+without one.
 differntly-configured BiGpairSEQ matchings on the same graph, keeping the most recent graph cached drastically reduces 
 execution time. 
-Subsequent uses of the same data file won't need to be read in again until another file of that type is used or generated.
+To save file I/O time, the most recent instance of each of these four
-The program checks whether it needs to update its cached data by comparing filenames as entered by the user. On 
+files either generated or read from disk can be cached in program memory. When caching is active, subsequent uses of the 
-encountering a new filename, the program flushes its cache and reads in the new file.
+same data file won't need to be read in again until another file of that type is used or generated,
 or caching is turned off for that file type. The program checks whether it needs to update its cached data by comparing
 filenames as entered by the user. On encountering a new filename, the program flushes its cache and reads in the new file.
-When entering filenames, it is not necessary to include the file extension (.csv or .ser). When reading or
+(Note that cached Graph/Data files must be transformed back into their original state after a matching experiment, which
-writing files, the program will automatically add the correct extension to any filename without one. 
+may take some time. Whether file I/O or graph transformation takes longer for graph/data files is likely to be
 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 
 turned on in the Options menu. By default, GraphML output is OFF.
 ---
 #### Cell Sample Files
 Cell Sample files consist of any number of distinct "T cells." Every cell contains 
 four sequences: Alpha CDR3, Beta CDR3, Alpha CDR1, Beta CDR1. The sequences are represented by
@@ -107,7 +129,6 @@ Comments are preceded by `#`
 Structure:
 ---
    # Sample contains 1 unique CDR1 for every 4 unique CDR3s.
 | Alpha CDR3 | Beta CDR3 | Alpha CDR1 | Beta CDR1 |
 |---|---|---|---|
@@ -131,8 +152,11 @@ Options when making a Sample Plate file:
    * Standard deviation size 
  * Exponential
    * Lambda value
-      * *(Based on the slope of the graph in Figure 4C of the pairSEQ paper, the distribution of the original experiment was exponential with a lambda of approximately 0.6. (Howie, et al. 2015))*
+      * *(Based on the slope of the graph in Figure 4C of the pairSEQ paper, the distribution of the original experiment was approximately exponential with a lambda ~0.6. (Howie, et al. 2015))*
 * Total number of wells on the plate
 * Well populations random or fixed
  * If random, minimum and maximum population sizes
  * If fixed
    * Number of sections on plate
    * Number of T cells per well
      * per section, if more than one section
@@ -149,7 +173,6 @@ Dropout sequences are replaced with the value `-1`. Comments are preceded by `#`
 Structure:
 ---
 ```
 # Cell source file name:
 # Each row represents one well on the plate
@@ -178,14 +201,24 @@ Options for creating a Graph/Data file:
 * The Cell Sample file to use
 * The Sample Plate file to use. (This must have been generated from the selected Cell Sample file.)
-These files do not have a human-readable structure, and are not portable to other programs. (Export of graphs in a 
+These files do not have a human-readable structure, and are not portable to other programs.
-portable data format may be implemented in the future. The tricky part is encoding the necessary metadata.)
+
 *Optional GraphML output*
 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.
 ---
 #### Matching Results Files 
-Matching results files consist of the results of a BiGpairSEQ matching simulation. Making them requires a Graph and 
+Matching results files consist of the results of a BiGpairSEQ matching simulation. Making them requires a serialized
-Data file. Matching results files are in CSV format. Rows are sequence pairings with extra relevant data. Columns are pairing-specific details.
+binary Graph/Data file (.ser). (Because .graphML files are larger than .ser files, BiGpairSEQ_Sim supports .graphML
 output only. Graph/data input must use a serialized binary.)
 Matching results files are in CSV format. Rows are sequence pairings with extra relevant data. Columns are pairing-specific details.
 Metadata about the matching simulation is included as comments. Comments are preceded by `#`.
 Options when running a BiGpairSEQ simulation of CDR3 alpha/beta matching:
@@ -200,7 +233,6 @@ Options when running a BiGpairSEQ simulation of CDR3 alpha/beta matching:
 Example output:
 ---
 ```
 # Source Sample Plate file: 4MilCellsPlate.csv
 # Source Graph and Data file: 4MilCellsPlateGraph.ser
@@ -232,45 +264,101 @@ 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 weighted 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
 * Enable post-filtering instead of pre-filtering. Pre-filtering of things like singleton sequences or saturating-occupancy sequences reduces graph size, but could conceivably reduce pairing accuracy by throwing away data. While these sequences have very little signal, it would be interesting to compare unfiltered results to filtered results. This would require a much, much faster MWM algorithm, though, to handle the much larger graphs. Possible one of the linear-time approximation algorithms.
 * ~~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
+* ~~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. If so, awesome.
+  * 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 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?~~
    * Parameter implemented. Fibonacci heap the current default.
 * ~~Implement sample plates with random numbers of T cells per well.~~ DONE
  * Possible BiGpairSEQ advantage over pairSEQ: BiGpairSEQ is resilient to variations in well population sizes on a sample plate; pairSEQ is not.
    * preliminary data suggests that BiGpairSEQ behaves roughly as though the whole plate had whatever the *average* well concentration is, but that's still speculative.
 * See if there's a reasonable way to reformat Sample Plate files so that wells are columns instead of rows. 
  * ~~Problem is variable number of cells in a well~~
  * ~~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._
+    * _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.
-* Re-implement command line arguments, to enable scripting and statistical simulation studies
+* ~~Enable GraphML output in addition to serialized object binaries, for data portability~~ DONE
-* Implement sample plates with random numbers of T cells per well.
+  * ~~Custom vertex type with attribute for sequence occupancy?~~ ABANDONED
-  * Possible BiGpairSEQ advantage over pairSEQ: BiGpairSEQ is resilient to variations in well population sizes on a sample plate; pairSEQ is not.
+    * Advantage: would eliminate the need to use maps to associate vertices with sequences, which would make the code easier to understand.
-    * preliminary data suggests that BiGpairSEQ behaves roughly as though the whole plate had whatever the *average* well concentration is, but that's still speculative.
+    * Have a branch where this is implemented, but there's a bug that broke matching. Don't currently have time to fix.
-* Enable GraphML output in addition to serialized object binaries, for data portability
+* ~~Re-implement command line arguments, to enable scripting and statistical simulation studies~~ DONE
  * Custom vertex type with attribute for sequence occupancy?
 * Re-implement CDR1 matching method
 * Implement Duan and Su's maximum weight matching algorithm
    * Add controllable algorithm-type parameter?
-* Test whether pairing heap (currently used) or Fibonacci heap is more efficient for priority queue in current matching algorithm
+    * This would be fun and valuable, but probably take more time than I have for a hobby project.
-  * in theory Fibonacci heap should be more efficient, but complexity overhead may eliminate theoretical advantage
+* Implement Vose's alias method for arbitrary statistical distributions of cells
-  * Add controllable heap-type parameter?
+  * Should probably refactor to use apache commons rng for this
-
+* Use commons JCS for caching
 ## CITATIONS
@@ -283,7 +371,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 
--- a/src/main/java/BiGpairSEQ.java
+++ b/src/main/java/BiGpairSEQ.java
@@ -1,6 +1,6 @@
 import java.util.Random;
-//main class. For choosing interface type and caching file data
+//main class. For choosing interface type and holding settings
 public class BiGpairSEQ {
    private static final Random rand = new Random();
@@ -10,6 +10,13 @@ public class BiGpairSEQ {
    private static String plateFilename = null;
    private static GraphWithMapData graphInMemory = null;
    private static String graphFilename = null;
    private static boolean cacheCells = false;
    private static boolean cachePlate = false;
    private static boolean cacheGraph = false;
    private static String priorityQueueHeapType = "FIBONACCI";
    private static boolean outputBinary = true;
    private static boolean outputGraphML = false;
    private static final String version = "version 2.0";
    public static void main(String[] args) {
        if (args.length == 0) {
@@ -17,8 +24,8 @@ public class BiGpairSEQ {
        }
        else {
            //This will be uncommented when command line arguments are re-implemented.
-            //CommandLineInterface.startCLI(args);
+            CommandLineInterface.startCLI(args);
-            System.out.println("Command line arguments are still being re-implemented.");
+            //System.out.println("Command line arguments are still being re-implemented.");
        }
    }
@@ -30,66 +37,141 @@ public class BiGpairSEQ {
        return cellSampleInMemory;
    }
-    public static void setCellSampleInMemory(CellSample cellSampleInMemory) {
+    public static void setCellSampleInMemory(CellSample cellSample, String filename) {
-        BiGpairSEQ.cellSampleInMemory = cellSampleInMemory;
+        if(cellSampleInMemory != null) {
            clearCellSampleInMemory();
        }
        cellSampleInMemory = cellSample;
        cellFilename = filename;
        System.out.println("Cell sample file " + filename + " cached.");
    }
    public static void clearCellSampleInMemory() {
        cellSampleInMemory = null;
        cellFilename = null;
        System.gc();
        System.out.println("Cell sample file cache cleared.");
    }
    public static String getCellFilename() {
        return cellFilename;
    }
    public static void setCellFilename(String cellFilename) {
        BiGpairSEQ.cellFilename = cellFilename;
    }
    public static Plate getPlateInMemory() {
        return plateInMemory;
    }
-    public static void setPlateInMemory(Plate plateInMemory) {
+    public static void setPlateInMemory(Plate plate, String filename) {
-        BiGpairSEQ.plateInMemory = plateInMemory;
+        if(plateInMemory != null) {
            clearPlateInMemory();
        }
        plateInMemory = plate;
        plateFilename = filename;
        System.out.println("Sample plate file " + filename + " cached.");
    }
    public static void clearPlateInMemory() {
        plateInMemory = null;
        plateFilename = null;
        System.gc();
        System.out.println("Sample plate file cache cleared.");
    }
    public static String getPlateFilename() {
        return plateFilename;
    }
-    public static void setPlateFilename(String plateFilename) {
+
-        BiGpairSEQ.plateFilename = plateFilename;
+    public static GraphWithMapData getGraphInMemory() {return graphInMemory;
    }
-    public static GraphWithMapData getGraphInMemory() {
+    public static void setGraphInMemory(GraphWithMapData g, String filename) {
        return graphInMemory;
    }
    public static void setGraphInMemory(GraphWithMapData g) {
        if (graphInMemory != null) {
            clearGraphInMemory();
        }
        graphInMemory = g;
        graphFilename = filename;
        System.out.println("Graph and data file " + filename + " cached.");
    }
    public static void clearGraphInMemory() {
        graphInMemory = null;
        graphFilename = null;
        System.gc();
        System.out.println("Graph and data file cache cleared.");
    }
    public static String getGraphFilename() {
        return graphFilename;
    }
-    public static void setGraphFilename(String filename) {
+
-        graphFilename = filename;
+    public static boolean cacheCells() {
        return cacheCells;
    }
    public static void setCacheCells(boolean cacheCells) {
        //if not caching, clear the memory
        if(!cacheCells){
            BiGpairSEQ.clearCellSampleInMemory();
            System.out.println("Cell sample file caching: OFF.");
        }
        else {
            System.out.println("Cell sample file caching: ON.");
        }
        BiGpairSEQ.cacheCells = cacheCells;
    }
    public static boolean cachePlate() {
        return cachePlate;
    }
    public static void setCachePlate(boolean cachePlate) {
        //if not caching, clear the memory
        if(!cachePlate) {
            BiGpairSEQ.clearPlateInMemory();
            System.out.println("Sample plate file caching: OFF.");
        }
        else {
            System.out.println("Sample plate file caching: ON.");
        }
        BiGpairSEQ.cachePlate = cachePlate;
    }
    public static boolean cacheGraph() {
        return cacheGraph;
    }
    public static void setCacheGraph(boolean cacheGraph) {
        //if not caching, clear the memory
        if(!cacheGraph) {
            BiGpairSEQ.clearGraphInMemory();
            System.out.println("Graph/data file caching: OFF.");
        }
        else {
            System.out.println("Graph/data file caching: ON.");
        }
        BiGpairSEQ.cacheGraph = cacheGraph;
    }
    public static String getPriorityQueueHeapType() {
        return priorityQueueHeapType;
    }
    public static void setPairingHeap() {
        priorityQueueHeapType = "PAIRING";
    }
    public static void setFibonacciHeap() {
        priorityQueueHeapType = "FIBONACCI";
    }
    public static boolean outputBinary() {return outputBinary;}
    public static void setOutputBinary(boolean b) {outputBinary = b;}
    public static boolean outputGraphML() {return outputGraphML;}
    public static void setOutputGraphML(boolean b) {outputGraphML = b;}
    public static String getVersion() { return version; }
 }
--- a/src/main/java/CellSample.java
+++ b/src/main/java/CellSample.java
@@ -1,10 +1,37 @@
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 import java.util.stream.IntStream;
 public class CellSample {
    private List<Integer[]> cells;
    private Integer cdr1Freq;
    public CellSample(Integer numDistinctCells, Integer cdr1Freq){
        this.cdr1Freq = cdr1Freq;
        List<Integer> numbersCDR3 = new ArrayList<>();
        List<Integer> numbersCDR1 = new ArrayList<>();
        Integer numDistCDR3s = 2 * numDistinctCells + 1;
        IntStream.range(1, numDistCDR3s + 1).forEach(i -> numbersCDR3.add(i));
        IntStream.range(numDistCDR3s + 1, numDistCDR3s + 1 + (numDistCDR3s / cdr1Freq) + 1).forEach(i -> numbersCDR1.add(i));
        Collections.shuffle(numbersCDR3);
        Collections.shuffle(numbersCDR1);
        //Each cell represented by 4 values
        //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){
            Integer tmpCDR3a = numbersCDR3.get(i);
            Integer tmpCDR3b = numbersCDR3.get(i+1);
            Integer tmpCDR1a = numbersCDR1.get(i % numbersCDR1.size());
            Integer tmpCDR1b = numbersCDR1.get((i+1) % numbersCDR1.size());
            Integer[] tmp = {tmpCDR3a, tmpCDR3b, tmpCDR1a, tmpCDR1b};
            distinctCells.add(tmp);
        }
        this.cells = distinctCells;
    }
    public CellSample(List<Integer[]> cells, Integer cdr1Freq){
        this.cells = cells;
        this.cdr1Freq = cdr1Freq;
--- a/src/main/java/CommandLineInterface.java
+++ b/src/main/java/CommandLineInterface.java
@@ -1,5 +1,9 @@
 import org.apache.commons.cli.*;
 import java.io.IOException;
 import java.util.Arrays;
 import java.util.stream.Stream;
 /*
 * Class for parsing options passed to program from command line
 *
@@ -29,6 +33,8 @@ import org.apache.commons.cli.*;
 * cellfile : name of the cell sample file to use as input
 * platefile : name of the sample plate file to use as input
 * output : name of the output file
 * graphml : output a graphml file
 * binary : output a serialized binary object file
 *
 * Match flags:
 * graphFile : name of graph and data file to use as input
@@ -43,242 +49,172 @@ import org.apache.commons.cli.*;
 public class CommandLineInterface {
    public static void startCLI(String[] args) {
-        //These command line options are a big mess
+        //Options sets for the different modes
-        //Really, I don't think command line tools are expected to work in this many different modes
+        Options mainOptions = buildMainOptions();
-        //making cells, making plates, and matching are the sort of thing that UNIX philosophy would say
+        Options cellOptions = buildCellOptions();
-        //should be three separate programs.
+        Options plateOptions = buildPlateOptions();
-        //There might be a way to do it with option parameters?
+        Options graphOptions = buildGraphOptions();
-
+        Options matchOptions = buildMatchCDR3options();
        //main options set
        Options mainOptions = new Options();
        Option makeCells = Option.builder("cells")
                .longOpt("make-cells")
                .desc("Makes a file of distinct cells")
                .build();
        Option makePlate = Option.builder("plates")
                .longOpt("make-plates")
                .desc("Makes a sample plate file")
                .build();
        Option makeGraph = Option.builder("graph")
                .longOpt("make-graph")
                .desc("Makes a graph and data file")
                .build();
        Option matchCDR3 = Option.builder("match")
                .longOpt("match-cdr3")
                .desc("Match CDR3s. Requires a cell sample file and any number of plate files.")
                .build();
        OptionGroup mainGroup = new OptionGroup();
        mainGroup.addOption(makeCells);
        mainGroup.addOption(makePlate);
        mainGroup.addOption(makeGraph);
        mainGroup.addOption(matchCDR3);
        mainGroup.setRequired(true);
        mainOptions.addOptionGroup(mainGroup);
        //Reuse clones of this for other options groups, rather than making it lots of times
        Option outputFile = Option.builder("o")
                .longOpt("output-file")
                .hasArg()
                .argName("filename")
                .desc("Name of output file")
                .build();
        mainOptions.addOption(outputFile);
        //Options cellOptions = new Options();
        Option numCells = Option.builder("nc")
                .longOpt("num-cells")
                .desc("The number of distinct cells to generate")
                .hasArg()
                .argName("number")
                .build();
        mainOptions.addOption(numCells);
        Option cdr1Freq = Option.builder("d")
                .longOpt("peptide-diversity-factor")
                .hasArg()
                .argName("number")
                .desc("Number of distinct CDR3s for every CDR1")
                .build();
        mainOptions.addOption(cdr1Freq);
        //Option cellOutput = (Option) outputFile.clone();
        //cellOutput.setRequired(true);
        //mainOptions.addOption(cellOutput);
        //Options plateOptions = new Options();
        Option inputCells = Option.builder("c")
                .longOpt("cell-file")
                .hasArg()
                .argName("file")
                .desc("The cell sample file used for filling wells")
                .build();
        mainOptions.addOption(inputCells);
        Option numWells = Option.builder("w")
                .longOpt("num-wells")
                .hasArg()
                .argName("number")
                .desc("The number of wells on each plate")
                .build();
        mainOptions.addOption(numWells);
        Option numPlates = Option.builder("np")
                .longOpt("num-plates")
                .hasArg()
                .argName("number")
                .desc("The number of plate files to output")
                .build();
        mainOptions.addOption(numPlates);
        //Option plateOutput = (Option) outputFile.clone();
        //plateOutput.setRequired(true);
        //plateOutput.setDescription("Prefix for plate output filenames");
        //mainOptions.addOption(plateOutput);
        Option plateErr = Option.builder("err")
                .longOpt("drop-out-rate")
                .hasArg()
                .argName("number")
                .desc("Well drop-out rate. (Probability between 0 and 1)")
                .build();
        mainOptions.addOption(plateErr);
        Option plateConcentrations = Option.builder("t")
                .longOpt("t-cells-per-well")
                .hasArgs()
                .argName("number 1, number 2, ...")
                .desc("Number of T cells per well for each plate section")
                .build();
        mainOptions.addOption(plateConcentrations);
 //different distributions, mutually exclusive
        OptionGroup plateDistributions = new OptionGroup();
        Option plateExp = Option.builder("exponential")
                .desc("Sample from distinct cells with exponential frequency distribution")
                .build();
        plateDistributions.addOption(plateExp);
        Option plateGaussian = Option.builder("gaussian")
                .desc("Sample from distinct cells with gaussain frequency distribution")
                .build();
        plateDistributions.addOption(plateGaussian);
        Option platePoisson = Option.builder("poisson")
                .desc("Sample from distinct cells with poisson frequency distribution")
                .build();
        plateDistributions.addOption(platePoisson);
        mainOptions.addOptionGroup(plateDistributions);
        Option plateStdDev = Option.builder("stddev")
                .desc("Standard deviation for gaussian distribution")
                .hasArg()
                .argName("number")
                .build();
        mainOptions.addOption(plateStdDev);
        Option plateLambda = Option.builder("lambda")
                .desc("Lambda for exponential distribution")
                .hasArg()
                .argName("number")
                .build();
        mainOptions.addOption(plateLambda);
 //
 //            String cellFile, String filename, Double stdDev,
 //                    Integer numWells, Integer numSections,
 //                    Integer[] concentrations, Double dropOutRate
 //
        //Options matchOptions = new Options();
        inputCells.setDescription("The cell sample file to be used for matching.");
        mainOptions.addOption(inputCells);
        Option lowThresh = Option.builder("low")
                .longOpt("low-threshold")
                .hasArg()
                .argName("number")
                .desc("Sets the minimum occupancy overlap to attempt matching")
                .build();
        mainOptions.addOption(lowThresh);
        Option highThresh = Option.builder("high")
                .longOpt("high-threshold")
                .hasArg()
                .argName("number")
                .desc("Sets the maximum occupancy overlap to attempt matching")
                .build();
        mainOptions.addOption(highThresh);
        Option occDiff = Option.builder("occdiff")
                .longOpt("occupancy-difference")
                .hasArg()
                .argName("Number")
                .desc("Maximum difference in alpha/beta occupancy to attempt matching")
                .build();
        mainOptions.addOption(occDiff);
        Option overlapPer = Option.builder("ovper")
                .longOpt("overlap-percent")
                .hasArg()
                .argName("Percent")
                .desc("Minimum overlap percent to attempt matching (0 -100)")
                .build();
        mainOptions.addOption(overlapPer);
        Option inputPlates = Option.builder("p")
                .longOpt("plate-files")
                .hasArgs()
                .desc("Plate files to match")
                .build();
        mainOptions.addOption(inputPlates);
        CommandLineParser parser = new DefaultParser();
        try{
-            CommandLine line = parser.parse(mainOptions, args);
+            CommandLine line = parser.parse(mainOptions, Arrays.copyOfRange(args, 0, 1));
-            if(line.hasOption("match")){
+
-                //line = parser.parse(mainOptions, args);
+            if (line.hasOption("help")) {
-                //String cellFile = line.getOptionValue("c");
+                HelpFormatter formatter = new HelpFormatter();
-                String graphFile = line.getOptionValue("g");
+                formatter.printHelp("BiGpairSEQ_Sim.jar", mainOptions);
-                Integer lowThreshold = Integer.valueOf(line.getOptionValue(lowThresh));
+                System.out.println();
-                Integer highThreshold = Integer.valueOf(line.getOptionValue(highThresh));
+                formatter.printHelp("BiGpairSEQ_Sim.jar -cells", cellOptions);
-                Integer occupancyDifference = Integer.valueOf(line.getOptionValue(occDiff));
+                System.out.println();
-                Integer overlapPercent = Integer.valueOf(line.getOptionValue(overlapPer));
+                formatter.printHelp("BiGpairSEQ_Sim.jar -plate", plateOptions);
-                for(String plate: line.getOptionValues("p")) {
+                System.out.println();
-                    matchCDR3s(graphFile, lowThreshold, highThreshold, occupancyDifference, overlapPercent);
+                formatter.printHelp("BiGpairSEQ_Sim.jar -graph", graphOptions);
                System.out.println();
                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(mainOptions, args);
+                line = parser.parse(cellOptions, Arrays.copyOfRange(args, 1, args.length));
                Integer number = Integer.valueOf(line.getOptionValue("n"));
                Integer diversity = Integer.valueOf(line.getOptionValue("d"));
                String filename = line.getOptionValue("o");
-                Integer numDistCells = Integer.valueOf(line.getOptionValue("nc"));
+                makeCells(filename, number, diversity);
                Integer freq = Integer.valueOf(line.getOptionValue("d"));
                makeCells(filename, numDistCells, freq);
            }
            else if(line.hasOption("plates")){
                //line = parser.parse(mainOptions, args);
                String cellFile = line.getOptionValue("c");
                String filenamePrefix = line.getOptionValue("o");
                Integer numWellsOnPlate = Integer.valueOf(line.getOptionValue("w"));
                Integer numPlatesToMake = Integer.valueOf(line.getOptionValue("np"));
                String[] concentrationsToUseString = line.getOptionValues("t");
                Integer numSections = concentrationsToUseString.length;
-                Integer[] concentrationsToUse = new Integer[numSections];
+            else if (line.hasOption("plate")) {
-                for(int i = 0; i <numSections; i++){
+                line = parser.parse(plateOptions, Arrays.copyOfRange(args, 1, args.length));
-                    concentrationsToUse[i] = Integer.valueOf(concentrationsToUseString[i]);
+                //get the cells
                String cellFilename = line.getOptionValue("c");
                CellSample cells = getCells(cellFilename);
                //get the rest of the parameters
                Integer[] populations;
                String outputFilename = line.getOptionValue("o");
                Integer numWells = Integer.parseInt(line.getOptionValue("w"));
                Double dropoutRate = Double.parseDouble(line.getOptionValue("err"));
                if (line.hasOption("random")) {
                    //Array holding values of minimum and maximum populations
                   Integer[] min_max = Stream.of(line.getOptionValues("random"))
                           .mapToInt(Integer::parseInt)
                           .boxed()
                           .toArray(Integer[]::new);
                   populations = BiGpairSEQ.getRand().ints(min_max[0], min_max[1] + 1)
                            .limit(numWells)
                            .boxed()
                            .toArray(Integer[]::new);
                }
-                Double dropOutRate = Double.valueOf(line.getOptionValue("err"));
+                else if (line.hasOption("pop")) {
-                if(line.hasOption("exponential")){
+                    populations = Stream.of(line.getOptionValues("pop"))
-                    Double lambda = Double.valueOf(line.getOptionValue("lambda"));
+                            .mapToInt(Integer::parseInt)
-                    for(int i = 1; i <= numPlatesToMake; i++){
+                            .boxed()
-                        makePlateExp(cellFile, filenamePrefix + i, lambda, numWellsOnPlate,
+                            .toArray(Integer[]::new);
                                concentrationsToUse,dropOutRate);
                }
                else{
                    populations = new Integer[1];
                    populations[0] = 1;
                }
                //make the plate
                Plate plate;
                if (line.hasOption("poisson")) {
                    Double stdDev = Math.sqrt(numWells);
                    plate = new Plate(cells, cellFilename, numWells, populations, dropoutRate, stdDev, false);
                }
                else if (line.hasOption("gaussian")) {
-                    Double stdDev = Double.valueOf(line.getOptionValue("std-dev"));
+                    Double stdDev = Double.parseDouble(line.getOptionValue("stddev"));
-                    for(int i = 1; i <= numPlatesToMake; i++){
+                    plate = new Plate(cells, cellFilename, numWells, populations, dropoutRate, stdDev, false);
-                        makePlate(cellFile, filenamePrefix + i, stdDev, numWellsOnPlate,
+                }
-                                concentrationsToUse,dropOutRate);
+                else {
                    assert line.hasOption("exponential");
                    Double lambda = Double.parseDouble(line.getOptionValue("lambda"));
                    plate = new Plate(cells, cellFilename, numWells, populations, dropoutRate, lambda, true);
                }
                PlateFileWriter writer = new PlateFileWriter(outputFilename, plate);
                writer.writePlateFile();
            }
            else if (line.hasOption("graph")) { //Making a graph
                line = parser.parse(graphOptions, Arrays.copyOfRange(args, 1, args.length));
                String cellFilename = line.getOptionValue("c");
                String plateFilename = line.getOptionValue("p");
                String outputFilename = line.getOptionValue("o");
                //get cells
                CellSample cells = getCells(cellFilename);
                //get plate
                Plate plate = getPlate(plateFilename);
                GraphWithMapData graph = Simulator.makeGraph(cells, plate, false);
                if (!line.hasOption("no-binary")) { //output binary file unless told not to
                    GraphDataObjectWriter writer = new GraphDataObjectWriter(outputFilename, graph, false);
                    writer.writeDataToFile();
                }
-                else if(line.hasOption("poisson")){
+                if (line.hasOption("graphml")) { //if told to, output graphml file
-                    for(int i = 1; i <= numPlatesToMake; i++){
+                    GraphMLFileWriter gmlwriter = new GraphMLFileWriter(outputFilename, graph);
-                        makePlatePoisson(cellFile, filenamePrefix + i, numWellsOnPlate,
+                    gmlwriter.writeGraphToFile();
                                concentrationsToUse,dropOutRate);
                }
            }
            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;
                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"));
                int minOverlapPct;
                if (line.hasOption("minpct")) { //see if this filter is being used
                    minOverlapPct = Integer.parseInt(line.getOptionValue("minpct"));
                }
                else {
                    minOverlapPct = 0;
                }
                int maxOccupancyDiff;
                if (line.hasOption("maxdiff")) { //see if this filter is being used
                    maxOccupancyDiff = Integer.parseInt(line.getOptionValue("maxdiff"));
                }
                else {
                    maxOccupancyDiff = Integer.MAX_VALUE;
                }
                GraphWithMapData graph = getGraph(graphFilename);
                MatchingResult result = Simulator.matchCDR3s(graph, graphFilename, minThreshold, maxThreshold,
                        maxOccupancyDiff, minOverlapPct, false);
                if(outputFilename != null){
                    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) {
@@ -286,43 +222,278 @@ public class CommandLineInterface {
        }
    }
    private static Option outputFileOption() {
        Option outputFile = Option.builder("o")
                .longOpt("output-file")
                .hasArg()
                .argName("filename")
                .desc("Name of output file")
                .required()
                .build();
        return outputFile;
    }
    private static Options buildMainOptions() {
        Options mainOptions = new Options();
        Option help = Option.builder("help")
                .desc("Displays this help menu")
                .build();
        Option makeCells = Option.builder("cells")
                .longOpt("make-cells")
                .desc("Makes a cell sample file of distinct T cells")
                .build();
        Option makePlate = Option.builder("plate")
                .longOpt("make-plate")
                .desc("Makes a sample plate file. Requires a cell sample file.")
                .build();
        Option makeGraph = Option.builder("graph")
                .longOpt("make-graph")
                .desc("Makes a graph/data file. Requires a cell sample file and a sample plate file")
                .build();
        Option matchCDR3 = Option.builder("match")
                .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);
        mainGroup.addOption(matchCDR3);
        mainGroup.setRequired(true);
        mainOptions.addOptionGroup(mainGroup);
        return mainOptions;
    }
    private static Options buildCellOptions() {
        Options cellOptions = new Options();
        Option numCells = Option.builder("n")
                .longOpt("num-cells")
                .desc("The number of distinct cells to generate")
                .hasArg()
                .argName("number")
                .required().build();
        Option cdr3Diversity = Option.builder("d")
                .longOpt("diversity-factor")
                .desc("The factor by which unique CDR3s outnumber unique CDR1s")
                .hasArg()
                .argName("factor")
                .required().build();
        cellOptions.addOption(numCells);
        cellOptions.addOption(cdr3Diversity);
        cellOptions.addOption(outputFileOption());
        return cellOptions;
    }
    private static Options buildPlateOptions() {
        Options plateOptions = new Options();
        Option cellFile = Option.builder("c") // add this to plate options
                .longOpt("cell-file")
                .desc("The cell sample file to use")
                .hasArg()
                .argName("filename")
                .required().build();
        Option numWells = Option.builder("w")// add this to plate options
                .longOpt("wells")
                .desc("The number of wells on the sample plate")
                .hasArg()
                .argName("number")
                .required().build();
        //options group for choosing with distribution to use
        OptionGroup distributions = new OptionGroup();// add this to plate options
        distributions.setRequired(true);
        Option poisson = Option.builder("poisson")
                .desc("Use a Poisson distribution for cell sample")
                .build();
        Option gaussian = Option.builder("gaussian")
                .desc("Use a Gaussian distribution for cell sample")
                .build();
        Option exponential = Option.builder("exponential")
                .desc("Use an exponential distribution for cell sample")
                .build();
        distributions.addOption(poisson);
        distributions.addOption(gaussian);
        distributions.addOption(exponential);
        //options group for statistical distribution parameters
        OptionGroup statParams = new OptionGroup();// add this to plate options
        Option stdDev = Option.builder("stddev")
                .desc("If using -gaussian flag, standard deviation for distrbution")
                .hasArg()
                .argName("value")
                .build();
        Option lambda = Option.builder("lambda")
                .desc("If using -exponential flag, lambda value for distribution")
                .hasArg()
                .argName("value")
                .build();
        statParams.addOption(stdDev);
        statParams.addOption(lambda);
        //Option group for random plate or set populations
        OptionGroup wellPopOptions = new OptionGroup(); // add this to plate options
        wellPopOptions.setRequired(true);
        Option randomWellPopulations = Option.builder("random")
                .desc("Randomize well populations on sample plate. Takes two arguments: the minimum possible population and the maximum possible population.")
                .hasArgs()
                .numberOfArgs(2)
                .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.")
                .hasArgs()
                .argName("number [number]...")
                .build();
        Option dropoutRate = Option.builder("err") //add this to plate options
                .hasArg()
                .desc("The sequence dropout rate due to amplification error. (0.0 - 1.0)")
                .argName("rate")
                .required()
                .build();
        wellPopOptions.addOption(randomWellPopulations);
        wellPopOptions.addOption(specificWellPopulations);
        plateOptions.addOption(cellFile);
        plateOptions.addOption(numWells);
        plateOptions.addOptionGroup(distributions);
        plateOptions.addOptionGroup(statParams);
        plateOptions.addOptionGroup(wellPopOptions);
        plateOptions.addOption(dropoutRate);
        plateOptions.addOption(outputFileOption());
        return plateOptions;
    }
    private static Options buildGraphOptions() {
        Options graphOptions = new Options();
        Option cellFilename = Option.builder("c")
                .longOpt("cell-file")
                .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 from which to construct graph")
                .hasArg()
                .argName("filename")
                .required().build();
        Option outputGraphML = Option.builder("graphml")
                .desc("(Optional) Output GraphML file")
                .build();
        Option outputSerializedBinary = Option.builder("nb")
                .longOpt("no-binary")
                .desc("(Optional) Don't output serialized binary file")
                .build();
        graphOptions.addOption(cellFilename);
        graphOptions.addOption(plateFilename);
        graphOptions.addOption(outputFileOption());
        graphOptions.addOption(outputGraphML);
        graphOptions.addOption(outputSerializedBinary);
        return graphOptions;
    }
    private static Options buildMatchCDR3options() {
        Options matchCDR3options = new Options();
        Option graphFilename = Option.builder("g")
                .longOpt("graph-file")
                .desc("The graph/data file to use")
                .hasArg()
                .argName("filename")
                .required().build();
        Option minOccupancyOverlap = Option.builder("min")
                .desc("The minimum number of shared wells to attempt to match a sequence pair")
                .hasArg()
                .argName("number")
                .required().build();
        Option maxOccupancyOverlap = Option.builder("max")
                .desc("The maximum number of shared wells to attempt to match a sequence pair")
                .hasArg()
                .argName("number")
                .required().build();
        Option minOverlapPercent = Option.builder("minpct")
                .desc("(Optional) The minimum percentage of a sequence's total occupancy shared by another sequence to attempt matching. (0 - 100) ")
                .hasArg()
                .argName("percent")
                .build();
        Option maxOccupancyDifference = Option.builder("maxdiff")
                .desc("(Optional) The maximum difference in total occupancy between two sequences to attempt matching.")
                .hasArg()
                .argName("number")
                .build();
        Option outputFile = Option.builder("o") //can't call the method this time, because this one's optional
                .longOpt("output-file")
                .hasArg()
                .argName("filename")
                .desc("(Optional) Name of output the output file. If not present, no file will be written.")
                .build();
        matchCDR3options.addOption(graphFilename)
                .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;
    }
    private static CellSample getCells(String cellFilename) {
        assert cellFilename != null;
        CellFileReader reader = new CellFileReader(cellFilename);
        return reader.getCellSample();
    }
    private static Plate getPlate(String plateFilename) {
        assert plateFilename != null;
        PlateFileReader reader = new PlateFileReader(plateFilename);
        return reader.getSamplePlate();
    }
    private static GraphWithMapData getGraph(String graphFilename) {
        assert graphFilename != null;
        try{
            GraphDataObjectReader reader = new GraphDataObjectReader(graphFilename, false);
            return reader.getData();
        }
        catch (IOException ex) {
            ex.printStackTrace();
            return null;
        }
    }
    //for calling from command line
    public static void makeCells(String filename, Integer numCells, Integer cdr1Freq) {
-        CellSample sample = Simulator.generateCellSample(numCells, cdr1Freq);
+        CellSample sample = new CellSample(numCells, cdr1Freq);
        CellFileWriter writer = new CellFileWriter(filename, sample);
        writer.writeCellsToFile();
    }
    public static void makePlateExp(String cellFile, String filename, Double lambda,
                                    Integer numWells, Integer[] concentrations, Double dropOutRate){
        CellFileReader cellReader = new CellFileReader(cellFile);
        Plate samplePlate = new Plate(numWells, dropOutRate, concentrations);
        samplePlate.fillWellsExponential(cellReader.getFilename(), cellReader.getListOfDistinctCellsDEPRECATED(), lambda);
        PlateFileWriter writer = new PlateFileWriter(filename, samplePlate);
        writer.writePlateFile();
    }
    private static void makePlatePoisson(String cellFile, String filename, Integer numWells,
                                        Integer[] concentrations, Double dropOutRate){
        CellFileReader cellReader = new CellFileReader(cellFile);
        Double stdDev = Math.sqrt(cellReader.getCellCountDEPRECATED());
        Plate samplePlate = new Plate(numWells, dropOutRate, concentrations);
        samplePlate.fillWells(cellReader.getFilename(), cellReader.getListOfDistinctCellsDEPRECATED(), stdDev);
        PlateFileWriter writer = new PlateFileWriter(filename, samplePlate);
        writer.writePlateFile();
    }
    private static void makePlate(String cellFile, String filename, Double stdDev,
                                 Integer numWells, Integer[] concentrations, Double dropOutRate){
        CellFileReader cellReader = new CellFileReader(cellFile);
        Plate samplePlate = new Plate(numWells, dropOutRate, concentrations);
        samplePlate.fillWells(cellReader.getFilename(), cellReader.getListOfDistinctCellsDEPRECATED(), stdDev);
        PlateFileWriter writer = new PlateFileWriter(filename, samplePlate);
        writer.writePlateFile();
    }
    private static void matchCDR3s(String graphFile, Integer lowThreshold, Integer highThreshold,
                                   Integer occupancyDifference, Integer overlapPercent) {
    }
 }
--- a/src/main/java/GraphDataObjectReader.java
+++ b/src/main/java/GraphDataObjectReader.java
@@ -1,10 +1,12 @@
 import java.io.*;
 public class GraphDataObjectReader {
    private GraphWithMapData data;
    private String filename;
-    public GraphDataObjectReader(String filename) throws IOException {
+
    public GraphDataObjectReader(String filename, boolean verbose) throws IOException {
        if(!filename.matches(".*\\.ser")){
            filename = filename + ".ser";
        }
@@ -13,10 +15,13 @@ public class GraphDataObjectReader {
            BufferedInputStream fileIn = new BufferedInputStream(new FileInputStream(filename));
                ObjectInputStream in = new ObjectInputStream(fileIn))
        {
            if (verbose) {
                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();
        }
    }
--- a/src/main/java/GraphDataObjectWriter.java
+++ b/src/main/java/GraphDataObjectWriter.java
@@ -1,3 +1,5 @@
 import org.jgrapht.Graph;
 import java.io.BufferedOutputStream;
 import java.io.FileOutputStream;
 import java.io.IOException;
@@ -7,6 +9,7 @@ public class GraphDataObjectWriter {
    private GraphWithMapData data;
    private String filename;
    private boolean verbose = true;
    public GraphDataObjectWriter(String filename, GraphWithMapData data) {
        if(!filename.matches(".*\\.ser")){
@@ -16,13 +19,24 @@ public class GraphDataObjectWriter {
        this.data = data;
    }
    public GraphDataObjectWriter(String filename, GraphWithMapData data, boolean verbose) {
        this.verbose = verbose;
        if(!filename.matches(".*\\.ser")){
            filename = filename + ".ser";
        }
        this.filename = filename;
        this.data = data;
    }
    public void writeDataToFile() {
        try (BufferedOutputStream bufferedOut = new BufferedOutputStream(new FileOutputStream(filename));
             ObjectOutputStream out = new ObjectOutputStream(bufferedOut);
        ){
            if(verbose) {
                System.out.println("Writing graph and occupancy data to file. This may take some time.");
                System.out.println("File I/O time is not included in results.");
            }
            out.writeObject(data);
        } catch (IOException ex) {
            ex.printStackTrace();
--- a/src/main/java/GraphMLFileReader.java
+++ b/src/main/java/GraphMLFileReader.java
@@ -1,35 +0,0 @@
 import org.jgrapht.graph.SimpleWeightedGraph;
 import org.jgrapht.nio.graphml.GraphMLImporter;
 import java.io.BufferedReader;
 import java.io.IOException;
 import java.nio.file.Files;
 import java.nio.file.Path;
 public class GraphMLFileReader {
    private String filename;
    private SimpleWeightedGraph graph;
    public GraphMLFileReader(String filename, SimpleWeightedGraph graph) {
        if(!filename.matches(".*\\.graphml")){
            filename = filename + ".graphml";
        }
        this.filename = filename;
        this.graph = graph;
        try(//don't need to close reader bc of try-with-resources auto-closing
            BufferedReader reader = Files.newBufferedReader(Path.of(filename));
        ){
            GraphMLImporter<SimpleWeightedGraph, BufferedReader> importer = new GraphMLImporter<>();
            importer.importGraph(graph, reader);
        }
        catch (IOException ex) {
            System.out.println("Graph file " + filename + " not found.");
            System.err.println(ex);
        }
    }
    public SimpleWeightedGraph getGraph() { return graph; }
 }
--- a/src/main/java/GraphMLFileWriter.java
+++ b/src/main/java/GraphMLFileWriter.java
@@ -1,4 +1,8 @@
 import org.jgrapht.graph.DefaultWeightedEdge;
 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;
@@ -7,25 +11,69 @@ import java.io.IOException;
 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;
-    public GraphMLFileWriter(String filename, SimpleWeightedGraph graph) {
+    public GraphMLFileWriter(String filename, GraphWithMapData data) {
        if(!filename.matches(".*\\.graphml")){
            filename = filename + ".graphml";
        }
        this.filename = filename;
-        this.graph = graph;
+        this.data = data;
    }
 //    public void writeGraphToFile() {
 //        try(BufferedWriter writer = Files.newBufferedWriter(Path.of(filename), StandardOpenOption.CREATE_NEW);
 //        ){
 //            GraphMLExporter<SimpleWeightedGraph, BufferedWriter> exporter = new GraphMLExporter<>();
 //            exporter.exportGraph(graph, writer);
 //        } catch(IOException ex){
 //            System.out.println("Could not make new file named "+filename);
 //            System.err.println(ex);
 //        }
 //    }
    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);
        ){
-            GraphMLExporter<SimpleWeightedGraph, BufferedWriter> exporter = new GraphMLExporter<>();
+            //create exporter. Let the vertex labels be the unique ids for the vertices
            GraphMLExporter<Integer, SimpleWeightedGraph<Vertex, DefaultWeightedEdge>> exporter = new GraphMLExporter<>(v -> v.toString());
            //set to export weights
            exporter.setExportEdgeWeights(true);
            //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("CDR3 Alpha"));
                    attributes.put("sequence", DefaultAttribute.createAttribute(vertexToAlphaMap.get(v)));
                    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);
            exporter.registerAttribute("sequence", GraphMLExporter.AttributeCategory.NODE, AttributeType.STRING);
            exporter.registerAttribute("occupancy", GraphMLExporter.AttributeCategory.NODE, AttributeType.STRING);
            //export the graph
            exporter.exportGraph(graph, writer);
        } catch(IOException ex){
            System.out.println("Could not make new file named "+filename);
@@ -33,3 +81,4 @@ public class GraphMLFileWriter {
        }
    }
 }
--- a/src/main/java/GraphModificationFunctions.java
+++ b/src/main/java/GraphModificationFunctions.java
@@ -4,61 +4,75 @@ import org.jgrapht.graph.SimpleWeightedGraph;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
-public abstract class GraphModificationFunctions {
+public interface GraphModificationFunctions {
    //remove over- and under-weight edges
-    public static List<Integer[]> filterByOverlapThresholds(SimpleWeightedGraph<Integer, DefaultWeightedEdge> graph,
+    static List<Integer[]> filterByOverlapThresholds(SimpleWeightedGraph<Integer, DefaultWeightedEdge> graph,
-                                                            int low, int high) {
+                                                            int low, int high, boolean saveEdges) {
        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);
                    Integer target = graph.getEdgeTarget(e);
                    Integer weight = (int) graph.getEdgeWeight(e);
                    Integer[] edge = {source, target, weight};
                    removedEdges.add(edge);
                }
                else {
                    graph.setEdgeWeight(e, 0.0);
                }
            }
        }
        if(saveEdges) {
            for (Integer[] edge : removedEdges) {
                graph.removeEdge(edge[0], edge[1]);
            }
        }
        return removedEdges;
    }
    //Remove edges for pairs with large occupancy discrepancy
-    public static List<Integer[]> filterByRelativeOccupancy(SimpleWeightedGraph<Integer, DefaultWeightedEdge> graph,
+    static List<Integer[]> filterByRelativeOccupancy(SimpleWeightedGraph<Integer, DefaultWeightedEdge> graph,
                                                  Map<Integer, Integer> alphaWellCounts,
                                                  Map<Integer, Integer> betaWellCounts,
                                                  Map<Integer, Integer> plateVtoAMap,
                                                  Map<Integer, Integer> plateVtoBMap,
-                                                  Integer maxOccupancyDifference) {
+                                                  Integer maxOccupancyDifference, boolean saveEdges) {
        List<Integer[]> removedEdges = new ArrayList<>();
        for (DefaultWeightedEdge e : graph.edgeSet()) {
            Integer alphaOcc = alphaWellCounts.get(plateVtoAMap.get(graph.getEdgeSource(e)));
            Integer betaOcc = betaWellCounts.get(plateVtoBMap.get(graph.getEdgeTarget(e)));
            if (Math.abs(alphaOcc - betaOcc) >= maxOccupancyDifference) {
                if (saveEdges) {
                    Integer source = graph.getEdgeSource(e);
                    Integer target = graph.getEdgeTarget(e);
                    Integer weight = (int) graph.getEdgeWeight(e);
                    Integer[] edge = {source, target, weight};
                    removedEdges.add(edge);
                }
                else {
                    graph.setEdgeWeight(e, 0.0);
                }
            }
        }
        if(saveEdges) {
            for (Integer[] edge : removedEdges) {
                graph.removeEdge(edge[0], edge[1]);
            }
        }
        return removedEdges;
    }
    //Remove edges for pairs where overlap size is significantly lower than the well occupancy
-    public static List<Integer[]> filterByOverlapPercent(SimpleWeightedGraph<Integer, DefaultWeightedEdge> graph,
+    static List<Integer[]> filterByOverlapPercent(SimpleWeightedGraph<Integer, DefaultWeightedEdge> graph,
                                                         Map<Integer, Integer> alphaWellCounts,
                                                         Map<Integer, Integer> betaWellCounts,
                                                         Map<Integer, Integer> plateVtoAMap,
                                                         Map<Integer, Integer> plateVtoBMap,
-                                                         Integer minOverlapPercent) {
+                                                         Integer minOverlapPercent,
                                                         boolean saveEdges) {
        List<Integer[]> removedEdges = new ArrayList<>();
        for (DefaultWeightedEdge e : graph.edgeSet()) {
            Integer alphaOcc = alphaWellCounts.get(plateVtoAMap.get(graph.getEdgeSource(e)));
@@ -66,20 +80,27 @@ public abstract class GraphModificationFunctions {
            double weight = graph.getEdgeWeight(e);
            double min = minOverlapPercent / 100.0;
            if ((weight / alphaOcc < min) || (weight / betaOcc < min)) {
                if(saveEdges) {
                    Integer source = graph.getEdgeSource(e);
                    Integer target = graph.getEdgeTarget(e);
                    Integer intWeight = (int) graph.getEdgeWeight(e);
                    Integer[] edge = {source, target, intWeight};
                    removedEdges.add(edge);
                }
                else {
                    graph.setEdgeWeight(e, 0.0);
                }
            }
        }
        if(saveEdges) {
            for (Integer[] edge : removedEdges) {
                graph.removeEdge(edge[0], edge[1]);
            }
        }
        return removedEdges;
    }
-    public static void addRemovedEdges(SimpleWeightedGraph<Integer, DefaultWeightedEdge> graph,
+    static void addRemovedEdges(SimpleWeightedGraph<Integer, DefaultWeightedEdge> graph,
                                       List<Integer[]> removedEdges) {
        for (Integer[] edge : removedEdges) {
            DefaultWeightedEdge e = graph.addEdge(edge[0], edge[1]);
--- a/src/main/java/InteractiveInterface.java
+++ b/src/main/java/InteractiveInterface.java
@@ -27,6 +27,7 @@ public class InteractiveInterface {
                //Need to re-do the CDR3/CDR1 matching to correspond to new pattern
                //System.out.println("5) Generate CDR3/CDR1 occupancy graph");
                //System.out.println("6) Simulate CDR3/CDR1 T cell matching");
                System.out.println("8) Options");
                System.out.println("9) About/Acknowledgments");
                System.out.println("0) Exit");
                try {
@@ -37,9 +38,10 @@ public class InteractiveInterface {
                        case 3 -> makeCDR3Graph();
                        case 4 -> matchCDR3s();
                        //case 6 -> matchCellsCDR1();
                        case 8 -> mainOptions();
                        case 9 -> acknowledge();
                        case 0 -> quit = true;
-                        default -> throw new InputMismatchException("Invalid input.");
+                        default -> System.out.println("Invalid input.");
                    }
                } catch (InputMismatchException | IOException ex) {
                    System.out.println(ex);
@@ -72,17 +74,15 @@ public class InteractiveInterface {
            System.out.println(ex);
            sc.next();
        }
-        CellSample sample = Simulator.generateCellSample(numCells, cdr1Freq);
+        CellSample sample = new CellSample(numCells, cdr1Freq);
        assert filename != null;
        System.out.println("Writing cells to file");
        CellFileWriter writer = new CellFileWriter(filename, sample);
        writer.writeCellsToFile();
        System.out.println("Cell sample written to: " + filename);
-        if(BiGpairSEQ.getCellSampleInMemory() != null) {
+        if(BiGpairSEQ.cacheCells()) {
-            BiGpairSEQ.clearCellSampleInMemory();
+            BiGpairSEQ.setCellSampleInMemory(sample, filename);
        }
        BiGpairSEQ.setCellSampleInMemory(sample);
        BiGpairSEQ.setCellFilename(filename);
    }
    //Output a CSV of sample plate
@@ -219,31 +219,30 @@ public class InteractiveInterface {
            System.out.println("Reading Cell Sample file: " + cellFile);
            CellFileReader cellReader = new CellFileReader(cellFile);
            cells = cellReader.getCellSample();
-            BiGpairSEQ.clearCellSampleInMemory();
+            if(BiGpairSEQ.cacheCells()) {
-            BiGpairSEQ.setCellSampleInMemory(cells);
+                BiGpairSEQ.setCellSampleInMemory(cells, cellFile);
-            BiGpairSEQ.setCellFilename(cellFile);
+            }
        }
        assert filename != null;
        Plate samplePlate;
        PlateFileWriter writer;
        if(exponential){
-            samplePlate = new Plate(numWells, dropOutRate, populations);
+            samplePlate = new Plate(cells, cellFile, numWells, populations, dropOutRate, lambda, true);
            samplePlate.fillWellsExponential(cellFile, cells.getCells(), lambda);
            writer = new PlateFileWriter(filename, samplePlate);
        }
        else {
            if (poisson) {
                stdDev = Math.sqrt(cells.getCellCount()); //gaussian with square root of elements approximates poisson
            }
-            samplePlate = new Plate(numWells, dropOutRate, populations);
+            samplePlate = new Plate(cells, cellFile, numWells, populations, dropOutRate, stdDev, false);
            samplePlate.fillWells(cellFile, cells.getCells(), stdDev);
            writer = new PlateFileWriter(filename, samplePlate);
        }
        System.out.println("Writing Sample Plate to file");
        writer.writePlateFile();
        System.out.println("Sample Plate written to file: " + filename);
-        BiGpairSEQ.setPlateInMemory(samplePlate);
+        if(BiGpairSEQ.cachePlate()) {
-        BiGpairSEQ.setPlateFilename(filename);
+            BiGpairSEQ.setPlateInMemory(samplePlate, filename);
        }
    }
    //Output serialized binary of GraphAndMapData object
@@ -251,7 +250,6 @@ public class InteractiveInterface {
        String filename = null;
        String cellFile = null;
        String plateFile = null;
        try {
            String str = "\nGenerating bipartite weighted graph encoding occupancy overlap data ";
            str = str.concat("\nrequires a cell sample file and a sample plate file.");
@@ -271,16 +269,16 @@ public class InteractiveInterface {
        assert cellFile != null;
        CellSample cellSample;
        //check if cells are already in memory
-        if(cellFile.equals(BiGpairSEQ.getCellFilename())) {
+        if(cellFile.equals(BiGpairSEQ.getCellFilename()) && BiGpairSEQ.getCellSampleInMemory() != null) {
            cellSample = BiGpairSEQ.getCellSampleInMemory();
        }
        else {
            BiGpairSEQ.clearCellSampleInMemory();
            System.out.println("Reading Cell Sample file: " + cellFile);
            CellFileReader cellReader = new CellFileReader(cellFile);
            cellSample = cellReader.getCellSample();
-            BiGpairSEQ.setCellSampleInMemory(cellSample);
+            if(BiGpairSEQ.cacheCells()) {
-            BiGpairSEQ.setCellFilename(cellFile);
+                BiGpairSEQ.setCellSampleInMemory(cellSample, cellFile);
            }
        }
        assert plateFile != null;
@@ -290,12 +288,12 @@ public class InteractiveInterface {
            plate = BiGpairSEQ.getPlateInMemory();
        }
        else {
            BiGpairSEQ.clearPlateInMemory();
            System.out.println("Reading Sample Plate file: " + plateFile);
            PlateFileReader plateReader = new PlateFileReader(plateFile);
-            plate = new Plate(plateReader.getFilename(), plateReader.getWells());
+            plate = plateReader.getSamplePlate();
-            BiGpairSEQ.setPlateInMemory(plate);
+            if(BiGpairSEQ.cachePlate()) {
-            BiGpairSEQ.setPlateFilename(plateFile);
+                BiGpairSEQ.setPlateInMemory(plate, plateFile);
            }
        }
        if (cellSample.getCells().size() == 0){
            System.out.println("No cell sample found.");
@@ -306,15 +304,22 @@ public class InteractiveInterface {
            System.out.println("Returning to main menu.");
        }
        else{
-            List<Integer[]> cells = cellSample.getCells();
+            GraphWithMapData data = Simulator.makeGraph(cellSample, plate, true);
            GraphWithMapData data = Simulator.makeGraph(cells, plate, true);
            assert filename != null;
            if(BiGpairSEQ.outputBinary()) {
                GraphDataObjectWriter dataWriter = new GraphDataObjectWriter(filename, data);
                dataWriter.writeDataToFile();
-            System.out.println("Graph and Data file written to: " + filename);
+                System.out.println("Serialized binary graph/data file written to: " + filename);
-            BiGpairSEQ.setGraphInMemory(data);
+            }
-            BiGpairSEQ.setGraphFilename(filename);
+            if(BiGpairSEQ.outputGraphML()) {
-            System.out.println("Graph and Data file " + filename + " cached.");
+                GraphMLFileWriter graphMLWriter = new GraphMLFileWriter(filename, data);
                graphMLWriter.writeGraphToFile();
                System.out.println("GraphML file written to: " + filename);
            }
            if(BiGpairSEQ.cacheGraph()) {
                BiGpairSEQ.setGraphInMemory(data, filename);
            }
        }
    }
@@ -366,17 +371,15 @@ public class InteractiveInterface {
        assert graphFilename != null;
        //check if this is the same graph we already have in memory.
        GraphWithMapData data;
-        if(!(graphFilename.equals(BiGpairSEQ.getGraphFilename())) || BiGpairSEQ.getGraphInMemory() == null) {
+        if(graphFilename.equals(BiGpairSEQ.getGraphFilename())) {
-            BiGpairSEQ.clearGraphInMemory();
+            data = BiGpairSEQ.getGraphInMemory();
            //read object data from file
            GraphDataObjectReader dataReader = new GraphDataObjectReader(graphFilename);
            data = dataReader.getData();
            //set new graph in memory and new filename
            BiGpairSEQ.setGraphInMemory(data);
            BiGpairSEQ.setGraphFilename(graphFilename);
        }
        else {
-            data = BiGpairSEQ.getGraphInMemory();
+            GraphDataObjectReader dataReader = new GraphDataObjectReader(graphFilename, true);
            data = dataReader.getData();
            if(BiGpairSEQ.cacheGraph()) {
                BiGpairSEQ.setGraphInMemory(data, graphFilename);
            }
        }
        //simulate matching
        MatchingResult results = Simulator.matchCDR3s(data, graphFilename, lowThreshold, highThreshold, maxOccupancyDiff,
@@ -493,7 +496,82 @@ public class InteractiveInterface {
 //        }
 //    }
    private static void mainOptions(){
        boolean backToMain = false;
        while(!backToMain) {
            System.out.println("\n--------------OPTIONS---------------");
            System.out.println("1) Turn " + getOnOff(!BiGpairSEQ.cacheCells()) + " cell sample file caching");
            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("6) Maximum weight matching algorithm options");
            System.out.println("0) Return to main menu");
            try {
                input = sc.nextInt();
                switch (input) {
                    case 1 -> BiGpairSEQ.setCacheCells(!BiGpairSEQ.cacheCells());
                    case 2 -> BiGpairSEQ.setCachePlate(!BiGpairSEQ.cachePlate());
                    case 3 -> BiGpairSEQ.setCacheGraph(!BiGpairSEQ.cacheGraph());
                    case 4 -> BiGpairSEQ.setOutputBinary(!BiGpairSEQ.outputBinary());
                    case 5 -> BiGpairSEQ.setOutputGraphML(!BiGpairSEQ.outputGraphML());
                    case 6 -> algorithmOptions();
                    case 0 -> backToMain = true;
                    default -> System.out.println("Invalid input");
                }
            } catch (InputMismatchException ex) {
                System.out.println(ex);
                sc.next();
            }
        }
    }
    /**
     * Helper function for printing menu items in mainOptions(). Returns a string based on the value of parameter.
     *
     * @param b - a boolean value
     * @return String "on" if b is true, "off" if b is false
     */
    private static String getOnOff(boolean b) {
        if (b) { return "on";}
        else { return "off"; }
    }
    private static void algorithmOptions(){
        boolean backToOptions = false;
        while(!backToOptions) {
            System.out.println("\n---------ALGORITHM OPTIONS----------");
            System.out.println("1) Use scaling algorithm by Duan and Su.");
            System.out.println("2) Use LEDA book algorithm with Fibonacci heap priority queue");
            System.out.println("3) Use LEDA book algorithm with pairing heap priority queue");
            System.out.println("0) Return to Options menu");
            try {
                input = sc.nextInt();
                switch (input) {
                    case 1 -> System.out.println("This option is not yet implemented. Choose another.");
                    case 2 -> {
                        BiGpairSEQ.setFibonacciHeap();
                        System.out.println("MWM algorithm set to LEDA with Fibonacci heap");
                        backToOptions = true;
                    }
                    case 3 -> {
                        BiGpairSEQ.setPairingHeap();
                        System.out.println("MWM algorithm set to LEDA with pairing heap");
                        backToOptions = true;
                    }
                    case 0 -> backToOptions = true;
                    default -> System.out.println("Invalid input");
                }
            } catch (InputMismatchException ex) {
                System.out.println(ex);
                sc.next();
            }
        }
    }
    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();
--- a/src/main/java/MatchingResult.java
+++ b/src/main/java/MatchingResult.java
@@ -21,15 +21,15 @@ public class MatchingResult {
         * well populations *
         * total alphas found *
         * total betas found *
-         * high overlap threshold
+         * high overlap threshold *
-         * low overlap threshold
+         * low overlap threshold *
-         * maximum occupancy difference
+         * maximum occupancy difference *
-         * minimum overlap percent
+         * minimum overlap percent *
-         * pairing attempt rate
+         * pairing attempt rate *
-         * correct pairing count
+         * correct pairing count *
-         * incorrect pairing count
+         * incorrect pairing count *
-         * pairing error rate
+         * pairing error rate *
-         * simulation time
+         * simulation time (seconds)
         */
        this.metadata = metadata;
        this.comments = new ArrayList<>();
@@ -91,6 +91,22 @@ public class MatchingResult {
        return Integer.parseInt(metadata.get("total beta count"));
    }
-    //put in the rest of these methods following the same pattern
+    public Integer getHighOverlapThreshold() { return Integer.parseInt(metadata.get("high overlap threshold"));}
    public Integer getLowOverlapThreshold() { return Integer.parseInt(metadata.get("low overlap threshold"));}
    public Integer getMaxOccupancyDifference() { return Integer.parseInt(metadata.get("maximum occupancy difference"));}
    public Integer getMinOverlapPercent() { return Integer.parseInt(metadata.get("minimum overlap percent"));}
    public Double getPairingAttemptRate() { return Double.parseDouble(metadata.get("pairing attempt rate"));}
    public Integer getCorrectPairingCount() { return Integer.parseInt(metadata.get("correct pairing count"));}
    public Integer getIncorrectPairingCount() { return Integer.parseInt(metadata.get("incorrect pairing count"));}
    public Double getPairingErrorRate() { return Double.parseDouble(metadata.get("pairing error rate"));}
    public String getSimulationTime() { return metadata.get("simulation time (seconds)"); }
 }
--- a/src/main/java/Plate.java
+++ b/src/main/java/Plate.java
@@ -8,7 +8,9 @@ TODO: Implement discrete frequency distributions using Vose's Alias Method
 import java.util.*;
 public class Plate {
    private CellSample cells;
    private String sourceFile;
    private String filename;
    private List<List<Integer[]>> wells;
    private final Random rand = BiGpairSEQ.getRand();
    private int size;
@@ -18,6 +20,25 @@ public class Plate {
    private double lambda;
    boolean exponential = false;
    public Plate(CellSample cells, String cellFilename, int numWells, Integer[] populations,
                 double dropoutRate, double stdDev_or_lambda, boolean exponential){
        this.cells = cells;
        this.sourceFile = cellFilename;
        this.size = numWells;
        this.wells = new ArrayList<>();
        this.error = dropoutRate;
        this.populations = populations;
        this.exponential = exponential;
        if (this.exponential) {
            this.lambda = stdDev_or_lambda;
            fillWellsExponential(cells.getCells(), this.lambda);
        }
        else {
            this.stdDev = stdDev_or_lambda;
            fillWells(cells.getCells(), this.stdDev);
        }
    }
    public Plate(int size, double error, Integer[] populations) {
        this.size = size;
@@ -26,8 +47,9 @@ public class Plate {
        wells = new ArrayList<>();
    }
-    public Plate(String sourceFileName, List<List<Integer[]>> wells) {
+    //constructor for returning a Plate from a PlateFileReader
-        this.sourceFile = sourceFileName;
+    public Plate(String filename, List<List<Integer[]>> wells) {
        this.filename = filename;
        this.wells = wells;
        this.size = wells.size();
@@ -43,10 +65,9 @@ public class Plate {
        }
    }
-    public void fillWellsExponential(String sourceFileName, List<Integer[]> cells, double lambda){
+    private void fillWellsExponential(List<Integer[]> cells, double lambda){
        this.lambda = lambda;
        exponential = true;
        sourceFile = sourceFileName;
        int numSections = populations.length;
        int section = 0;
        double m;
@@ -74,9 +95,8 @@ public class Plate {
        }
    }
-    public void fillWells(String sourceFileName, List<Integer[]> cells, double stdDev) {
+    private void fillWells( List<Integer[]> cells, double stdDev) {
        this.stdDev = stdDev;
        sourceFile = sourceFileName;
        int numSections = populations.length;
        int section = 0;
        double m;
@@ -159,4 +179,6 @@ public class Plate {
    public String getSourceFileName() {
        return sourceFile;
    }
    public String getFilename() { return filename; }
 }
--- a/src/main/java/PlateFileReader.java
+++ b/src/main/java/PlateFileReader.java
@@ -56,11 +56,8 @@ public class PlateFileReader {
    }
-    public List<List<Integer[]>> getWells() {
+    public Plate getSamplePlate() {
-        return wells;
+        return new Plate(filename, wells);
    }
    public String getFilename() {
        return filename;
    }
 }
--- a/src/main/java/Simulator.java
+++ b/src/main/java/Simulator.java
@@ -3,6 +3,7 @@ import org.jgrapht.alg.matching.MaximumWeightBipartiteMatching;
 import org.jgrapht.generate.SimpleWeightedBipartiteGraphMatrixGenerator;
 import org.jgrapht.graph.DefaultWeightedEdge;
 import org.jgrapht.graph.SimpleWeightedGraph;
 import org.jheaps.tree.FibonacciHeap;
 import org.jheaps.tree.PairingHeap;
 import java.math.BigDecimal;
@@ -16,39 +17,17 @@ import java.util.stream.IntStream;
 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 {
+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;
    public static CellSample generateCellSample(Integer numDistinctCells, Integer cdr1Freq) {
        //In real T cells, CDR1s have about one third the diversity of CDR3s
        List<Integer> numbersCDR3 = new ArrayList<>();
        List<Integer> numbersCDR1 = new ArrayList<>();
        Integer numDistCDR3s = 2 * numDistinctCells + 1;
        IntStream.range(1, numDistCDR3s + 1).forEach(i -> numbersCDR3.add(i));
        IntStream.range(numDistCDR3s + 1, numDistCDR3s + 1 + (numDistCDR3s / cdr1Freq) + 1).forEach(i -> numbersCDR1.add(i));
        Collections.shuffle(numbersCDR3);
        Collections.shuffle(numbersCDR1);
        //Each cell represented by 4 values
        //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){
            Integer tmpCDR3a = numbersCDR3.get(i);
            Integer tmpCDR3b = numbersCDR3.get(i+1);
            Integer tmpCDR1a = numbersCDR1.get(i % numbersCDR1.size());
            Integer tmpCDR1b = numbersCDR1.get((i+1) % numbersCDR1.size());
            Integer[] tmp = {tmpCDR3a, tmpCDR3b, tmpCDR1a, tmpCDR1b};
            distinctCells.add(tmp);
        }
        return new CellSample(distinctCells, cdr1Freq);
    }
    //Make the graph needed for matching CDR3s
-    public static GraphWithMapData makeGraph(List<Integer[]> distinctCells, Plate samplePlate, boolean verbose) {
+    public static GraphWithMapData makeGraph(CellSample cellSample, Plate samplePlate, boolean verbose) {
        Instant start = Instant.now();
        List<Integer[]> distinctCells = cellSample.getCells();
        int[] alphaIndex = {cdr3AlphaIndex};
        int[] betaIndex = {cdr3BetaIndex};
@@ -56,7 +35,7 @@ public class Simulator {
        if(verbose){System.out.println("Making cell maps");}
        //HashMap keyed to Alphas, values Betas
-        Map<Integer, Integer> distCellsMapAlphaKey = makeSequenceToSequenceMap(distinctCells, 0, 1);
+        Map<Integer, Integer> distCellsMapAlphaKey = makeSequenceToSequenceMap(distinctCells, cdr3AlphaIndex, cdr3BetaIndex);
        if(verbose){System.out.println("Cell maps made");}
        if(verbose){System.out.println("Making well maps");}
@@ -68,10 +47,11 @@ public class Simulator {
        if(verbose){System.out.println("All betas count: " + betaCount);}
        if(verbose){System.out.println("Well maps made");}
-        if(verbose){System.out.println("Removing sequences present in all wells.");}
+
-        filterByOccupancyThresholds(allAlphas, 1, numWells - 1);
+//        if(verbose){System.out.println("Removing singleton sequences and sequences present in all wells.");}
-        filterByOccupancyThresholds(allBetas, 1, numWells - 1);
+//        filterByOccupancyThresholds(allAlphas, 2, numWells - 1);
-        if(verbose){System.out.println("Sequences removed");}
+//        filterByOccupancyThresholds(allBetas, 2, numWells - 1);
 //        if(verbose){System.out.println("Sequences removed");}
        int pairableAlphaCount = allAlphas.size();
        if(verbose){System.out.println("Remaining alphas count: " + pairableAlphaCount);}
        int pairableBetaCount = allBetas.size();
@@ -136,7 +116,7 @@ public class Simulator {
                distCellsMapAlphaKey, plateVtoAMap, plateVtoBMap, plateAtoVMap,
                plateBtoVMap, alphaWellCounts, betaWellCounts, time);
        //Set source file name in graph to name of sample plate
-        output.setSourceFilename(samplePlate.getSourceFileName());
+        output.setSourceFilename(samplePlate.getFilename());
        //return GraphWithMapData object
        return output;
    }
@@ -146,8 +126,8 @@ public class Simulator {
                                            Integer highThreshold, Integer maxOccupancyDifference,
                                            Integer minOverlapPercent, boolean verbose) {
        Instant start = Instant.now();
        //Integer arrays will contain TO VERTEX, FROM VERTEX, and WEIGHT (which I'll need to cast to double)
        List<Integer[]> removedEdges = new ArrayList<>();
        boolean saveEdges = BiGpairSEQ.cacheGraph();
        int numWells = data.getNumWells();
        Integer alphaCount = data.getAlphaCount();
        Integer betaCount = data.getBetaCount();
@@ -160,33 +140,49 @@ public class Simulator {
        //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));
+        removedEdges.addAll(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,
-                plateVtoAMap, plateVtoBMap, minOverlapPercent));
+                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,
-                plateVtoAMap, plateVtoBMap, maxOccupancyDifference));
+                plateVtoAMap, plateVtoBMap, maxOccupancyDifference, saveEdges));
        if(verbose){System.out.println("Edges between vertices of with excessively different occupancy values " +
                "removed");}
        //Find Maximum Weighted Matching
        //using jheaps library class PairingHeap for improved efficiency
        if(verbose){System.out.println("Finding maximum weighted matching");}
-        //Attempting to use addressable heap to improve performance
+        MaximumWeightBipartiteMatching maxWeightMatching;
-        MaximumWeightBipartiteMatching maxWeightMatching =
+        //Use correct heap type for priority queue
-                new MaximumWeightBipartiteMatching(graph,
+        String heapType = BiGpairSEQ.getPriorityQueueHeapType();
        switch (heapType) {
            case "PAIRING" -> {
                maxWeightMatching = new MaximumWeightBipartiteMatching(graph,
                        plateVtoAMap.keySet(),
                        plateVtoBMap.keySet(),
                        i -> new PairingHeap(Comparator.naturalOrder()));
            }
            case "FIBONACCI" -> {
                maxWeightMatching = new MaximumWeightBipartiteMatching(graph,
                        plateVtoAMap.keySet(),
                        plateVtoBMap.keySet(),
                        i -> new FibonacciHeap(Comparator.naturalOrder()));
            }
            default -> {
                maxWeightMatching = new MaximumWeightBipartiteMatching(graph,
                        plateVtoAMap.keySet(),
                        plateVtoBMap.keySet());
            }
        }
        //get the matching
        MatchingAlgorithm.Matching<String, DefaultWeightedEdge> graphMatching = maxWeightMatching.getMatching();
        if(verbose){System.out.println("Matching completed");}
        Instant stop = Instant.now();
@@ -242,18 +238,21 @@ public class Simulator {
        }
        //Metadata comments for CSV file
        String algoType = "LEDA book with heap: " + heapType;
        int min = Math.min(alphaCount, betaCount);
        //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();
@@ -272,6 +271,8 @@ public class Simulator {
        Map<String, String> metadata = new LinkedHashMap<>();
        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 betas found", betaCount.toString());
@@ -283,7 +284,7 @@ public class Simulator {
        metadata.put("correct pairing count", Integer.toString(trueCount));
        metadata.put("incorrect pairing count", Integer.toString(falseCount));
        metadata.put("pairing error rate", pairingErrorRateTrunc.toString());
-        metadata.put("simulation time", nf.format(time.toSeconds()));
+        metadata.put("simulation time (seconds)", nf.format(time.toSeconds()));
        //create MatchingResult object
        MatchingResult output = new MatchingResult(metadata, header, allResults, matchMap, time);
        if(verbose){
@@ -292,10 +293,11 @@ public class Simulator {
            }
        }
        if(saveEdges) {
            //put the removed edges back on the graph
            System.out.println("Restoring removed edges to graph.");
            GraphModificationFunctions.addRemovedEdges(graph, removedEdges);
-
+        }
        //return MatchingResult object
        return output;
    }
@@ -671,7 +673,7 @@ public class Simulator {
    private static Map<Integer, Integer> makeVertexToSequenceMap(Map<Integer, Integer> sequences, Integer startValue) {
        Map<Integer, Integer> map = new LinkedHashMap<>(); //LinkedHashMap to preserve order of entry
-        Integer index = startValue;
+        Integer index = startValue; //is this necessary? I don't think I use this.
        for (Integer k: sequences.keySet()) {
            map.put(index, k);
            index++;
--- a/src/main/java/Vertex.java
+++ b/src/main/java/Vertex.java
@@ -1,14 +1,20 @@
 public class Vertex {
-    private final Integer peptide;
+    private final Integer vertexLabel;
    private final Integer sequence;
    private final Integer occupancy;
-    public Vertex(Integer peptide, Integer occupancy) {
+    public Vertex(Integer vertexLabel, Integer sequence, Integer occupancy) {
-        this.peptide = peptide;
+        this.vertexLabel = vertexLabel;
        this.sequence = sequence;
        this.occupancy = occupancy;
    }
-    public Integer getPeptide() {
+    public Integer getVertexLabel() { return vertexLabel; }
-        return peptide;
+
    public Integer getSequence() {
        return sequence;
    }
    public Integer getOccupancy() {
Author	SHA1	Message	Date
eugenefischer	3707923398	Merge remote-tracking branch 'origin/master'	2022-09-21 13:16:52 -05:00
eugenefischer	cf771ce574	parameterized sequence indices	2022-09-21 13:15:49 -05:00
efischer	f980722b56	update TODO	2022-09-21 18:09:37 +00:00
efischer	1df86f01df	parameterized sequence indices	2022-03-05 12:03:31 -06:00
efischer	96ba57d653	Remove singleton sequences from wells in initial filtering	2022-03-04 16:14:17 -06:00
efischer	b602fb02f1	Remove obsolete comments	2022-03-02 23:35:24 -06:00
efischer	325e1ebe2b	Add data on randomized well population behavior	2022-03-02 23:21:56 -06:00
efischer	df047267ee	Add data on randomized well population behavior	2022-03-02 22:54:17 -06:00
efischer	03e8d31210	Add data on randomized well population behavior	2022-03-02 18:55:19 -06:00
efischer	582dc3ef40	Update readme	2022-03-02 12:39:40 -06:00
efischer	4c872ed48e	Add optional stdout print flags	2022-03-01 15:27:04 -06:00
efischer	3fc39302c7	Add detail to error message	2022-03-01 15:24:14 -06:00
efischer	578bdc0fbf	clarify help menu text	2022-03-01 15:08:43 -06:00
efischer	8275cf7740	Check for finite pairing error rate	2022-03-01 09:01:53 -06:00
efischer	64209691f0	Check for finite pairing error rate	2022-03-01 09:00:58 -06:00
efischer	1886800873	update readme	2022-03-01 08:54:32 -06:00
efischer	bedf0894bc	update readme	2022-03-01 08:45:40 -06:00
efischer	2ac3451842	update readme	2022-03-01 08:43:48 -06:00
efischer	67ec3f3764	update readme	2022-03-01 08:43:18 -06:00
efischer	b5a8b7e2d5	update readme	2022-03-01 08:41:57 -06:00
efischer	9fb3095f0f	Clarify help text	2022-03-01 08:40:34 -06:00
efischer	25acf920c2	Add version information	2022-03-01 08:34:35 -06:00
efischer	f301327693	Update readme with -graphml flag	2022-03-01 08:24:43 -06:00
efischer	e04d2d6777	Fix typos in help menu	2022-03-01 08:16:06 -06:00
efischer	3e41afaa64	bugfix	2022-02-27 19:08:29 -06:00
efischer	bc5d67680d	Add flag to print metadata to stdout	2022-02-27 17:36:23 -06:00
efischer	f2347e8fc2	check verbose flag	2022-02-27 17:35:50 -06:00
efischer	c8364d8a6e	check verbose flag	2022-02-27 17:34:20 -06:00
efischer	6f5afbc6ec	Update readme with CLI arguments	2022-02-27 17:01:12 -06:00
efischer	fb4d22e7a4	Update readme with CLI arguments	2022-02-27 17:00:54 -06:00
efischer	e10350c214	Update readme with CLI arguments	2022-02-27 16:56:58 -06:00
efischer	b1155f8100	Format -help CLI option	2022-02-27 16:53:46 -06:00
efischer	12b003a69f	Add -help CLI option	2022-02-27 16:45:30 -06:00
efischer	32c5bcaaff	Deactivate file I/O announcement for CLI	2022-02-27 16:16:24 -06:00
efischer	2485ac4cf6	Add getters to MatchingResult	2022-02-27 16:15:26 -06:00
efischer	05556bce0c	Add units to metadata	2022-02-27 16:08:59 -06:00
efischer	a822f69ea4	Control verbose output	2022-02-27 16:07:17 -06:00
efischer	3d1f8668ee	Control verbose output	2022-02-27 16:03:57 -06:00
efischer	40c743308b	Initialize wells	2022-02-27 15:54:47 -06:00
efischer	5246cc4a0c	Re-implement command line options	2022-02-27 15:35:07 -06:00
efischer	a5f7c0641d	Refactor for better encapsulation with CellSamples	2022-02-27 14:51:53 -06:00
efischer	8ebfc1469f	Refactor plate to fill its own wells in its constructor	2022-02-27 14:25:53 -06:00
efischer	b53f5f1cc0	Refactor plate to fill its own wells in its constructor	2022-02-27 14:17:16 -06:00
efischer	974d2d650c	Refactor plate to fill its own wells in its constructor	2022-02-27 14:17:11 -06:00
efischer	6b5837e6ce	Add Vose's alias method to to-dos	2022-02-27 11:46:11 -06:00
efischer	b4cc240048	Update Readme	2022-02-26 11:03:31 -06:00
efischer	ff72c9b359	Update Readme	2022-02-26 11:02:23 -06:00
efischer	88eb8aca50	Update Readme	2022-02-26 11:01:44 -06:00
efischer	98bf452891	Update Readme	2022-02-26 11:01:20 -06:00
efischer	c2db4f87c1	Update Readme	2022-02-26 11:00:18 -06:00
efischer	8935407ade	Get rid of GraphML reader, those files are larger than serialized files	2022-02-26 10:38:10 -06:00
efischer	9fcc20343d	Fix GraphML writer	2022-02-26 10:36:00 -06:00
efischer	e4d094d796	Adding GraphML output to options menu	2022-02-24 17:22:07 -06:00
efischer	f385ebc31f	Update vertex class	2022-02-24 16:25:01 -06:00
efischer	8745550e11	add MWM algorithm type to matching metadata	2022-02-24 16:24:48 -06:00
efischer	41805135b3	remove unused import	2022-02-24 16:04:30 -06:00
efischer	373a5e02f9	Refactor to make CellSample class more self-contained	2022-02-24 16:03:49 -06:00
efischer	7f18311054	fix typos	2022-02-24 15:55:32 -06:00
efischer	bcb816c3e6	Reformat TODO	2022-02-24 15:48:10 -06:00
efischer	dad0fd35fd	Update readme to reflect wells with random population implemented	2022-02-24 15:47:08 -06:00
efischer	35d580cfcf	Update readme to reflect wells with random population implemented	2022-02-24 15:45:03 -06:00
efischer	ab8d98ed81	Update readme to reflect new default caching behavior.	2022-02-24 15:39:15 -06:00
efischer	3d9890e16a	Change GraphModificationFunctions to only save edges if graph data is cached	2022-02-24 15:32:27 -06:00
efischer	dd64ac2731	Change GraphModificationFunctions to interface	2022-02-24 15:18:09 -06:00
efischer	a5238624f1	Change default graph caching behavior to false	2022-02-24 15:14:28 -06:00
efischer	d8ba42b801	Fix Algorithm Options menu output	2022-02-24 14:59:08 -06:00
efischer	8edd89d784	Added heap type selection, fixed error handling	2022-02-24 14:48:19 -06:00
efischer	2829b88689	Update readme to reflect caching changes	2022-02-24 12:47:26 -06:00
efischer	108b0ec13f	Improve options menu wording	2022-02-24 12:42:09 -06:00
efischer	a8b58d3f79	Output new setting when changing options	2022-02-24 12:38:15 -06:00
efischer	bf64d57731	implement option menu for file caching	2022-02-24 12:30:47 -06:00
efischer	c068c3db3c	implement option menu for file caching	2022-02-23 20:35:31 -06:00