initial commit - Fst calculation (just in pairwise distance - method)

Author: JudithNeukamm

build.gradle

@@ -0,0 +1,113 @@
+group 'com.uni-tuebingen.de.it.mitobench.FstCalculator'
+version '0.1.20'
+
+buildscript {
+    repositories {
+        jcenter()
+    }
+    dependencies {
+        classpath 'com.jfrog.bintray.gradle:gradle-bintray-plugin:1.8+'
+    }
+}
+
+allprojects {
+    repositories {
+        jcenter()
+    }
+    apply plugin: 'maven'
+    apply plugin: 'maven-publish'
+    apply plugin: 'java'
+    apply plugin: 'idea'
+    apply plugin: 'com.jfrog.bintray'
+    apply plugin: 'jacoco'
+}
+
+sourceCompatibility = 1.8
+
+repositories {
+    mavenCentral()
+}
+
+sourceSets {
+    main {
+        java {
+            srcDir 'src'
+        }
+    }
+    test {
+        java {
+            srcDir 'test'
+        }
+    }
+}
+
+
+dependencies {
+    compile group: 'org.apache.commons', name: 'commons-lang3', version: '3.+'
+    compile 'junit:junit:4.+'
+    testCompile group: 'junit', name: 'junit', version: '4.+'
+}
+
+jar {
+    manifest {
+        attributes("Implementation-Title": "FstCalculator",
+                "Implementation-Version": version)
+    }
+    doFirst {
+        from { configurations.runtime.collect { it.isDirectory() ? it : zipTree(it) } }
+    }
+}
+
+task sourcesJar(type: Jar, dependsOn: classes) {
+    classifier = 'sources'
+    from sourceSets.main.allSource
+}
+
+
+artifacts {
+    archives sourcesJar //, javadocJar
+}
+
+
+
+publishing {
+    publications {
+        MyPublication(MavenPublication) {
+            from components.java
+            groupId 'com.uni-tuebingen.de.it.mitobench'
+            artifactId 'FstCalculator'
+            artifact sourcesJar {
+                classifier "sources"
+            }
+        }
+    }
+}
+
+jacocoTestReport {
+    reports {
+        xml.enabled true
+    }
+}
+
+
+bintray {
+    user = System.getenv('BINTRAY_USER')
+    key = System.getenv('BINTRAY_API_KEY')
+    publications = ['MyPublication']
+    publish = true
+    override = true
+    pkg {
+        repo = 'Mitobench'
+        name = 'FstCalculator'
+        licenses = ['GPL-3.0']
+        vcsUrl = "https://github.com/JudithNeukamm/FstCalculator"
+        version {
+            name = project.version
+            desc = 'Calculating pairwise Fst values.'
+            released  = new Date()
+            vcsTag = project.version
+            attributes = ['gradle-plugin': 'com.use.less:com.use.less.gradle:gradle-useless-plugin']
+        }
+
+    }
+}

settings.gradle

@@ -0,0 +1,2 @@
+rootProject.name = 'FstCalculator'
+

src/FstCalculator.java

@@ -0,0 +1,94 @@
+import IO.reader.DistanceTypeParser;
+import IO.writer.Writer;
+import fst.FstAMOVA;
+import fst.Linearization;
+import methods.Filter;
+
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.List;
+
+public class FstCalculator {
+
+    private static double gamma = 0.5;
+    private static double level_missing_data = 0.05;
+    private static double significance = 0.05;
+    private static int number_of_permutations = 0;
+    private static String missing_data = "N";
+    private final HashMap<String, List<String>> data;
+    private String distance_method = "Pairwise Difference";
+
+
+    public FstCalculator(HashMap<String, List<String>> data,
+                         String missing_data,
+                         double level_missing_data,
+                         String distance_method,
+                         int number_of_permutations,
+                         double gamma
+
+                         ) {
+
+        this.data = data;
+        this.missing_data = missing_data;
+        this.distance_method = distance_method;
+        this.level_missing_data = level_missing_data;
+        this.number_of_permutations = number_of_permutations;
+        this.gamma = gamma;
+    }
+
+    public double[][] runCaclulations() throws IOException {
+        return runAmova();
+    }
+
+    private double[][] runAmova() throws IOException {
+
+        Linearization linearization = new Linearization();
+
+        DistanceTypeParser distanceTypeParser = new DistanceTypeParser();
+        Filter filter = new Filter();
+        List<Integer> usableLoci = filter.getUsableLoci(data, missing_data, level_missing_data);
+
+        FstAMOVA standardAMOVA = new FstAMOVA(
+                usableLoci,
+                number_of_permutations,
+                distanceTypeParser.parse(distance_method),
+                gamma);
+
+        standardAMOVA.setData(data);
+
+        double[][] fsts_amova = standardAMOVA.calculateFst();
+        double[][] pvalues = standardAMOVA.calculatePermutatedFst();
+
+
+        Writer writer = new Writer(number_of_permutations);
+
+        writer.writeResultsFstToString(
+                fsts_amova,
+                pvalues,
+                standardAMOVA.getGroupnames(),
+                usableLoci,
+                level_missing_data,
+                significance
+        );
+        writer.addDistanceMatrixToResult(
+                standardAMOVA.getDistanceCalculator().getDistancematrix_d()
+        );
+
+        writer.addLinerarizedFstMatrix(
+                linearization.linearizeWithSlatkin(fsts_amova),
+                "# Linearized Fst values (Slatkin)."
+        );
+        writer.addLinerarizedFstMatrix(
+                linearization.linearizeWithReynolds(fsts_amova),
+                "# Linearized Fst values (Reynold)."
+        );
+
+        writer.writeResultsToFile("resultsFstStatisticsAMOVA.tsv");
+
+        return fsts_amova;
+
+    }
+
+
+
+}

src/IO/reader/DistanceTypeParser.java

@@ -0,0 +1,28 @@
+package IO.reader;
+
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Created by neukamm on 08.06.17.
+ */
+public class DistanceTypeParser {
+
+    List<String> types = new ArrayList<>();
+
+    public DistanceTypeParser(){
+
+        types.add("Pairwise Difference");
+        types.add("Percentage Difference");
+        types.add("Jukes and Cantor");
+        types.add("Kimura 2-parameters");
+        types.add("Tamura");
+
+
+    }
+
+    public int parse(String type){
+        return types.indexOf(type);
+    }
+}