Examples with VariantCallAnalysis org.icgc.dcc.song.server.model.analysis.VariantCallAnalysis used on opensource projects

Example 6 with VariantCallAnalysis

use of org.icgc.dcc.song.server.model.analysis.VariantCallAnalysis in project SONG by overture-stack.

the class AnalysisService method read.

public Analysis read(String id) {
    val analysis = checkAnalysis(id);
    analysis.setInfo(analysisInfoService.readNullableInfo(id));
    analysis.setFile(readFiles(id));
    analysis.setSample(readSamples(id));
    if (analysis instanceof SequencingReadAnalysis) {
        val experiment = readSequencingRead(id);
        ((SequencingReadAnalysis) analysis).setExperiment(experiment);
    } else if (analysis instanceof VariantCallAnalysis) {
        val experiment = readVariantCall(id);
        ((VariantCallAnalysis) analysis).setExperiment(experiment);
    }
    return analysis;
}

Example 7 with VariantCallAnalysis

use of org.icgc.dcc.song.server.model.analysis.VariantCallAnalysis in project SONG by overture-stack.

the class AnalysisServiceTest method testGetAnalysisAndIdSearch.

@Test
public void testGetAnalysisAndIdSearch() {
    val studyGenerator = createStudyGenerator(studyService, randomGenerator);
    val studyId = studyGenerator.createRandomStudy();
    val analysisGenerator = createAnalysisGenerator(studyId, service, payloadGenerator);
    val numAnalysis = 10;
    val sraMap = Maps.<String, SequencingReadAnalysis>newHashMap();
    val vcaMap = Maps.<String, VariantCallAnalysis>newHashMap();
    val expectedAnalyses = Sets.<Analysis>newHashSet();
    for (int i = 1; i <= numAnalysis; i++) {
        if (i % 2 == 0) {
            val sra = analysisGenerator.createDefaultRandomSequencingReadAnalysis();
            assertThat(sraMap.containsKey(sra.getAnalysisId())).isFalse();
            sraMap.put(sra.getAnalysisId(), sra);
            expectedAnalyses.add(sra);
        } else {
            val vca = analysisGenerator.createDefaultRandomVariantCallAnalysis();
            assertThat(sraMap.containsKey(vca.getAnalysisId())).isFalse();
            vcaMap.put(vca.getAnalysisId(), vca);
            expectedAnalyses.add(vca);
        }
    }
    assertThat(expectedAnalyses).hasSize(numAnalysis);
    assertThat(sraMap.keySet().size() + vcaMap.keySet().size()).isEqualTo(numAnalysis);
    val expectedVCAs = newHashSet(vcaMap.values());
    val expectedSRAs = newHashSet(sraMap.values());
    assertThat(expectedSRAs).hasSize(sraMap.keySet().size());
    assertThat(expectedVCAs).hasSize(vcaMap.keySet().size());
    val actualAnalyses = service.getAnalysis(studyId);
    val actualSRAs = actualAnalyses.stream().filter(x -> resolveAnalysisType(x.getAnalysisType()) == SEQUENCING_READ).collect(toSet());
    val actualVCAs = actualAnalyses.stream().filter(x -> resolveAnalysisType(x.getAnalysisType()) == VARIANT_CALL).collect(toSet());
    assertThat(actualSRAs).hasSize(sraMap.keySet().size());
    assertThat(actualVCAs).hasSize(vcaMap.keySet().size());
    assertThat(actualSRAs).containsAll(expectedSRAs);
    assertThat(actualVCAs).containsAll(expectedVCAs);
    // Do a study-wide idSearch and verify the response effectively has the same
    // number of results as the getAnalysis method
    val searchedAnalyses = service.idSearch(studyId, createIdSearchRequest(null, null, null, null));
    assertThat(searchedAnalyses).hasSameSizeAs(expectedAnalyses);
    assertThat(searchedAnalyses).containsOnlyElementsOf(expectedAnalyses);
}

Example 8 with VariantCallAnalysis

use of org.icgc.dcc.song.server.model.analysis.VariantCallAnalysis in project SONG by overture-stack.

the class DeserializationTest method testVariantCallDeserialization.

@Test
public void testVariantCallDeserialization() {
    val a1 = fromJson(TestFiles.getJsonNodeFromClasspath("documents/deserialization/variantcall-deserialize1.json"), Analysis.class);
    val sa1 = ((VariantCallAnalysis) a1).getExperiment();
    assertThat(sa1.getAnalysisId()).isEmpty();
    assertThat(sa1.getMatchedNormalSampleSubmitterId()).isNull();
    assertThat(sa1.getVariantCallingTool()).isNull();
    assertThat(sa1.getInfo().path("random").isNull()).isTrue();
    val a2 = fromJson(TestFiles.getJsonNodeFromClasspath("documents/deserialization/variantcall-deserialize2.json"), Analysis.class);
    val sa2 = ((VariantCallAnalysis) a2).getExperiment();
    assertThat(sa2.getAnalysisId()).isEmpty();
    assertThat(sa2.getMatchedNormalSampleSubmitterId()).isNull();
    assertThat(sa2.getVariantCallingTool()).isNull();
}

Example 9 with VariantCallAnalysis

use of org.icgc.dcc.song.server.model.analysis.VariantCallAnalysis in project SONG by overture-stack.

the class AnalysisService method updateAnalysis.

public ResponseEntity<String> updateAnalysis(String studyId, Analysis analysis) {
    val id = analysis.getAnalysisId();
    repository.deleteCompositeEntities(id);
    saveCompositeEntities(studyId, id, analysis.getSample());
    repository.deleteFiles(id);
    analysis.getFile().forEach(f -> fileInfoService.delete(f.getObjectId()));
    saveFiles(id, studyId, analysis.getFile());
    analysisInfoService.update(id, analysis.getInfoAsString());
    if (analysis instanceof SequencingReadAnalysis) {
        val experiment = ((SequencingReadAnalysis) analysis).getExperiment();
        updateSequencingRead(id, experiment);
    } else if (analysis instanceof VariantCallAnalysis) {
        val experiment = ((VariantCallAnalysis) analysis).getExperiment();
        updateVariantCall(id, experiment);
    }
    return ok("AnalysisId %s was updated successfully", analysis.getAnalysisId());
}

Example 10 with VariantCallAnalysis

use of org.icgc.dcc.song.server.model.analysis.VariantCallAnalysis in project SONG by overture-stack.

the class AnalysisConverter method buildVariantCallAnalysis.

private static VariantCallAnalysis buildVariantCallAnalysis(VariantCallAggregate variantCallAggregate) {
    val analysisType = AnalysisTypes.resolve(variantCallAggregate.getType());
    checkState(analysisType == VARIANT_CALL, "The input VariantCallAggregate [%s] is NOT of analysisType [%s]", variantCallAggregate, VARIANT_CALL.getAnalysisTypeName());
    val variantCallAnalysis = new VariantCallAnalysis();
    val analysisId = variantCallAggregate.getAnalysisId();
    variantCallAnalysis.setAnalysisId(analysisId);
    variantCallAnalysis.setAnalysisState(PUBLISHED.toString());
    variantCallAnalysis.setStudy(variantCallAggregate.getStudyId());
    variantCallAnalysis.setInfo(NA);
    val variantCallExperiment = VariantCall.create(analysisId, variantCallAggregate.getVariantCallingTool(), variantCallAggregate.getMatchedNormalSampleSubmitterId());
    variantCallAnalysis.setExperiment(variantCallExperiment);
    return variantCallAnalysis;
}