Added metadata to MatchingResult to enable CLI options
This commit is contained in:
@@ -131,10 +131,14 @@ public class Simulator {
|
||||
|
||||
Instant stop = Instant.now();
|
||||
Duration time = Duration.between(start, stop);
|
||||
//return GraphWithMapData object
|
||||
return new GraphWithMapData(graph, numWells, samplePlate.getConcentrations(), alphaCount, betaCount,
|
||||
|
||||
//create GraphWithMapData object
|
||||
GraphWithMapData output = new GraphWithMapData(graph, numWells, samplePlate.getPopulations(), alphaCount, betaCount,
|
||||
distCellsMapAlphaKey, plateVtoAMap, plateVtoBMap, plateAtoVMap,
|
||||
plateBtoVMap, alphaWellCounts, betaWellCounts, time);
|
||||
output.setSourceFilename(samplePlate.getSourceFileName());
|
||||
//return GraphWithMapData object
|
||||
return output;
|
||||
}
|
||||
|
||||
//match CDR3s.
|
||||
@@ -233,351 +237,356 @@ public class Simulator {
|
||||
allResults.add(result);
|
||||
}
|
||||
|
||||
//Metadate comments for CSV file
|
||||
//Metadata comments for CSV file
|
||||
int min = Math.min(alphaCount, betaCount);
|
||||
double attemptRate = (double) (trueCount + falseCount) / min;
|
||||
BigDecimal attemptRateTrunc = new BigDecimal(attemptRate, mc);
|
||||
double pairingErrorRate = (double) falseCount / (trueCount + falseCount);
|
||||
BigDecimal pairingErrorRateTrunc = new BigDecimal(pairingErrorRate, mc);
|
||||
//get list of well concentrations
|
||||
List<Integer> wellConcentrations = Arrays.asList(data.getWellConcentrations());
|
||||
List<Integer> wellPopulations = Arrays.asList(data.getWellConcentrations());
|
||||
//make string out of concentrations list
|
||||
StringBuilder concentrationStringBuilder = new StringBuilder();
|
||||
for(Integer i: wellConcentrations){
|
||||
concentrationStringBuilder.append(i.toString());
|
||||
concentrationStringBuilder.append(" ");
|
||||
StringBuilder populationsStringBuilder = new StringBuilder();
|
||||
populationsStringBuilder.append(wellPopulations.remove(0).toString());
|
||||
for(Integer i: wellPopulations){
|
||||
populationsStringBuilder.append(", ");
|
||||
populationsStringBuilder.append(i.toString());
|
||||
}
|
||||
String concentrationString = concentrationStringBuilder.toString();
|
||||
|
||||
List<String> comments = new ArrayList<>();
|
||||
comments.add("Source Sample Plate filename: " + data.getSourceFilename());
|
||||
comments.add("Source Graph and Data filename: " + dataFilename);
|
||||
comments.add("T cell counts in sample plate wells: " + concentrationString);
|
||||
comments.add("Total alphas found: " + alphaCount);
|
||||
comments.add("Total betas found: " + betaCount);
|
||||
comments.add("High overlap threshold: " + highThreshold);
|
||||
comments.add("Low overlap threshold: " + lowThreshold);
|
||||
comments.add("Minimum overlap percent: " + minOverlapPercent);
|
||||
comments.add("Maximum occupancy difference: " + maxOccupancyDifference);
|
||||
comments.add("Pairing attempt rate: " + attemptRateTrunc);
|
||||
comments.add("Correct pairings: " + trueCount);
|
||||
comments.add("Incorrect pairings: " + falseCount);
|
||||
comments.add("Pairing error rate: " + pairingErrorRateTrunc);
|
||||
String wellPopulationsString = populationsStringBuilder.toString();
|
||||
//total simulation time
|
||||
Duration time = Duration.between(start, stop);
|
||||
time = time.plus(data.getTime());
|
||||
comments.add("Simulation time: " + nf.format(time.toSeconds()) + " seconds");
|
||||
|
||||
Map<String, String> metadata = new LinkedHashMap<>();
|
||||
metadata.put("sample plate filename", data.getSourceFilename());
|
||||
metadata.put("graph filename", dataFilename);
|
||||
metadata.put("well populations", wellPopulationsString);
|
||||
metadata.put("total alphas found", alphaCount.toString());
|
||||
metadata.put("total betas found", betaCount.toString());
|
||||
metadata.put("high overlap threshold", highThreshold.toString());
|
||||
metadata.put("low overlap threshold", lowThreshold.toString());
|
||||
metadata.put("maximum occupancy difference", maxOccupancyDifference.toString());
|
||||
metadata.put("minimum overlap percent", minOverlapPercent.toString());
|
||||
metadata.put("pairing attempt rate", attemptRateTrunc.toString());
|
||||
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()));
|
||||
|
||||
MatchingResult output = new MatchingResult(data.getSourceFilename(), metadata, header, allResults, matchMap, time);
|
||||
if(verbose){
|
||||
for(String s: comments){
|
||||
for(String s: output.getComments()){
|
||||
System.out.println(s);
|
||||
}
|
||||
}
|
||||
return new MatchingResult(data.getSourceFilename(), comments, header, allResults, matchMap, time);
|
||||
}
|
||||
|
||||
//Simulated matching of CDR1s to CDR3s. Requires MatchingResult from prior run of matchCDR3s.
|
||||
public static MatchingResult[] matchCDR1s(List<Integer[]> distinctCells,
|
||||
Plate samplePlate, Integer lowThreshold,
|
||||
Integer highThreshold, MatchingResult priorResult){
|
||||
Instant start = Instant.now();
|
||||
Duration previousTime = priorResult.getTime();
|
||||
Map<Integer, Integer> previousMatches = priorResult.getMatchMap();
|
||||
int numWells = samplePlate.getSize();
|
||||
int[] cdr3Indices = {cdr3AlphaIndex, cdr3BetaIndex};
|
||||
int[] cdr1Indices = {cdr1AlphaIndex, cdr1BetaIndex};
|
||||
|
||||
System.out.println("Making previous match maps");
|
||||
Map<Integer, Integer> cdr3AtoBMap = previousMatches;
|
||||
Map<Integer, Integer> cdr3BtoAMap = invertVertexMap(cdr3AtoBMap);
|
||||
System.out.println("Previous match maps made");
|
||||
|
||||
System.out.println("Making cell maps");
|
||||
Map<Integer, Integer> alphaCDR3toCDR1Map = makeSequenceToSequenceMap(distinctCells, cdr3AlphaIndex, cdr1AlphaIndex);
|
||||
Map<Integer, Integer> betaCDR3toCDR1Map = makeSequenceToSequenceMap(distinctCells, cdr3BetaIndex, cdr1BetaIndex);
|
||||
System.out.println("Cell maps made");
|
||||
|
||||
System.out.println("Making well maps");
|
||||
Map<Integer, Integer> allCDR3s = samplePlate.assayWellsSequenceS(cdr3Indices);
|
||||
Map<Integer, Integer> allCDR1s = samplePlate.assayWellsSequenceS(cdr1Indices);
|
||||
int CDR3Count = allCDR3s.size();
|
||||
System.out.println("all CDR3s count: " + CDR3Count);
|
||||
int CDR1Count = allCDR1s.size();
|
||||
System.out.println("all CDR1s count: " + CDR1Count);
|
||||
System.out.println("Well maps made");
|
||||
|
||||
System.out.println("Removing unpaired CDR3s from well maps");
|
||||
List<Integer> unpairedCDR3s = new ArrayList<>();
|
||||
for(Integer i: allCDR3s.keySet()){
|
||||
if(!(cdr3AtoBMap.containsKey(i) || cdr3BtoAMap.containsKey(i))){
|
||||
unpairedCDR3s.add(i);
|
||||
}
|
||||
}
|
||||
for(Integer i: unpairedCDR3s){
|
||||
allCDR3s.remove(i);
|
||||
}
|
||||
System.out.println("Unpaired CDR3s removed.");
|
||||
System.out.println("Remaining CDR3 count: " + allCDR3s.size());
|
||||
|
||||
System.out.println("Removing below-minimum-overlap-threshold and saturating-occupancy CDR1s");
|
||||
filterByOccupancyThreshold(allCDR1s, lowThreshold, numWells - 1);
|
||||
System.out.println("CDR1s removed.");
|
||||
System.out.println("Remaining CDR1 count: " + allCDR1s.size());
|
||||
|
||||
System.out.println("Making vertex maps");
|
||||
|
||||
//For the SimpleWeightedBipartiteGraphMatrixGenerator, all vertices must have
|
||||
// distinct numbers associated with them. Since I'm using a 2D array, that means
|
||||
// distinct indices between the rows and columns. vertexStartValue lets me track where I switch
|
||||
// from numbering rows to columns, so I can assign unique numbers to every vertex, and then
|
||||
// subtract the vertexStartValue from CDR1s to use their vertex labels as array indices
|
||||
Integer vertexStartValue = 0;
|
||||
//keys are sequential integer vertices, values are CDR3s
|
||||
Map<Integer, Integer> plateVtoCDR3Map = makeVertexToSequenceMap(allCDR3s, vertexStartValue);
|
||||
//New start value for vertex to CDR1 map should be one more than final vertex value in CDR3 map
|
||||
vertexStartValue += plateVtoCDR3Map.size();
|
||||
//keys are sequential integers vertices, values are CDR1s
|
||||
Map<Integer, Integer> plateVtoCDR1Map = makeVertexToSequenceMap(allCDR1s, vertexStartValue);
|
||||
//keys are CDR3s, values are sequential integer vertices from previous map
|
||||
Map<Integer, Integer> plateCDR3toVMap = invertVertexMap(plateVtoCDR3Map);
|
||||
//keys are CDR1s, values are sequential integer vertices from previous map
|
||||
Map<Integer, Integer> plateCDR1toVMap = invertVertexMap(plateVtoCDR1Map);
|
||||
System.out.println("Vertex maps made");
|
||||
|
||||
System.out.println("Creating adjacency matrix");
|
||||
//Count how many wells each CDR3 appears in
|
||||
Map<Integer, Integer> cdr3WellCounts = new HashMap<>();
|
||||
//count how many wells each CDR1 appears in
|
||||
Map<Integer, Integer> cdr1WellCounts = new HashMap<>();
|
||||
//add edges, where weights are number of wells the peptides share in common.
|
||||
//If this is too slow, can make a 2d array and use the SimpleWeightedGraphMatrixGenerator class
|
||||
Map<Integer, Integer> wellNCDR3s = null;
|
||||
Map<Integer, Integer> wellNCDR1s = null;
|
||||
double[][] weights = new double[plateVtoCDR3Map.size()][plateVtoCDR1Map.size()];
|
||||
countSequencesAndFillMatrix(samplePlate, allCDR3s, allCDR1s, plateCDR3toVMap, plateCDR1toVMap,
|
||||
cdr3Indices, cdr1Indices, cdr3WellCounts, cdr1WellCounts, weights);
|
||||
System.out.println("Matrix created");
|
||||
|
||||
System.out.println("Creating graph");
|
||||
SimpleWeightedGraph<Integer, DefaultWeightedEdge> graph =
|
||||
new SimpleWeightedGraph<>(DefaultWeightedEdge.class);
|
||||
|
||||
SimpleWeightedBipartiteGraphMatrixGenerator graphGenerator = new SimpleWeightedBipartiteGraphMatrixGenerator();
|
||||
List<Integer> cdr3Vertices = new ArrayList<>(plateVtoCDR3Map.keySet()); //This will work because LinkedHashMap preserves order of entry
|
||||
graphGenerator.first(cdr3Vertices);
|
||||
List<Integer> cdr1Vertices = new ArrayList<>(plateVtoCDR1Map.keySet());
|
||||
graphGenerator.second(cdr1Vertices); //This will work because LinkedHashMap preserves order of entry
|
||||
graphGenerator.weights(weights);
|
||||
graphGenerator.generateGraph(graph);
|
||||
System.out.println("Graph created");
|
||||
|
||||
System.out.println("Removing edges outside of weight thresholds");
|
||||
filterByOccupancyThreshold(graph, lowThreshold, highThreshold);
|
||||
System.out.println("Over- and under-weight edges set to 0.0");
|
||||
|
||||
System.out.println("Finding first maximum weighted matching");
|
||||
MaximumWeightBipartiteMatching firstMaxWeightMatching =
|
||||
new MaximumWeightBipartiteMatching(graph, plateVtoCDR3Map.keySet(), plateVtoCDR1Map.keySet());
|
||||
MatchingAlgorithm.Matching<String, DefaultWeightedEdge> graphMatching = firstMaxWeightMatching.getMatching();
|
||||
System.out.println("First maximum weighted matching found");
|
||||
|
||||
|
||||
//first processing run
|
||||
Map<Integer, Integer> firstMatchCDR3toCDR1Map = new HashMap<>();
|
||||
Iterator<DefaultWeightedEdge> weightIter = graphMatching.iterator();
|
||||
DefaultWeightedEdge e;
|
||||
while(weightIter.hasNext()){
|
||||
e = weightIter.next();
|
||||
// if(graph.getEdgeWeight(e) < lowThreshold || graph.getEdgeWeight(e) > highThreshold) {
|
||||
// continue;
|
||||
// }
|
||||
Integer source = graph.getEdgeSource(e);
|
||||
Integer target = graph.getEdgeTarget(e);
|
||||
firstMatchCDR3toCDR1Map.put(plateVtoCDR3Map.get(source), plateVtoCDR1Map.get(target));
|
||||
}
|
||||
System.out.println("First pass matches: " + firstMatchCDR3toCDR1Map.size());
|
||||
|
||||
System.out.println("Removing edges from first maximum weighted matching");
|
||||
//zero out the edge weights in the matching
|
||||
weightIter = graphMatching.iterator();
|
||||
while(weightIter.hasNext()){
|
||||
graph.removeEdge(weightIter.next());
|
||||
}
|
||||
System.out.println("Edges removed");
|
||||
|
||||
//Generate a new matching
|
||||
System.out.println("Finding second maximum weighted matching");
|
||||
MaximumWeightBipartiteMatching secondMaxWeightMatching =
|
||||
new MaximumWeightBipartiteMatching(graph, plateVtoCDR3Map.keySet(), plateVtoCDR1Map.keySet());
|
||||
graphMatching = secondMaxWeightMatching.getMatching();
|
||||
System.out.println("Second maximum weighted matching found");
|
||||
|
||||
|
||||
//second processing run
|
||||
Map<Integer, Integer> secondMatchCDR3toCDR1Map = new HashMap<>();
|
||||
weightIter = graphMatching.iterator();
|
||||
while(weightIter.hasNext()){
|
||||
e = weightIter.next();
|
||||
// if(graph.getEdgeWeight(e) < lowThreshold || graph.getEdgeWeight(e) > highThreshold) {
|
||||
// continue;
|
||||
// }
|
||||
Integer source = graph.getEdgeSource(e);
|
||||
// if(!(CDR3AtoBMap.containsKey(source) || CDR3BtoAMap.containsKey(source))){
|
||||
// continue;
|
||||
// }
|
||||
Integer target = graph.getEdgeTarget(e);
|
||||
secondMatchCDR3toCDR1Map.put(plateVtoCDR3Map.get(source), plateVtoCDR1Map.get(target));
|
||||
}
|
||||
System.out.println("Second pass matches: " + secondMatchCDR3toCDR1Map.size());
|
||||
|
||||
System.out.println("Mapping first pass CDR3 alpha/beta pairs");
|
||||
//get linked map for first matching attempt
|
||||
Map<Integer, Integer> firstMatchesMap = new LinkedHashMap<>();
|
||||
for(Integer alphaCDR3: cdr3AtoBMap.keySet()) {
|
||||
if (!(firstMatchCDR3toCDR1Map.containsKey(alphaCDR3))) {
|
||||
continue;
|
||||
}
|
||||
Integer betaCDR3 = cdr3AtoBMap.get(alphaCDR3);
|
||||
if (!(firstMatchCDR3toCDR1Map.containsKey(betaCDR3))) {
|
||||
continue;
|
||||
}
|
||||
firstMatchesMap.put(alphaCDR3, firstMatchCDR3toCDR1Map.get(alphaCDR3));
|
||||
firstMatchesMap.put(betaCDR3, firstMatchCDR3toCDR1Map.get(betaCDR3));
|
||||
}
|
||||
System.out.println("First pass CDR3 alpha/beta pairs mapped");
|
||||
|
||||
System.out.println("Mapping second pass CDR3 alpha/beta pairs.");
|
||||
System.out.println("Finding CDR3 pairs that swapped CDR1 matches between first pass and second pass.");
|
||||
//Look for matches that simply swapped already-matched alpha and beta CDR3s
|
||||
Map<Integer, Integer> dualMatchesMap = new LinkedHashMap<>();
|
||||
for(Integer alphaCDR3: cdr3AtoBMap.keySet()) {
|
||||
if (!(firstMatchCDR3toCDR1Map.containsKey(alphaCDR3) && secondMatchCDR3toCDR1Map.containsKey(alphaCDR3))) {
|
||||
continue;
|
||||
}
|
||||
Integer betaCDR3 = cdr3AtoBMap.get(alphaCDR3);
|
||||
if (!(firstMatchCDR3toCDR1Map.containsKey(betaCDR3) && secondMatchCDR3toCDR1Map.containsKey(betaCDR3))) {
|
||||
continue;
|
||||
}
|
||||
if(firstMatchCDR3toCDR1Map.get(alphaCDR3).equals(secondMatchCDR3toCDR1Map.get(betaCDR3))){
|
||||
if(firstMatchCDR3toCDR1Map.get(betaCDR3).equals(secondMatchCDR3toCDR1Map.get(alphaCDR3))){
|
||||
dualMatchesMap.put(alphaCDR3, firstMatchCDR3toCDR1Map.get(alphaCDR3));
|
||||
dualMatchesMap.put(betaCDR3, firstMatchCDR3toCDR1Map.get(betaCDR3));
|
||||
}
|
||||
}
|
||||
}
|
||||
System.out.println("Second pass mapping made. Dual CDR3/CDR1 pairings found.");
|
||||
|
||||
Instant stop = Instant.now();
|
||||
//results for first map
|
||||
System.out.println("RESULTS FOR FIRST PASS MATCHING");
|
||||
List<List<String>> allResults = new ArrayList<>();
|
||||
Integer trueCount = 0;
|
||||
Iterator iter = firstMatchesMap.keySet().iterator();
|
||||
|
||||
while(iter.hasNext()){
|
||||
Boolean proven = false;
|
||||
List<String> tmp = new ArrayList<>();
|
||||
tmp.add(iter.next().toString());
|
||||
tmp.add(iter.next().toString());
|
||||
tmp.add(firstMatchesMap.get(Integer.valueOf(tmp.get(0))).toString());
|
||||
tmp.add(firstMatchesMap.get(Integer.valueOf(tmp.get(1))).toString());
|
||||
if(alphaCDR3toCDR1Map.get(Integer.valueOf(tmp.get(0))).equals(Integer.valueOf(tmp.get(2)))){
|
||||
if(betaCDR3toCDR1Map.get(Integer.valueOf(tmp.get(1))).equals(Integer.valueOf(tmp.get(3)))){
|
||||
proven = true;
|
||||
}
|
||||
}
|
||||
else if(alphaCDR3toCDR1Map.get(Integer.valueOf(tmp.get(0))).equals(Integer.valueOf(tmp.get(3)))){
|
||||
if(betaCDR3toCDR1Map.get(Integer.valueOf(tmp.get(1))).equals(Integer.valueOf(tmp.get(2)))){
|
||||
proven = true;
|
||||
}
|
||||
}
|
||||
tmp.add(proven.toString());
|
||||
allResults.add(tmp);
|
||||
if(proven){
|
||||
trueCount++;
|
||||
}
|
||||
}
|
||||
|
||||
List<String> comments = new ArrayList<>();
|
||||
comments.add("Plate size: " + samplePlate.getSize() + " wells");
|
||||
comments.add("Previous pairs found: " + previousMatches.size());
|
||||
comments.add("CDR1 matches attempted: " + allResults.size());
|
||||
double attemptRate = (double) allResults.size() / previousMatches.size();
|
||||
comments.add("Matching attempt rate: " + attemptRate);
|
||||
comments.add("Number of correct matches: " + trueCount);
|
||||
double correctRate = (double) trueCount / allResults.size();
|
||||
comments.add("Correct matching rate: " + correctRate);
|
||||
NumberFormat nf = NumberFormat.getInstance(Locale.US);
|
||||
Duration time = Duration.between(start, stop);
|
||||
time = time.plus(previousTime);
|
||||
comments.add("Simulation time: " + nf.format(time.toSeconds()) + " seconds");
|
||||
for(String s: comments){
|
||||
System.out.println(s);
|
||||
}
|
||||
|
||||
|
||||
|
||||
List<String> headers = new ArrayList<>();
|
||||
headers.add("CDR3 alpha");
|
||||
headers.add("CDR3 beta");
|
||||
headers.add("first matched CDR1");
|
||||
headers.add("second matched CDR1");
|
||||
headers.add("Correct match?");
|
||||
|
||||
MatchingResult firstTest = new MatchingResult(samplePlate.getSourceFileName(),
|
||||
comments, headers, allResults, dualMatchesMap, time);
|
||||
|
||||
//results for dual map
|
||||
System.out.println("RESULTS FOR SECOND PASS MATCHING");
|
||||
allResults = new ArrayList<>();
|
||||
trueCount = 0;
|
||||
iter = dualMatchesMap.keySet().iterator();
|
||||
while(iter.hasNext()){
|
||||
Boolean proven = false;
|
||||
List<String> tmp = new ArrayList<>();
|
||||
tmp.add(iter.next().toString());
|
||||
tmp.add(iter.next().toString());
|
||||
tmp.add(dualMatchesMap.get(Integer.valueOf(tmp.get(0))).toString());
|
||||
tmp.add(dualMatchesMap.get(Integer.valueOf(tmp.get(1))).toString());
|
||||
if(alphaCDR3toCDR1Map.get(Integer.valueOf(tmp.get(0))).equals(Integer.valueOf(tmp.get(2)))){
|
||||
if(betaCDR3toCDR1Map.get(Integer.valueOf(tmp.get(1))).equals(Integer.valueOf(tmp.get(3)))){
|
||||
proven = true;
|
||||
}
|
||||
}
|
||||
else if(alphaCDR3toCDR1Map.get(Integer.valueOf(tmp.get(0))).equals(Integer.valueOf(tmp.get(3)))){
|
||||
if(betaCDR3toCDR1Map.get(Integer.valueOf(tmp.get(1))).equals(Integer.valueOf(tmp.get(2)))){
|
||||
proven = true;
|
||||
}
|
||||
}
|
||||
tmp.add(proven.toString());
|
||||
allResults.add(tmp);
|
||||
if(proven){
|
||||
trueCount++;
|
||||
}
|
||||
}
|
||||
|
||||
comments = new ArrayList<>();
|
||||
comments.add("Plate size: " + samplePlate.getSize() + " wells");
|
||||
comments.add("Previous pairs found: " + previousMatches.size());
|
||||
comments.add("High overlap threshold: " + highThreshold);
|
||||
comments.add("Low overlap threshold: " + lowThreshold);
|
||||
comments.add("CDR1 matches attempted: " + allResults.size());
|
||||
attemptRate = (double) allResults.size() / previousMatches.size();
|
||||
comments.add("Matching attempt rate: " + attemptRate);
|
||||
comments.add("Number of correct matches: " + trueCount);
|
||||
correctRate = (double) trueCount / allResults.size();
|
||||
comments.add("Correct matching rate: " + correctRate);
|
||||
comments.add("Simulation time: " + nf.format(time.toSeconds()) + " seconds");
|
||||
|
||||
for(String s: comments){
|
||||
System.out.println(s);
|
||||
}
|
||||
|
||||
System.out.println("Simulation time: " + nf.format(time.toSeconds()) + " seconds");
|
||||
MatchingResult dualTest = new MatchingResult(samplePlate.getSourceFileName(), comments, headers,
|
||||
allResults, dualMatchesMap, time);
|
||||
MatchingResult[] output = {firstTest, dualTest};
|
||||
return output;
|
||||
}
|
||||
|
||||
//Commented out CDR1 matching until it's time to re-implement it
|
||||
// //Simulated matching of CDR1s to CDR3s. Requires MatchingResult from prior run of matchCDR3s.
|
||||
// public static MatchingResult[] matchCDR1s(List<Integer[]> distinctCells,
|
||||
// Plate samplePlate, Integer lowThreshold,
|
||||
// Integer highThreshold, MatchingResult priorResult){
|
||||
// Instant start = Instant.now();
|
||||
// Duration previousTime = priorResult.getTime();
|
||||
// Map<Integer, Integer> previousMatches = priorResult.getMatchMap();
|
||||
// int numWells = samplePlate.getSize();
|
||||
// int[] cdr3Indices = {cdr3AlphaIndex, cdr3BetaIndex};
|
||||
// int[] cdr1Indices = {cdr1AlphaIndex, cdr1BetaIndex};
|
||||
//
|
||||
// System.out.println("Making previous match maps");
|
||||
// Map<Integer, Integer> cdr3AtoBMap = previousMatches;
|
||||
// Map<Integer, Integer> cdr3BtoAMap = invertVertexMap(cdr3AtoBMap);
|
||||
// System.out.println("Previous match maps made");
|
||||
//
|
||||
// System.out.println("Making cell maps");
|
||||
// Map<Integer, Integer> alphaCDR3toCDR1Map = makeSequenceToSequenceMap(distinctCells, cdr3AlphaIndex, cdr1AlphaIndex);
|
||||
// Map<Integer, Integer> betaCDR3toCDR1Map = makeSequenceToSequenceMap(distinctCells, cdr3BetaIndex, cdr1BetaIndex);
|
||||
// System.out.println("Cell maps made");
|
||||
//
|
||||
// System.out.println("Making well maps");
|
||||
// Map<Integer, Integer> allCDR3s = samplePlate.assayWellsSequenceS(cdr3Indices);
|
||||
// Map<Integer, Integer> allCDR1s = samplePlate.assayWellsSequenceS(cdr1Indices);
|
||||
// int CDR3Count = allCDR3s.size();
|
||||
// System.out.println("all CDR3s count: " + CDR3Count);
|
||||
// int CDR1Count = allCDR1s.size();
|
||||
// System.out.println("all CDR1s count: " + CDR1Count);
|
||||
// System.out.println("Well maps made");
|
||||
//
|
||||
// System.out.println("Removing unpaired CDR3s from well maps");
|
||||
// List<Integer> unpairedCDR3s = new ArrayList<>();
|
||||
// for(Integer i: allCDR3s.keySet()){
|
||||
// if(!(cdr3AtoBMap.containsKey(i) || cdr3BtoAMap.containsKey(i))){
|
||||
// unpairedCDR3s.add(i);
|
||||
// }
|
||||
// }
|
||||
// for(Integer i: unpairedCDR3s){
|
||||
// allCDR3s.remove(i);
|
||||
// }
|
||||
// System.out.println("Unpaired CDR3s removed.");
|
||||
// System.out.println("Remaining CDR3 count: " + allCDR3s.size());
|
||||
//
|
||||
// System.out.println("Removing below-minimum-overlap-threshold and saturating-occupancy CDR1s");
|
||||
// filterByOccupancyThreshold(allCDR1s, lowThreshold, numWells - 1);
|
||||
// System.out.println("CDR1s removed.");
|
||||
// System.out.println("Remaining CDR1 count: " + allCDR1s.size());
|
||||
//
|
||||
// System.out.println("Making vertex maps");
|
||||
//
|
||||
// //For the SimpleWeightedBipartiteGraphMatrixGenerator, all vertices must have
|
||||
// // distinct numbers associated with them. Since I'm using a 2D array, that means
|
||||
// // distinct indices between the rows and columns. vertexStartValue lets me track where I switch
|
||||
// // from numbering rows to columns, so I can assign unique numbers to every vertex, and then
|
||||
// // subtract the vertexStartValue from CDR1s to use their vertex labels as array indices
|
||||
// Integer vertexStartValue = 0;
|
||||
// //keys are sequential integer vertices, values are CDR3s
|
||||
// Map<Integer, Integer> plateVtoCDR3Map = makeVertexToSequenceMap(allCDR3s, vertexStartValue);
|
||||
// //New start value for vertex to CDR1 map should be one more than final vertex value in CDR3 map
|
||||
// vertexStartValue += plateVtoCDR3Map.size();
|
||||
// //keys are sequential integers vertices, values are CDR1s
|
||||
// Map<Integer, Integer> plateVtoCDR1Map = makeVertexToSequenceMap(allCDR1s, vertexStartValue);
|
||||
// //keys are CDR3s, values are sequential integer vertices from previous map
|
||||
// Map<Integer, Integer> plateCDR3toVMap = invertVertexMap(plateVtoCDR3Map);
|
||||
// //keys are CDR1s, values are sequential integer vertices from previous map
|
||||
// Map<Integer, Integer> plateCDR1toVMap = invertVertexMap(plateVtoCDR1Map);
|
||||
// System.out.println("Vertex maps made");
|
||||
//
|
||||
// System.out.println("Creating adjacency matrix");
|
||||
// //Count how many wells each CDR3 appears in
|
||||
// Map<Integer, Integer> cdr3WellCounts = new HashMap<>();
|
||||
// //count how many wells each CDR1 appears in
|
||||
// Map<Integer, Integer> cdr1WellCounts = new HashMap<>();
|
||||
// //add edges, where weights are number of wells the peptides share in common.
|
||||
// //If this is too slow, can make a 2d array and use the SimpleWeightedGraphMatrixGenerator class
|
||||
// Map<Integer, Integer> wellNCDR3s = null;
|
||||
// Map<Integer, Integer> wellNCDR1s = null;
|
||||
// double[][] weights = new double[plateVtoCDR3Map.size()][plateVtoCDR1Map.size()];
|
||||
// countSequencesAndFillMatrix(samplePlate, allCDR3s, allCDR1s, plateCDR3toVMap, plateCDR1toVMap,
|
||||
// cdr3Indices, cdr1Indices, cdr3WellCounts, cdr1WellCounts, weights);
|
||||
// System.out.println("Matrix created");
|
||||
//
|
||||
// System.out.println("Creating graph");
|
||||
// SimpleWeightedGraph<Integer, DefaultWeightedEdge> graph =
|
||||
// new SimpleWeightedGraph<>(DefaultWeightedEdge.class);
|
||||
//
|
||||
// SimpleWeightedBipartiteGraphMatrixGenerator graphGenerator = new SimpleWeightedBipartiteGraphMatrixGenerator();
|
||||
// List<Integer> cdr3Vertices = new ArrayList<>(plateVtoCDR3Map.keySet()); //This will work because LinkedHashMap preserves order of entry
|
||||
// graphGenerator.first(cdr3Vertices);
|
||||
// List<Integer> cdr1Vertices = new ArrayList<>(plateVtoCDR1Map.keySet());
|
||||
// graphGenerator.second(cdr1Vertices); //This will work because LinkedHashMap preserves order of entry
|
||||
// graphGenerator.weights(weights);
|
||||
// graphGenerator.generateGraph(graph);
|
||||
// System.out.println("Graph created");
|
||||
//
|
||||
// System.out.println("Removing edges outside of weight thresholds");
|
||||
// filterByOccupancyThreshold(graph, lowThreshold, highThreshold);
|
||||
// System.out.println("Over- and under-weight edges set to 0.0");
|
||||
//
|
||||
// System.out.println("Finding first maximum weighted matching");
|
||||
// MaximumWeightBipartiteMatching firstMaxWeightMatching =
|
||||
// new MaximumWeightBipartiteMatching(graph, plateVtoCDR3Map.keySet(), plateVtoCDR1Map.keySet());
|
||||
// MatchingAlgorithm.Matching<String, DefaultWeightedEdge> graphMatching = firstMaxWeightMatching.getMatching();
|
||||
// System.out.println("First maximum weighted matching found");
|
||||
//
|
||||
//
|
||||
// //first processing run
|
||||
// Map<Integer, Integer> firstMatchCDR3toCDR1Map = new HashMap<>();
|
||||
// Iterator<DefaultWeightedEdge> weightIter = graphMatching.iterator();
|
||||
// DefaultWeightedEdge e;
|
||||
// while(weightIter.hasNext()){
|
||||
// e = weightIter.next();
|
||||
//// if(graph.getEdgeWeight(e) < lowThreshold || graph.getEdgeWeight(e) > highThreshold) {
|
||||
//// continue;
|
||||
//// }
|
||||
// Integer source = graph.getEdgeSource(e);
|
||||
// Integer target = graph.getEdgeTarget(e);
|
||||
// firstMatchCDR3toCDR1Map.put(plateVtoCDR3Map.get(source), plateVtoCDR1Map.get(target));
|
||||
// }
|
||||
// System.out.println("First pass matches: " + firstMatchCDR3toCDR1Map.size());
|
||||
//
|
||||
// System.out.println("Removing edges from first maximum weighted matching");
|
||||
// //zero out the edge weights in the matching
|
||||
// weightIter = graphMatching.iterator();
|
||||
// while(weightIter.hasNext()){
|
||||
// graph.removeEdge(weightIter.next());
|
||||
// }
|
||||
// System.out.println("Edges removed");
|
||||
//
|
||||
// //Generate a new matching
|
||||
// System.out.println("Finding second maximum weighted matching");
|
||||
// MaximumWeightBipartiteMatching secondMaxWeightMatching =
|
||||
// new MaximumWeightBipartiteMatching(graph, plateVtoCDR3Map.keySet(), plateVtoCDR1Map.keySet());
|
||||
// graphMatching = secondMaxWeightMatching.getMatching();
|
||||
// System.out.println("Second maximum weighted matching found");
|
||||
//
|
||||
//
|
||||
// //second processing run
|
||||
// Map<Integer, Integer> secondMatchCDR3toCDR1Map = new HashMap<>();
|
||||
// weightIter = graphMatching.iterator();
|
||||
// while(weightIter.hasNext()){
|
||||
// e = weightIter.next();
|
||||
//// if(graph.getEdgeWeight(e) < lowThreshold || graph.getEdgeWeight(e) > highThreshold) {
|
||||
//// continue;
|
||||
//// }
|
||||
// Integer source = graph.getEdgeSource(e);
|
||||
//// if(!(CDR3AtoBMap.containsKey(source) || CDR3BtoAMap.containsKey(source))){
|
||||
//// continue;
|
||||
//// }
|
||||
// Integer target = graph.getEdgeTarget(e);
|
||||
// secondMatchCDR3toCDR1Map.put(plateVtoCDR3Map.get(source), plateVtoCDR1Map.get(target));
|
||||
// }
|
||||
// System.out.println("Second pass matches: " + secondMatchCDR3toCDR1Map.size());
|
||||
//
|
||||
// System.out.println("Mapping first pass CDR3 alpha/beta pairs");
|
||||
// //get linked map for first matching attempt
|
||||
// Map<Integer, Integer> firstMatchesMap = new LinkedHashMap<>();
|
||||
// for(Integer alphaCDR3: cdr3AtoBMap.keySet()) {
|
||||
// if (!(firstMatchCDR3toCDR1Map.containsKey(alphaCDR3))) {
|
||||
// continue;
|
||||
// }
|
||||
// Integer betaCDR3 = cdr3AtoBMap.get(alphaCDR3);
|
||||
// if (!(firstMatchCDR3toCDR1Map.containsKey(betaCDR3))) {
|
||||
// continue;
|
||||
// }
|
||||
// firstMatchesMap.put(alphaCDR3, firstMatchCDR3toCDR1Map.get(alphaCDR3));
|
||||
// firstMatchesMap.put(betaCDR3, firstMatchCDR3toCDR1Map.get(betaCDR3));
|
||||
// }
|
||||
// System.out.println("First pass CDR3 alpha/beta pairs mapped");
|
||||
//
|
||||
// System.out.println("Mapping second pass CDR3 alpha/beta pairs.");
|
||||
// System.out.println("Finding CDR3 pairs that swapped CDR1 matches between first pass and second pass.");
|
||||
// //Look for matches that simply swapped already-matched alpha and beta CDR3s
|
||||
// Map<Integer, Integer> dualMatchesMap = new LinkedHashMap<>();
|
||||
// for(Integer alphaCDR3: cdr3AtoBMap.keySet()) {
|
||||
// if (!(firstMatchCDR3toCDR1Map.containsKey(alphaCDR3) && secondMatchCDR3toCDR1Map.containsKey(alphaCDR3))) {
|
||||
// continue;
|
||||
// }
|
||||
// Integer betaCDR3 = cdr3AtoBMap.get(alphaCDR3);
|
||||
// if (!(firstMatchCDR3toCDR1Map.containsKey(betaCDR3) && secondMatchCDR3toCDR1Map.containsKey(betaCDR3))) {
|
||||
// continue;
|
||||
// }
|
||||
// if(firstMatchCDR3toCDR1Map.get(alphaCDR3).equals(secondMatchCDR3toCDR1Map.get(betaCDR3))){
|
||||
// if(firstMatchCDR3toCDR1Map.get(betaCDR3).equals(secondMatchCDR3toCDR1Map.get(alphaCDR3))){
|
||||
// dualMatchesMap.put(alphaCDR3, firstMatchCDR3toCDR1Map.get(alphaCDR3));
|
||||
// dualMatchesMap.put(betaCDR3, firstMatchCDR3toCDR1Map.get(betaCDR3));
|
||||
// }
|
||||
// }
|
||||
// }
|
||||
// System.out.println("Second pass mapping made. Dual CDR3/CDR1 pairings found.");
|
||||
//
|
||||
// Instant stop = Instant.now();
|
||||
// //results for first map
|
||||
// System.out.println("RESULTS FOR FIRST PASS MATCHING");
|
||||
// List<List<String>> allResults = new ArrayList<>();
|
||||
// Integer trueCount = 0;
|
||||
// Iterator iter = firstMatchesMap.keySet().iterator();
|
||||
//
|
||||
// while(iter.hasNext()){
|
||||
// Boolean proven = false;
|
||||
// List<String> tmp = new ArrayList<>();
|
||||
// tmp.add(iter.next().toString());
|
||||
// tmp.add(iter.next().toString());
|
||||
// tmp.add(firstMatchesMap.get(Integer.valueOf(tmp.get(0))).toString());
|
||||
// tmp.add(firstMatchesMap.get(Integer.valueOf(tmp.get(1))).toString());
|
||||
// if(alphaCDR3toCDR1Map.get(Integer.valueOf(tmp.get(0))).equals(Integer.valueOf(tmp.get(2)))){
|
||||
// if(betaCDR3toCDR1Map.get(Integer.valueOf(tmp.get(1))).equals(Integer.valueOf(tmp.get(3)))){
|
||||
// proven = true;
|
||||
// }
|
||||
// }
|
||||
// else if(alphaCDR3toCDR1Map.get(Integer.valueOf(tmp.get(0))).equals(Integer.valueOf(tmp.get(3)))){
|
||||
// if(betaCDR3toCDR1Map.get(Integer.valueOf(tmp.get(1))).equals(Integer.valueOf(tmp.get(2)))){
|
||||
// proven = true;
|
||||
// }
|
||||
// }
|
||||
// tmp.add(proven.toString());
|
||||
// allResults.add(tmp);
|
||||
// if(proven){
|
||||
// trueCount++;
|
||||
// }
|
||||
// }
|
||||
//
|
||||
// List<String> comments = new ArrayList<>();
|
||||
// comments.add("Plate size: " + samplePlate.getSize() + " wells");
|
||||
// comments.add("Previous pairs found: " + previousMatches.size());
|
||||
// comments.add("CDR1 matches attempted: " + allResults.size());
|
||||
// double attemptRate = (double) allResults.size() / previousMatches.size();
|
||||
// comments.add("Matching attempt rate: " + attemptRate);
|
||||
// comments.add("Number of correct matches: " + trueCount);
|
||||
// double correctRate = (double) trueCount / allResults.size();
|
||||
// comments.add("Correct matching rate: " + correctRate);
|
||||
// NumberFormat nf = NumberFormat.getInstance(Locale.US);
|
||||
// Duration time = Duration.between(start, stop);
|
||||
// time = time.plus(previousTime);
|
||||
// comments.add("Simulation time: " + nf.format(time.toSeconds()) + " seconds");
|
||||
// for(String s: comments){
|
||||
// System.out.println(s);
|
||||
// }
|
||||
//
|
||||
//
|
||||
//
|
||||
// List<String> headers = new ArrayList<>();
|
||||
// headers.add("CDR3 alpha");
|
||||
// headers.add("CDR3 beta");
|
||||
// headers.add("first matched CDR1");
|
||||
// headers.add("second matched CDR1");
|
||||
// headers.add("Correct match?");
|
||||
//
|
||||
// MatchingResult firstTest = new MatchingResult(samplePlate.getSourceFileName(),
|
||||
// comments, headers, allResults, dualMatchesMap, time);
|
||||
//
|
||||
// //results for dual map
|
||||
// System.out.println("RESULTS FOR SECOND PASS MATCHING");
|
||||
// allResults = new ArrayList<>();
|
||||
// trueCount = 0;
|
||||
// iter = dualMatchesMap.keySet().iterator();
|
||||
// while(iter.hasNext()){
|
||||
// Boolean proven = false;
|
||||
// List<String> tmp = new ArrayList<>();
|
||||
// tmp.add(iter.next().toString());
|
||||
// tmp.add(iter.next().toString());
|
||||
// tmp.add(dualMatchesMap.get(Integer.valueOf(tmp.get(0))).toString());
|
||||
// tmp.add(dualMatchesMap.get(Integer.valueOf(tmp.get(1))).toString());
|
||||
// if(alphaCDR3toCDR1Map.get(Integer.valueOf(tmp.get(0))).equals(Integer.valueOf(tmp.get(2)))){
|
||||
// if(betaCDR3toCDR1Map.get(Integer.valueOf(tmp.get(1))).equals(Integer.valueOf(tmp.get(3)))){
|
||||
// proven = true;
|
||||
// }
|
||||
// }
|
||||
// else if(alphaCDR3toCDR1Map.get(Integer.valueOf(tmp.get(0))).equals(Integer.valueOf(tmp.get(3)))){
|
||||
// if(betaCDR3toCDR1Map.get(Integer.valueOf(tmp.get(1))).equals(Integer.valueOf(tmp.get(2)))){
|
||||
// proven = true;
|
||||
// }
|
||||
// }
|
||||
// tmp.add(proven.toString());
|
||||
// allResults.add(tmp);
|
||||
// if(proven){
|
||||
// trueCount++;
|
||||
// }
|
||||
// }
|
||||
//
|
||||
// comments = new ArrayList<>();
|
||||
// comments.add("Plate size: " + samplePlate.getSize() + " wells");
|
||||
// comments.add("Previous pairs found: " + previousMatches.size());
|
||||
// comments.add("High overlap threshold: " + highThreshold);
|
||||
// comments.add("Low overlap threshold: " + lowThreshold);
|
||||
// comments.add("CDR1 matches attempted: " + allResults.size());
|
||||
// attemptRate = (double) allResults.size() / previousMatches.size();
|
||||
// comments.add("Matching attempt rate: " + attemptRate);
|
||||
// comments.add("Number of correct matches: " + trueCount);
|
||||
// correctRate = (double) trueCount / allResults.size();
|
||||
// comments.add("Correct matching rate: " + correctRate);
|
||||
// comments.add("Simulation time: " + nf.format(time.toSeconds()) + " seconds");
|
||||
//
|
||||
// for(String s: comments){
|
||||
// System.out.println(s);
|
||||
// }
|
||||
//
|
||||
// System.out.println("Simulation time: " + nf.format(time.toSeconds()) + " seconds");
|
||||
// MatchingResult dualTest = new MatchingResult(samplePlate.getSourceFileName(), comments, headers,
|
||||
// allResults, dualMatchesMap, time);
|
||||
// MatchingResult[] output = {firstTest, dualTest};
|
||||
// return output;
|
||||
// }
|
||||
|
||||
|
||||
//Counts the well occupancy of the row peptides and column peptides into given maps, and
|
||||
//fills weights in the given 2D array
|
||||
|
||||
Reference in New Issue
Block a user