1028 lines
40 KiB
Go
1028 lines
40 KiB
Go
|
|
// readGeneticAnalysis provides function to read genetic analyses
|
|
|
|
package readGeneticAnalysis
|
|
|
|
import "seekia/resources/geneticReferences/monogenicDiseases"
|
|
import "seekia/resources/geneticReferences/polygenicDiseases"
|
|
import "seekia/resources/geneticReferences/traits"
|
|
|
|
import "seekia/internal/encoding"
|
|
import "seekia/internal/genetics/geneticAnalysis"
|
|
import "seekia/internal/genetics/locusValue"
|
|
import "seekia/internal/helpers"
|
|
|
|
import "errors"
|
|
|
|
|
|
// This converts a person genetic analysis MessagePack to a PersonAnalysis object
|
|
func ReadPersonGeneticAnalysisString(inputAnalysisString string)(geneticAnalysis.PersonAnalysis, error){
|
|
|
|
inputAnalysisBytes := []byte(inputAnalysisString)
|
|
|
|
var newAnalysisObject geneticAnalysis.PersonAnalysis
|
|
|
|
err := encoding.DecodeMessagePackBytes(false, inputAnalysisBytes, &newAnalysisObject)
|
|
if (err != nil) { return geneticAnalysis.PersonAnalysis{}, err }
|
|
|
|
return newAnalysisObject, nil
|
|
}
|
|
|
|
// This converts a couple genetic analysis MessagePack to a CoupleAnalysis object
|
|
func ReadCoupleGeneticAnalysisString(inputAnalysisString string)(geneticAnalysis.CoupleAnalysis, error){
|
|
|
|
inputAnalysisBytes := []byte(inputAnalysisString)
|
|
|
|
var newAnalysisObject geneticAnalysis.CoupleAnalysis
|
|
|
|
err := encoding.DecodeMessagePackBytes(false, inputAnalysisBytes, &newAnalysisObject)
|
|
if (err != nil) { return geneticAnalysis.CoupleAnalysis{}, err }
|
|
|
|
return newAnalysisObject, nil
|
|
}
|
|
|
|
|
|
//Outputs:
|
|
// -[][16]byte: All raw genome identifiers list (excluding combined genomes)
|
|
// -bool: Multiple genomes exist
|
|
// -[16]byte: OnlyExcludeConflicts GenomeIdentifier
|
|
// -[16]byte: OnlyIncludeShared GenomeIdentifier
|
|
// -error
|
|
func GetMetadataFromPersonGeneticAnalysis(inputGeneticAnalysis geneticAnalysis.PersonAnalysis)([][16]byte, bool, [16]byte, [16]byte, error){
|
|
|
|
analysisVersion := inputGeneticAnalysis.AnalysisVersion
|
|
if (analysisVersion != 1){
|
|
// This analysis must have been created by a newer version of Seekia
|
|
// We cannot read it
|
|
return nil, false, [16]byte{}, [16]byte{}, errors.New("Cannot read analysis: Is a newer analysis version.")
|
|
}
|
|
|
|
allRawGenomeIdentifiersList := inputGeneticAnalysis.AllRawGenomeIdentifiersList
|
|
|
|
combinedGenomesExist := inputGeneticAnalysis.CombinedGenomesExist
|
|
if (combinedGenomesExist == false){
|
|
return allRawGenomeIdentifiersList, false, [16]byte{}, [16]byte{}, nil
|
|
}
|
|
|
|
onlyExcludeConflictsGenomeIdentifier := inputGeneticAnalysis.OnlyExcludeConflictsGenomeIdentifier
|
|
onlyIncludeSharedGenomeIdentifier := inputGeneticAnalysis.OnlyIncludeSharedGenomeIdentifier
|
|
|
|
return allRawGenomeIdentifiersList, true, onlyExcludeConflictsGenomeIdentifier, onlyIncludeSharedGenomeIdentifier, nil
|
|
}
|
|
|
|
//Outputs:
|
|
// -[16]byte: Pair 1 Person 1 Genome Identifier
|
|
// -[16]byte: Pair 1 Person 2 Genome Identifier
|
|
// -bool: Second Genome pair exists
|
|
// -[16]byte: Pair 2 Person 1 Genome Identifier
|
|
// -[16]byte: Pair 2 Person 2 Genome Identifier
|
|
// -bool: Person 1 Has Multiple Genomes
|
|
// -[16]byte: Person 1 OnlyExcludeConflicts Genome Identifier
|
|
// -[16]byte: Person 1 OnlyIncludeShared Genome Identifier
|
|
// -bool: Person 2 Has Multiple Genomes
|
|
// -[16]byte: Person 2 OnlyExcludeConflicts Genome Identifier
|
|
// -[16]byte: Person 2 OnlyIncludeShared Genome Identifier
|
|
// -error
|
|
func GetMetadataFromCoupleGeneticAnalysis(inputGeneticAnalysis geneticAnalysis.CoupleAnalysis)([16]byte, [16]byte, bool, [16]byte, [16]byte, bool, [16]byte, [16]byte, bool, [16]byte, [16]byte, error){
|
|
|
|
analysisVersion := inputGeneticAnalysis.AnalysisVersion
|
|
if (analysisVersion != 1){
|
|
// This analysis must have been created by a newer version of Seekia
|
|
// We cannot read it
|
|
return [16]byte{}, [16]byte{}, false, [16]byte{}, [16]byte{}, false, [16]byte{}, [16]byte{}, false, [16]byte{}, [16]byte{}, errors.New("Cannot read analysis: Is a newer analysis version.")
|
|
}
|
|
|
|
pair1Person1GenomeIdentifier := inputGeneticAnalysis.Pair1Person1GenomeIdentifier
|
|
pair1Person2GenomeIdentifier := inputGeneticAnalysis.Pair1Person2GenomeIdentifier
|
|
|
|
secondPairExists := inputGeneticAnalysis.SecondPairExists
|
|
if (secondPairExists == false){
|
|
|
|
return pair1Person1GenomeIdentifier, pair1Person2GenomeIdentifier, false, [16]byte{}, [16]byte{}, false, [16]byte{}, [16]byte{}, false, [16]byte{}, [16]byte{}, nil
|
|
}
|
|
|
|
pair2Person1GenomeIdentifier := inputGeneticAnalysis.Pair2Person1GenomeIdentifier
|
|
pair2Person2GenomeIdentifier := inputGeneticAnalysis.Pair2Person2GenomeIdentifier
|
|
|
|
getPerson1MultipleGenomesInfo := func()(bool, [16]byte, [16]byte, error){
|
|
|
|
person1HasMultipleGenomes := inputGeneticAnalysis.Person1HasMultipleGenomes
|
|
if (person1HasMultipleGenomes == false){
|
|
return false, [16]byte{}, [16]byte{}, nil
|
|
}
|
|
|
|
person1OnlyExcludeConflictsGenomeIdentifier := inputGeneticAnalysis.Person1OnlyExcludeConflictsGenomeIdentifier
|
|
|
|
person1OnlyIncludeSharedGenomeIdentifier := inputGeneticAnalysis.Person1OnlyIncludeSharedGenomeIdentifier
|
|
|
|
return true, person1OnlyExcludeConflictsGenomeIdentifier, person1OnlyIncludeSharedGenomeIdentifier, nil
|
|
}
|
|
|
|
getPerson2MultipleGenomesInfo := func()(bool, [16]byte, [16]byte, error){
|
|
|
|
person2HasMultipleGenomes := inputGeneticAnalysis.Person2HasMultipleGenomes
|
|
if (person2HasMultipleGenomes == false){
|
|
return false, [16]byte{}, [16]byte{}, nil
|
|
}
|
|
|
|
person2OnlyExcludeConflictsGenomeIdentifier := inputGeneticAnalysis.Person2OnlyExcludeConflictsGenomeIdentifier
|
|
|
|
person2OnlyIncludeSharedGenomeIdentifier := inputGeneticAnalysis.Person2OnlyIncludeSharedGenomeIdentifier
|
|
|
|
return true, person2OnlyExcludeConflictsGenomeIdentifier, person2OnlyIncludeSharedGenomeIdentifier, nil
|
|
}
|
|
|
|
person1HasMultipleGenomes, person1OnlyExcludeConflictsGenomeIdentifier, person1OnlyIncludeSharedGenomeIdentifier, err := getPerson1MultipleGenomesInfo()
|
|
if (err != nil) { return [16]byte{}, [16]byte{}, false, [16]byte{}, [16]byte{}, false, [16]byte{}, [16]byte{}, false, [16]byte{}, [16]byte{}, err }
|
|
|
|
person2HasMultipleGenomes, person2OnlyExcludeConflictsGenomeIdentifier, person2OnlyIncludeSharedGenomeIdentifier, err := getPerson2MultipleGenomesInfo()
|
|
if (err != nil) { return [16]byte{}, [16]byte{}, false, [16]byte{}, [16]byte{}, false, [16]byte{}, [16]byte{}, false, [16]byte{}, [16]byte{}, err }
|
|
|
|
return pair1Person1GenomeIdentifier, pair1Person2GenomeIdentifier, true, pair2Person1GenomeIdentifier, pair2Person2GenomeIdentifier, person1HasMultipleGenomes, person1OnlyExcludeConflictsGenomeIdentifier, person1OnlyIncludeSharedGenomeIdentifier, person2HasMultipleGenomes, person2OnlyExcludeConflictsGenomeIdentifier, person2OnlyIncludeSharedGenomeIdentifier, nil
|
|
}
|
|
|
|
|
|
// This function will take a couple and person analysis
|
|
// It takes in a genome identifier from the couple analysis
|
|
// It returns the equivalent genome identifier from the person analysis
|
|
// This is needed for combined genomes, because their identifiers are generated randomly for each analysis
|
|
//Inputs:
|
|
// -bool: Is person 1
|
|
// -geneticAnalysis.PersonAnalysis: Person 1 Analysis
|
|
// -geneticAnalysis.PersonAnalysis: Person 2 Analysis
|
|
// -geneticAnalysis.CoupleAnalysis: Couple Analysis
|
|
// -[16]byte: Input Genome Identifier (Should be from Couple identifier)
|
|
//Outputs:
|
|
// -[16]byte: Genome identifier from person analysis
|
|
// -bool: Person analysis has multiple genomes
|
|
// -bool: Genome is a combined genome
|
|
// -string: Genome combined type ("Only Exclude Conflicts"/"Only Include Shared")
|
|
// -error
|
|
func GetMatchingPersonAnalysisGenomeIdentifierFromCoupleAnalysis(isPerson1 bool, person1AnalysisObject geneticAnalysis.PersonAnalysis, person2AnalysisObject geneticAnalysis.PersonAnalysis, coupleAnalysisObject geneticAnalysis.CoupleAnalysis, inputGenomeIdentifier [16]byte)([16]byte, bool, bool, string, error){
|
|
|
|
// We need to figure out which genome identifier the current genome identifier corresponds to within the person analysis
|
|
// If the genome is not a combined genome, then the genome identifier should be identical between each analysis
|
|
// If it is a combined genome, we need to determine which genome it corresponds to
|
|
|
|
_, _, secondGenomePairExists, _, _, person1HasMultipleGenomes, person1OnlyExcludeConflictsGenomeIdentifier, person1OnlyIncludeSharedGenomeIdentifier, person2HasMultipleGenomes, person2OnlyExcludeConflictsGenomeIdentifier, person2OnlyIncludeSharedGenomeIdentifier, err := GetMetadataFromCoupleGeneticAnalysis(coupleAnalysisObject)
|
|
if (err != nil) { return [16]byte{}, false, false, "", err }
|
|
|
|
if (isPerson1 == true){
|
|
|
|
if (person1HasMultipleGenomes == false){
|
|
// This person does not have multiple genomes. The genome identifier is the same between both analyses
|
|
return inputGenomeIdentifier, false, false, "", nil
|
|
}
|
|
|
|
if (secondGenomePairExists == false){
|
|
return inputGenomeIdentifier, true, false, "", nil
|
|
}
|
|
|
|
_, multipleGenomesExist, onlyExcludeConflictsGenomeIdentifier, onlyIncludeSharedGenomeIdentifier, err := GetMetadataFromPersonGeneticAnalysis(person1AnalysisObject)
|
|
if (err != nil) { return [16]byte{}, false, false, "", err }
|
|
if (multipleGenomesExist == false){
|
|
return [16]byte{}, false, false, "", errors.New("Couple analysis says person has multiple genomes, person analysis does not.")
|
|
}
|
|
|
|
if (inputGenomeIdentifier == person1OnlyExcludeConflictsGenomeIdentifier){
|
|
return onlyExcludeConflictsGenomeIdentifier, true, true, "Only Exclude Conflicts", nil
|
|
}
|
|
if (inputGenomeIdentifier == person1OnlyIncludeSharedGenomeIdentifier){
|
|
return onlyIncludeSharedGenomeIdentifier, true, true, "Only Include Shared", nil
|
|
}
|
|
return [16]byte{}, false, false, "", errors.New("Combined genome identifier from couple analysis does not correspond to either combined genome from person analysis.")
|
|
}
|
|
|
|
// isPerson1 == false
|
|
|
|
if (person2HasMultipleGenomes == false){
|
|
// This person does not have multiple genomes. The genome identifier is the same between both analyses
|
|
return inputGenomeIdentifier, false, false, "", nil
|
|
}
|
|
|
|
if (secondGenomePairExists == false){
|
|
return inputGenomeIdentifier, true, false, "", nil
|
|
}
|
|
|
|
_, multipleGenomesExist, onlyExcludeConflictsGenomeIdentifier, onlyIncludeSharedGenomeIdentifier, err := GetMetadataFromPersonGeneticAnalysis(person2AnalysisObject)
|
|
if (err != nil) { return [16]byte{}, false, false, "", err }
|
|
if (multipleGenomesExist == false){
|
|
return [16]byte{}, false, false, "", errors.New("Couple analysis says person has multiple genomes, person analysis does not.")
|
|
}
|
|
|
|
if (inputGenomeIdentifier == person2OnlyExcludeConflictsGenomeIdentifier){
|
|
return onlyExcludeConflictsGenomeIdentifier, true, true, "Only Exclude Conflicts", nil
|
|
}
|
|
if (inputGenomeIdentifier == person2OnlyIncludeSharedGenomeIdentifier){
|
|
return onlyIncludeSharedGenomeIdentifier, true, true, "Only Include Shared", nil
|
|
}
|
|
|
|
return [16]byte{}, false, false, "", errors.New("Combined genome identifier from couple analysis does not correspond to either combined genome from person analysis.")
|
|
}
|
|
|
|
|
|
//Outputs:
|
|
// -bool: Disease info known
|
|
// -bool: Person has disease
|
|
// -int: Probability of passing a disease variant
|
|
// -string: Probability of passing a disease variant formatted (with % suffix)
|
|
// -int: Number of variants tested
|
|
// -int: Number of loci tested
|
|
// -int: Number of phased loci
|
|
// -bool: Conflict exists
|
|
// -error
|
|
func GetPersonMonogenicDiseaseInfoFromGeneticAnalysis(personAnalysisObject geneticAnalysis.PersonAnalysis, diseaseName string, genomeIdentifier [16]byte)(bool, bool, int, string, int, int, int, bool, error){
|
|
|
|
personMonogenicDiseasesMap := personAnalysisObject.MonogenicDiseasesMap
|
|
|
|
personMonogenicDiseaseInfo, exists := personMonogenicDiseasesMap[diseaseName]
|
|
if (exists == false){
|
|
return false, false, 0, "", 0, 0, 0, false, nil
|
|
}
|
|
|
|
personMonogenicDiseaseInfoMap := personMonogenicDiseaseInfo.MonogenicDiseaseInfoMap
|
|
|
|
genomeMonogenicDiseaseInfo, exists := personMonogenicDiseaseInfoMap[genomeIdentifier]
|
|
if (exists == false){
|
|
return false, false, 0, "", 0, 0, 0, false, nil
|
|
}
|
|
|
|
conflictExists := personMonogenicDiseaseInfo.ConflictExists
|
|
|
|
personHasDisease := genomeMonogenicDiseaseInfo.PersonHasDisease
|
|
numberOfVariantsTested := genomeMonogenicDiseaseInfo.NumberOfVariantsTested
|
|
numberOfLociTested := genomeMonogenicDiseaseInfo.NumberOfLociTested
|
|
numberOfPhasedLoci := genomeMonogenicDiseaseInfo.NumberOfPhasedLoci
|
|
probabilityOfPassingAVariant := genomeMonogenicDiseaseInfo.ProbabilityOfPassingADiseaseVariant
|
|
|
|
probabilityOfPassingAVariantString := helpers.ConvertIntToString(probabilityOfPassingAVariant)
|
|
|
|
probabilityOfPassingAVariantFormatted := probabilityOfPassingAVariantString + "%"
|
|
|
|
return true, personHasDisease, probabilityOfPassingAVariant, probabilityOfPassingAVariantFormatted, numberOfVariantsTested, numberOfLociTested, numberOfPhasedLoci, conflictExists, nil
|
|
}
|
|
|
|
|
|
//Outputs:
|
|
// -bool: Probability Offspring Has Disease Is Known
|
|
// -int: Percentage Probability of offspring having disease
|
|
// -string: Probability of offspring having disease formatted (with % suffix)
|
|
// -bool: Probability Offspring Has Variant Is Known
|
|
// -int: Percentage probability of offspring having a disease variant
|
|
// -string: Percentage probability of offspring having a disease variant formatted (with % suffix)
|
|
// -bool: Conflict exists between genome pairs
|
|
// -error
|
|
func GetOffspringMonogenicDiseaseInfoFromGeneticAnalysis(coupleAnalysisObject geneticAnalysis.CoupleAnalysis, diseaseName string, genomePairIdentifier [32]byte)(bool, int, string, bool, int, string, bool, error){
|
|
|
|
offspringMonogenicDiseasesMap := coupleAnalysisObject.MonogenicDiseasesMap
|
|
|
|
offspringMonogenicDiseaseInfoObject, exists := offspringMonogenicDiseasesMap[diseaseName]
|
|
if (exists == false){
|
|
return false, 0, "", false, 0, "", false, nil
|
|
}
|
|
|
|
monogenicDiseaseInfoMap := offspringMonogenicDiseaseInfoObject.MonogenicDiseaseInfoMap
|
|
|
|
offspringGenomePairMonogenicDiseaseInfo, exists := monogenicDiseaseInfoMap[genomePairIdentifier]
|
|
if (exists == false){
|
|
return false, 0, "", false, 0, "", false, nil
|
|
}
|
|
|
|
conflictExists := offspringMonogenicDiseaseInfoObject.ConflictExists
|
|
|
|
probabilityOffspringHasDiseaseIsKnown := offspringGenomePairMonogenicDiseaseInfo.ProbabilityOffspringHasDiseaseIsKnown
|
|
probabilityOffspringHasDisease := offspringGenomePairMonogenicDiseaseInfo.ProbabilityOffspringHasDisease
|
|
probabilityOffspringHasVariantIsKnown := offspringGenomePairMonogenicDiseaseInfo.ProbabilityOffspringHasVariantIsKnown
|
|
probabilityOffspringHasVariant := offspringGenomePairMonogenicDiseaseInfo.ProbabilityOffspringHasVariant
|
|
|
|
getProbabilityOffspringHasDiseaseFormatted := func()string{
|
|
if (probabilityOffspringHasDiseaseIsKnown == false){
|
|
return ""
|
|
}
|
|
|
|
probabilityOffspringHasDiseaseString := helpers.ConvertIntToString(probabilityOffspringHasDisease)
|
|
|
|
probabilityOffspringHasDiseaseFormatted := probabilityOffspringHasDiseaseString + "%"
|
|
|
|
return probabilityOffspringHasDiseaseFormatted
|
|
}
|
|
|
|
probabilityOffspringHasDiseaseFormatted := getProbabilityOffspringHasDiseaseFormatted()
|
|
|
|
getProbabilityOffspringHasVariantFormatted := func()string{
|
|
if (probabilityOffspringHasVariantIsKnown == false){
|
|
return ""
|
|
}
|
|
|
|
probabilityOffspringHasVariantString := helpers.ConvertIntToString(probabilityOffspringHasVariant)
|
|
|
|
probabilityOffspringHasVariantFormatted := probabilityOffspringHasVariantString + "%"
|
|
|
|
return probabilityOffspringHasVariantFormatted
|
|
}
|
|
|
|
probabilityOffspringHasVariantFormatted := getProbabilityOffspringHasVariantFormatted()
|
|
|
|
return probabilityOffspringHasDiseaseIsKnown, probabilityOffspringHasDisease, probabilityOffspringHasDiseaseFormatted, probabilityOffspringHasVariantIsKnown, probabilityOffspringHasVariant, probabilityOffspringHasVariantFormatted, conflictExists, nil
|
|
}
|
|
|
|
|
|
//Outputs:
|
|
// -bool: Number of mutations is known
|
|
// -int: Number of mutations
|
|
// -error
|
|
func GetPersonMonogenicDiseaseVariantInfoFromGeneticAnalysis(personAnalysisObject geneticAnalysis.PersonAnalysis, diseaseName string, variantIdentifier [3]byte, genomeIdentifier [16]byte)(bool, int, error){
|
|
|
|
personMonogenicDiseasesMap := personAnalysisObject.MonogenicDiseasesMap
|
|
|
|
personMonogenicDiseaseInfo, exists := personMonogenicDiseasesMap[diseaseName]
|
|
if (exists == false){
|
|
return false, 0, nil
|
|
}
|
|
|
|
personMonogenicDiseaseInfoMap := personMonogenicDiseaseInfo.MonogenicDiseaseInfoMap
|
|
|
|
genomeMonogenicDiseaseInfo, exists := personMonogenicDiseaseInfoMap[genomeIdentifier]
|
|
if (exists == false){
|
|
return false, 0, nil
|
|
}
|
|
|
|
variantsInfoMap := genomeMonogenicDiseaseInfo.VariantsInfoMap
|
|
|
|
variantInfoObject, exists := variantsInfoMap[variantIdentifier]
|
|
if (exists == false){
|
|
// The genome's variant info is unknown for this variant
|
|
return false, 0, nil
|
|
}
|
|
|
|
base1HasVariant := variantInfoObject.Base1HasVariant
|
|
base2HasVariant := variantInfoObject.Base2HasVariant
|
|
|
|
numberOfMutations := 0
|
|
|
|
if (base1HasVariant == true){
|
|
numberOfMutations += 1
|
|
}
|
|
if (base2HasVariant == true){
|
|
numberOfMutations += 1
|
|
}
|
|
|
|
return true, numberOfMutations, nil
|
|
}
|
|
|
|
//Outputs:
|
|
// -bool: Offspring Probabilities Known
|
|
// -int: Lower Bound Percentage Probability of 0 mutations
|
|
// -int: Upper Bound Percentage Probability of 0 mutations
|
|
// -string: Percentage probability of 0 mutations formatted (has % suffix and - between non-identical bounds)
|
|
// -int: Lower Bound Percentage probability of only 1 mutation
|
|
// -int: Upper Bound Percentage probability of only 1 mutation
|
|
// -string: Percentage probability of 1 mutation formatted (has % suffix and - between non-identical bounds)
|
|
// -int: Lower Bound Percentage probability of 2 mutations
|
|
// -int: Upper Bound Percentage probability of 2 mutations
|
|
// -string: Percentage probability of 2 mutations formatted (has % suffix and - between non-identical bounds)
|
|
// -error
|
|
func GetOffspringMonogenicDiseaseVariantInfoFromGeneticAnalysis(coupleAnalysisObject geneticAnalysis.CoupleAnalysis, diseaseName string, variantIdentifier [3]byte, genomePairIdentifier [32]byte)(bool, int, int, string, int, int, string, int, int, string, error){
|
|
|
|
coupleMonogenicDiseasesMap := coupleAnalysisObject.MonogenicDiseasesMap
|
|
|
|
coupleMonogenicDiseaseInfo, exists := coupleMonogenicDiseasesMap[diseaseName]
|
|
if (exists == false){
|
|
return false, 0, 0, "", 0, 0, "", 0, 0, "", nil
|
|
}
|
|
|
|
coupleMonogenicDiseaseInfoMap := coupleMonogenicDiseaseInfo.MonogenicDiseaseInfoMap
|
|
|
|
genomePairMonogenicDiseaseInfo, exists := coupleMonogenicDiseaseInfoMap[genomePairIdentifier]
|
|
if (exists == false){
|
|
return false, 0, 0, "", 0, 0, "", 0, 0, "", nil
|
|
}
|
|
|
|
genomePairVariantsInfoMap := genomePairMonogenicDiseaseInfo.VariantsInfoMap
|
|
|
|
variantInfoObject, exists := genomePairVariantsInfoMap[variantIdentifier]
|
|
if (exists == false){
|
|
return false, 0, 0, "", 0, 0, "", 0, 0, "", nil
|
|
}
|
|
|
|
probabilityOf0MutationsLowerBound := variantInfoObject.ProbabilityOf0MutationsLowerBound
|
|
probabilityOf0MutationsUpperBound := variantInfoObject.ProbabilityOf0MutationsUpperBound
|
|
|
|
probabilityOf1MutationLowerBound := variantInfoObject.ProbabilityOf1MutationLowerBound
|
|
probabilityOf1MutationUpperBound := variantInfoObject.ProbabilityOf1MutationUpperBound
|
|
|
|
probabilityOf2MutationsLowerBound := variantInfoObject.ProbabilityOf2MutationsLowerBound
|
|
probabilityOf2MutationsUpperBound := variantInfoObject.ProbabilityOf2MutationsUpperBound
|
|
|
|
getOffspringProbabilityOf0MutationsFormatted := func()string{
|
|
|
|
probabilityOf0MutationsLowerBoundString := helpers.ConvertIntToString(probabilityOf0MutationsLowerBound)
|
|
|
|
probabilityOf0MutationsLowerBoundFormatted := probabilityOf0MutationsLowerBoundString + "%"
|
|
|
|
if (probabilityOf0MutationsLowerBound == probabilityOf0MutationsUpperBound){
|
|
return probabilityOf0MutationsLowerBoundFormatted
|
|
}
|
|
|
|
probabilityOf0MutationsUpperBoundString := helpers.ConvertIntToString(probabilityOf0MutationsUpperBound)
|
|
|
|
probabilityOf0MutationsUpperBoundFormatted := probabilityOf0MutationsUpperBoundString + "%"
|
|
|
|
formattedResult := probabilityOf0MutationsLowerBoundFormatted + " - " + probabilityOf0MutationsUpperBoundFormatted
|
|
|
|
return formattedResult
|
|
}
|
|
|
|
probabilityOf0MutationsFormatted := getOffspringProbabilityOf0MutationsFormatted()
|
|
|
|
getOffspringProbabilityOf1MutationFormatted := func()string{
|
|
|
|
probabilityOf1MutationLowerBoundString := helpers.ConvertIntToString(probabilityOf1MutationLowerBound)
|
|
|
|
probabilityOf1MutationLowerBoundFormatted := probabilityOf1MutationLowerBoundString + "%"
|
|
|
|
if (probabilityOf1MutationLowerBound == probabilityOf1MutationUpperBound){
|
|
return probabilityOf1MutationLowerBoundFormatted
|
|
}
|
|
|
|
probabilityOf1MutationUpperBoundString := helpers.ConvertIntToString(probabilityOf1MutationUpperBound)
|
|
|
|
probabilityOf1MutationUpperBoundFormatted := probabilityOf1MutationUpperBoundString + "%"
|
|
|
|
formattedResult := probabilityOf1MutationLowerBoundFormatted + " - " + probabilityOf1MutationUpperBoundFormatted
|
|
|
|
return formattedResult
|
|
}
|
|
|
|
probabilityOf1MutationFormatted := getOffspringProbabilityOf1MutationFormatted()
|
|
|
|
getOffspringProbabilityOf2MutationsFormatted := func()string{
|
|
|
|
probabilityOf2MutationsLowerBoundString := helpers.ConvertIntToString(probabilityOf2MutationsLowerBound)
|
|
|
|
probabilityOf2MutationsLowerBoundFormatted := probabilityOf2MutationsLowerBoundString + "%"
|
|
|
|
if (probabilityOf2MutationsLowerBound == probabilityOf2MutationsUpperBound){
|
|
return probabilityOf2MutationsLowerBoundFormatted
|
|
}
|
|
|
|
probabilityOf2MutationsUpperBoundString := helpers.ConvertIntToString(probabilityOf2MutationsUpperBound)
|
|
|
|
probabilityOf2MutationsUpperBoundFormatted := probabilityOf2MutationsUpperBoundString + "%"
|
|
|
|
formattedResult := probabilityOf2MutationsLowerBoundFormatted + " - " + probabilityOf2MutationsUpperBoundFormatted
|
|
|
|
return formattedResult
|
|
}
|
|
|
|
probabilityOf2MutationsFormatted := getOffspringProbabilityOf2MutationsFormatted()
|
|
|
|
return true, probabilityOf0MutationsLowerBound, probabilityOf0MutationsUpperBound, probabilityOf0MutationsFormatted, probabilityOf1MutationLowerBound, probabilityOf1MutationUpperBound, probabilityOf1MutationFormatted, probabilityOf2MutationsLowerBound, probabilityOf2MutationsUpperBound, probabilityOf2MutationsFormatted, nil
|
|
}
|
|
|
|
|
|
//Outputs:
|
|
// -bool: Polygenic Disease Risk Score known (any loci values exist)
|
|
// -int: Person Disease risk score
|
|
// -string: Person Disease risk score formatted (has "/10" suffix)
|
|
// -map[int]locusValue.LocusValue: Person locus values map
|
|
// -int: Number of loci tested
|
|
// -bool: Conflict exists
|
|
// -error
|
|
func GetPersonPolygenicDiseaseInfoFromGeneticAnalysis(personAnalysisObject geneticAnalysis.PersonAnalysis, diseaseName string, genomeIdentifier [16]byte)(bool, int, string, map[int64]locusValue.LocusValue, int, bool, error){
|
|
|
|
personPolygenicDiseasesMap := personAnalysisObject.PolygenicDiseasesMap
|
|
|
|
personPolygenicDiseaseInfo, exists := personPolygenicDiseasesMap[diseaseName]
|
|
if (exists == false){
|
|
return false, 0, "", nil, 0, false, nil
|
|
}
|
|
|
|
personPolygenicDiseaseInfoMap := personPolygenicDiseaseInfo.PolygenicDiseaseInfoMap
|
|
|
|
genomePolygenicDiseaseInfo, exists := personPolygenicDiseaseInfoMap[genomeIdentifier]
|
|
if (exists == false){
|
|
return false, 0, "", nil, 0, false, nil
|
|
}
|
|
|
|
conflictExists := personPolygenicDiseaseInfo.ConflictExists
|
|
|
|
personDiseaseRiskScore := genomePolygenicDiseaseInfo.RiskScore
|
|
|
|
personDiseaseRiskScoreString := helpers.ConvertIntToString(personDiseaseRiskScore)
|
|
|
|
personDiseaseRiskScoreFormatted := personDiseaseRiskScoreString + "/10"
|
|
|
|
personLocusValuesMap := genomePolygenicDiseaseInfo.LocusValuesMap
|
|
|
|
numberOfLociTested := genomePolygenicDiseaseInfo.NumberOfLociTested
|
|
|
|
return true, personDiseaseRiskScore, personDiseaseRiskScoreFormatted, personLocusValuesMap, numberOfLociTested, conflictExists, nil
|
|
}
|
|
|
|
|
|
//Outputs:
|
|
// -bool: Offspring Disease Risk Score known
|
|
// -int: Offspring average disease risk score
|
|
// -string: Offspring Disease average risk score formatted (has "/10" suffix)
|
|
// -[]int: Sample Offspring Risk Scores List
|
|
// -int: Number of loci tested
|
|
// -bool: Conflict exists
|
|
// -error
|
|
func GetOffspringPolygenicDiseaseInfoFromGeneticAnalysis(coupleAnalysisObject geneticAnalysis.CoupleAnalysis, diseaseName string, genomePairIdentifier [32]byte)(bool, int, string, []int, int, bool, error){
|
|
|
|
couplePolygenicDiseasesMap := coupleAnalysisObject.PolygenicDiseasesMap
|
|
|
|
couplePolygenicDiseaseInfo, exists := couplePolygenicDiseasesMap[diseaseName]
|
|
if (exists == false){
|
|
return false, 0, "", nil, 0, false, nil
|
|
}
|
|
|
|
polygenicDiseaseInfoMap := couplePolygenicDiseaseInfo.PolygenicDiseaseInfoMap
|
|
|
|
genomePairPolygenicDiseaseInfo, exists := polygenicDiseaseInfoMap[genomePairIdentifier]
|
|
if (exists == false){
|
|
return false, 0, "", nil, 0, false, nil
|
|
}
|
|
|
|
conflictExists := couplePolygenicDiseaseInfo.ConflictExists
|
|
|
|
numberOfLociTested := genomePairPolygenicDiseaseInfo.NumberOfLociTested
|
|
|
|
offspringAverageRiskScore := genomePairPolygenicDiseaseInfo.OffspringAverageRiskScore
|
|
|
|
offspringAverageRiskScoreString := helpers.ConvertIntToString(offspringAverageRiskScore)
|
|
|
|
offspringAverageRiskScoreFormatted := offspringAverageRiskScoreString + "/10"
|
|
|
|
sampleOffspringRiskScoresList := genomePairPolygenicDiseaseInfo.SampleOffspringRiskScoresList
|
|
|
|
return true, offspringAverageRiskScore, offspringAverageRiskScoreFormatted, sampleOffspringRiskScoresList, numberOfLociTested, conflictExists, nil
|
|
}
|
|
|
|
//Outputs:
|
|
// -bool: Risk Weight and base pair known
|
|
// -int: Locus risk weight
|
|
// -bool: Locus odds ratio known
|
|
// -float64: Locus odds ratio
|
|
// -string: Locus odds ratio formatted (with x suffix)
|
|
// -error
|
|
func GetPersonPolygenicDiseaseLocusInfoFromGeneticAnalysis(personAnalyisObject geneticAnalysis.PersonAnalysis, diseaseName string, locusIdentifier [3]byte, genomeIdentifier [16]byte)(bool, int, bool, float64, string, error){
|
|
|
|
personPolygenicDiseasesMap := personAnalyisObject.PolygenicDiseasesMap
|
|
|
|
personPolygenicDiseaseMap, exists := personPolygenicDiseasesMap[diseaseName]
|
|
if (exists == false){
|
|
return false, 0, false, 0, "", nil
|
|
}
|
|
|
|
personPolygenicDiseaseInfoMap := personPolygenicDiseaseMap.PolygenicDiseaseInfoMap
|
|
|
|
personGenomePolygenicDiseaseInfo, exists := personPolygenicDiseaseInfoMap[genomeIdentifier]
|
|
if (exists == false){
|
|
return false, 0, false, 0, "", nil
|
|
}
|
|
|
|
genomeLociInfoMap := personGenomePolygenicDiseaseInfo.LociInfoMap
|
|
|
|
locusInfoObject, exists := genomeLociInfoMap[locusIdentifier]
|
|
if (exists == false){
|
|
return false, 0, false, 0, "", nil
|
|
}
|
|
|
|
locusRiskWeight := locusInfoObject.RiskWeight
|
|
|
|
locusOddsRatioIsKnown := locusInfoObject.OddsRatioIsKnown
|
|
if (locusOddsRatioIsKnown == false){
|
|
return true, locusRiskWeight, false, 0, "", nil
|
|
}
|
|
|
|
locusOddsRatio := locusInfoObject.OddsRatio
|
|
|
|
genomeLocusOddsRatioString := helpers.ConvertFloat64ToStringRounded(locusOddsRatio, 2)
|
|
|
|
locusOddsRatioFormatted := genomeLocusOddsRatioString + "x"
|
|
|
|
return true, locusRiskWeight, true, locusOddsRatio, locusOddsRatioFormatted, nil
|
|
}
|
|
|
|
//Outputs:
|
|
// -bool: Offspring risk weight known
|
|
// -int: Offspring risk weight
|
|
// -bool: Offspring odds ratio known
|
|
// -float64: Offspring odds ratio
|
|
// -string: Offspring odds ratio formatted (with + and < from unknownFactors weight sum and x suffix)
|
|
// -error
|
|
func GetOffspringPolygenicDiseaseLocusInfoFromGeneticAnalysis(coupleAnalysisObject geneticAnalysis.CoupleAnalysis, diseaseName string, locusIdentifier [3]byte, genomePairIdentifier [32]byte)(bool, int, bool, float64, string, error){
|
|
|
|
offspringPolygenicDiseasesMap := coupleAnalysisObject.PolygenicDiseasesMap
|
|
|
|
offspringPolygenicDiseaseInfo, exists := offspringPolygenicDiseasesMap[diseaseName]
|
|
if (exists == false){
|
|
return false, 0, false, 0, "", nil
|
|
}
|
|
|
|
offspringPolygenicDiseaseMap := offspringPolygenicDiseaseInfo.PolygenicDiseaseInfoMap
|
|
|
|
genomePairPolygenicDiseaseInfo, exists := offspringPolygenicDiseaseMap[genomePairIdentifier]
|
|
if (exists == false){
|
|
return false, 0, false, 0, "", nil
|
|
}
|
|
|
|
genomePairLociInfoMap := genomePairPolygenicDiseaseInfo.LociInfoMap
|
|
|
|
locusInfoObject, exists := genomePairLociInfoMap[locusIdentifier]
|
|
if (exists == false){
|
|
return false, 0, false, 0, "", nil
|
|
}
|
|
|
|
offspringAverageRiskWeight := locusInfoObject.OffspringAverageRiskWeight
|
|
offspringOddsRatioIsKnown := locusInfoObject.OffspringOddsRatioIsKnown
|
|
|
|
if (offspringOddsRatioIsKnown == false){
|
|
return true, offspringAverageRiskWeight, false, 0, "", nil
|
|
}
|
|
|
|
offspringAverageOddsRatio := locusInfoObject.OffspringAverageOddsRatio
|
|
|
|
getOddsRatioFormatted := func()string{
|
|
|
|
offspringAverageUnknownOddsRatiosWeightSum := locusInfoObject.OffspringAverageUnknownOddsRatiosWeightSum
|
|
|
|
offspringAverageOddsRatioString := helpers.ConvertFloat64ToStringRounded(offspringAverageOddsRatio, 2)
|
|
|
|
if (offspringAverageUnknownOddsRatiosWeightSum == 0){
|
|
result := offspringAverageOddsRatioString + "x"
|
|
|
|
return result
|
|
}
|
|
if (offspringAverageUnknownOddsRatiosWeightSum < 0){
|
|
result := "<" + offspringAverageOddsRatioString + "x"
|
|
|
|
return result
|
|
}
|
|
// offspringAverageUnknownOddsRatiosWeightSum > 0
|
|
result := offspringAverageOddsRatioString + "x+"
|
|
|
|
return result
|
|
}
|
|
|
|
oddsRatioFormatted := getOddsRatioFormatted()
|
|
|
|
return true, offspringAverageRiskWeight, true, offspringAverageOddsRatio, oddsRatioFormatted, nil
|
|
}
|
|
|
|
//Outputs:
|
|
// -map[int64]locusValue.LocusValue (rsID -> Base pair) (missing rsIDs represent unknown values)
|
|
// -bool: Any Trait Rule known/tested
|
|
// -map[string]int: Trait outcomes scores map (Outcome -> Number of points)
|
|
// -int: Number of rules tested
|
|
// -bool: Conflict exists
|
|
// -error
|
|
func GetPersonTraitInfoFromGeneticAnalysis(personAnalysisObject geneticAnalysis.PersonAnalysis, traitName string, genomeIdentifier [16]byte)(map[int64]locusValue.LocusValue, bool, map[string]int, int, bool, error){
|
|
|
|
personTraitsMap := personAnalysisObject.TraitsMap
|
|
|
|
personTraitInfoObject, exists := personTraitsMap[traitName]
|
|
if (exists == false){
|
|
emptyMap := make(map[int64]locusValue.LocusValue)
|
|
return emptyMap, false, nil, 0, false, nil
|
|
}
|
|
|
|
personTraitInfoMap := personTraitInfoObject.TraitInfoMap
|
|
|
|
personGenomeTraitInfoObject, exists := personTraitInfoMap[genomeIdentifier]
|
|
if (exists == false){
|
|
emptyMap := make(map[int64]locusValue.LocusValue)
|
|
return emptyMap, false, nil, 0, false, nil
|
|
}
|
|
|
|
conflictExists := personTraitInfoObject.ConflictExists
|
|
|
|
genomeNumberOfRulesTested := personGenomeTraitInfoObject.NumberOfRulesTested
|
|
|
|
genomeLocusValuesMap := personGenomeTraitInfoObject.LocusValuesMap
|
|
|
|
genomeOutcomeScoresMap := personGenomeTraitInfoObject.OutcomeScoresMap
|
|
|
|
return genomeLocusValuesMap, true, genomeOutcomeScoresMap, genomeNumberOfRulesTested, conflictExists, nil
|
|
}
|
|
|
|
|
|
|
|
//Outputs:
|
|
// -bool: Trait Outcome Scores known
|
|
// -map[string]float64: Trait average outcome scores map (OutcomeName -> AverageScore)
|
|
// -int: Number of rules tested
|
|
// -bool: Conflict exists
|
|
// -error
|
|
func GetOffspringTraitInfoFromGeneticAnalysis(coupleAnalysisObject geneticAnalysis.CoupleAnalysis, traitName string, genomePairIdentifier [32]byte)(bool, map[string]float64, int, bool, error){
|
|
|
|
offspringTraitsMap := coupleAnalysisObject.TraitsMap
|
|
|
|
traitInfoObject, exists := offspringTraitsMap[traitName]
|
|
if (exists == false){
|
|
return false, nil, 0, false, nil
|
|
}
|
|
|
|
traitInfoMap := traitInfoObject.TraitInfoMap
|
|
|
|
genomePairTraitInfoObject, exists := traitInfoMap[genomePairIdentifier]
|
|
if (exists == false){
|
|
return false, nil, 0, false, nil
|
|
}
|
|
|
|
conflictExists := traitInfoObject.ConflictExists
|
|
|
|
numberOfRulesTested := genomePairTraitInfoObject.NumberOfRulesTested
|
|
offspringAverageOutcomeScoresMap := genomePairTraitInfoObject.OffspringAverageOutcomeScoresMap
|
|
|
|
return true, offspringAverageOutcomeScoresMap, numberOfRulesTested, conflictExists, nil
|
|
}
|
|
|
|
|
|
//Outputs:
|
|
// -bool: Rule status is known (we know if the rule is passed or not)
|
|
// -bool: Genome passes rule
|
|
// -error
|
|
func GetPersonTraitRuleInfoFromGeneticAnalysis(personAnalysisObject geneticAnalysis.PersonAnalysis, traitName string, ruleIdentifier [3]byte, genomeIdentifier [16]byte)(bool, bool, error){
|
|
|
|
personTraitsMap := personAnalysisObject.TraitsMap
|
|
|
|
traitInfoObject, exists := personTraitsMap[traitName]
|
|
if (exists == false){
|
|
return false, false, nil
|
|
}
|
|
|
|
personTraitInfoMap := traitInfoObject.TraitInfoMap
|
|
|
|
genomeTraitInfoObject, exists := personTraitInfoMap[genomeIdentifier]
|
|
if (exists == false){
|
|
return false, false, nil
|
|
}
|
|
|
|
genomePassesRulesMap := genomeTraitInfoObject.GenomePassesRulesMap
|
|
|
|
genomePassesRule, statusIsKnown := genomePassesRulesMap[ruleIdentifier]
|
|
if (statusIsKnown == false){
|
|
return false, false, nil
|
|
}
|
|
|
|
return true, genomePassesRule, nil
|
|
}
|
|
|
|
|
|
//Outputs:
|
|
// -bool: Offspring trait rule probability known
|
|
// -int: Offspring probability of passing rule (0 - 100)
|
|
// -string: Offspring probability of passing rule formatted (with % suffix)
|
|
// -error
|
|
func GetOffspringTraitRuleInfoFromGeneticAnalysis(coupleAnalysisObject geneticAnalysis.CoupleAnalysis, traitName string, ruleIdentifier [3]byte, genomePairIdentifier [32]byte)(bool, int, string, error){
|
|
|
|
offspringTraitsMap := coupleAnalysisObject.TraitsMap
|
|
|
|
offspringTraitInfo, exists := offspringTraitsMap[traitName]
|
|
if (exists == false){
|
|
return false, 0, "", nil
|
|
}
|
|
|
|
offspringTraitInfoMap := offspringTraitInfo.TraitInfoMap
|
|
|
|
offspringTraitInfoObject, exists := offspringTraitInfoMap[genomePairIdentifier]
|
|
if (exists == false){
|
|
return false, 0, "", nil
|
|
}
|
|
|
|
offspringProbabilityOfPassingRulesMap := offspringTraitInfoObject.ProbabilityOfPassingRulesMap
|
|
|
|
offspringProbabilityOfPassingRule, exists := offspringProbabilityOfPassingRulesMap[ruleIdentifier]
|
|
if (exists == false){
|
|
return false, 0, "", nil
|
|
}
|
|
|
|
offspringProbabilityOfPassingRuleString := helpers.ConvertIntToString(offspringProbabilityOfPassingRule)
|
|
|
|
offspringProbabilityOfPassingRuleFormatted := offspringProbabilityOfPassingRuleString + "%"
|
|
|
|
return true, offspringProbabilityOfPassingRule, offspringProbabilityOfPassingRuleFormatted, nil
|
|
}
|
|
|
|
|
|
// We use this function to verify a person genetic analysis is well formed
|
|
//TODO: Perform sanity checks on data
|
|
func VerifyPersonGeneticAnalysis(personAnalysisObject geneticAnalysis.PersonAnalysis)error{
|
|
|
|
allRawGenomeIdentifiersList, personHasMultipleGenomes, onlyExcludeConflictsGenomeIdentifier, onlyIncludeSharedGenomeIdentifier, err := GetMetadataFromPersonGeneticAnalysis(personAnalysisObject)
|
|
if (err != nil) { return err }
|
|
|
|
allGenomeIdentifiersList := allRawGenomeIdentifiersList
|
|
if (personHasMultipleGenomes == true){
|
|
allGenomeIdentifiersList = append(allGenomeIdentifiersList, onlyExcludeConflictsGenomeIdentifier, onlyIncludeSharedGenomeIdentifier)
|
|
}
|
|
|
|
monogenicDiseaseObjectsList, err := monogenicDiseases.GetMonogenicDiseaseObjectsList()
|
|
if (err != nil) { return err }
|
|
|
|
for _, monogenicDiseaseObject := range monogenicDiseaseObjectsList{
|
|
|
|
diseaseName := monogenicDiseaseObject.DiseaseName
|
|
|
|
for _, genomeIdentifier := range allGenomeIdentifiersList{
|
|
|
|
_, _, _, _, _, _, _, _, err := GetPersonMonogenicDiseaseInfoFromGeneticAnalysis(personAnalysisObject, diseaseName, genomeIdentifier)
|
|
if (err != nil) { return err }
|
|
}
|
|
|
|
diseaseVariantObjectsList := monogenicDiseaseObject.VariantsList
|
|
|
|
for _, diseaseVariantObject := range diseaseVariantObjectsList{
|
|
|
|
variantIdentifierHex := diseaseVariantObject.VariantIdentifier
|
|
|
|
variantIdentifier, err := encoding.DecodeHexStringTo3ByteArray(variantIdentifierHex)
|
|
if (err != nil) { return err }
|
|
|
|
for _, genomeIdentifier := range allGenomeIdentifiersList{
|
|
|
|
_, _, err := GetPersonMonogenicDiseaseVariantInfoFromGeneticAnalysis(personAnalysisObject, diseaseName, variantIdentifier, genomeIdentifier)
|
|
if (err != nil) { return err }
|
|
}
|
|
}
|
|
}
|
|
|
|
polygenicDiseaseObjectsList, err := polygenicDiseases.GetPolygenicDiseaseObjectsList()
|
|
if (err != nil) { return err }
|
|
|
|
for _, diseaseObject := range polygenicDiseaseObjectsList{
|
|
|
|
diseaseName := diseaseObject.DiseaseName
|
|
|
|
for _, genomeIdentifier := range allGenomeIdentifiersList{
|
|
|
|
_, _, _, _, _, _, err := GetPersonPolygenicDiseaseInfoFromGeneticAnalysis(personAnalysisObject, diseaseName, genomeIdentifier)
|
|
if (err != nil) { return err }
|
|
}
|
|
|
|
diseaseLocusObjectsList := diseaseObject.LociList
|
|
|
|
for _, diseaseLocusObject := range diseaseLocusObjectsList{
|
|
|
|
locusIdentifierHex := diseaseLocusObject.LocusIdentifier
|
|
|
|
locusIdentifier, err := encoding.DecodeHexStringTo3ByteArray(locusIdentifierHex)
|
|
if (err != nil) { return err }
|
|
|
|
for _, genomeIdentifier := range allGenomeIdentifiersList{
|
|
|
|
_, _, _, _, _, err := GetPersonPolygenicDiseaseLocusInfoFromGeneticAnalysis(personAnalysisObject, diseaseName, locusIdentifier, genomeIdentifier)
|
|
if (err != nil) { return err }
|
|
}
|
|
}
|
|
}
|
|
|
|
traitObjectsList, err := traits.GetTraitObjectsList()
|
|
if (err != nil) { return err }
|
|
|
|
for _, traitObject := range traitObjectsList{
|
|
|
|
traitName := traitObject.TraitName
|
|
|
|
for _, genomeIdentifier := range allGenomeIdentifiersList{
|
|
|
|
_, _, _, _, _, err := GetPersonTraitInfoFromGeneticAnalysis(personAnalysisObject, traitName, genomeIdentifier)
|
|
if (err != nil) { return err }
|
|
}
|
|
|
|
traitRulesList := traitObject.RulesList
|
|
|
|
for _, traitRuleObject := range traitRulesList{
|
|
|
|
ruleIdentifierHex := traitRuleObject.RuleIdentifier
|
|
|
|
ruleIdentifier, err := encoding.DecodeHexStringTo3ByteArray(ruleIdentifierHex)
|
|
if (err != nil) { return err }
|
|
|
|
for _, genomeIdentifier := range allGenomeIdentifiersList{
|
|
|
|
_, _, err := GetPersonTraitRuleInfoFromGeneticAnalysis(personAnalysisObject, traitName, ruleIdentifier, genomeIdentifier)
|
|
if (err != nil) { return err }
|
|
}
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
|
|
// We use this function to verify a couple genetic analysis is well formed
|
|
//TODO: Perform sanity checks on data
|
|
func VerifyCoupleGeneticAnalysis(coupleAnalysisObject geneticAnalysis.CoupleAnalysis)error{
|
|
|
|
pair1Person1GenomeIdentifier, pair1Person2GenomeIdentifier, secondGenomePairExists, pair2Person1GenomeIdentifier, pair2Person2GenomeIdentifier, _, _, _, _, _, _, err := GetMetadataFromCoupleGeneticAnalysis(coupleAnalysisObject)
|
|
if (err != nil) { return err }
|
|
|
|
pair1GenomeIdentifier := helpers.JoinTwo16ByteArrays(pair1Person1GenomeIdentifier, pair1Person2GenomeIdentifier)
|
|
|
|
allGenomePairIdentifiersList := [][32]byte{pair1GenomeIdentifier}
|
|
|
|
if (secondGenomePairExists == true){
|
|
|
|
pair2GenomeIdentifier := helpers.JoinTwo16ByteArrays(pair2Person1GenomeIdentifier, pair2Person2GenomeIdentifier)
|
|
|
|
allGenomePairIdentifiersList = append(allGenomePairIdentifiersList, pair2GenomeIdentifier)
|
|
}
|
|
|
|
monogenicDiseaseObjectsList, err := monogenicDiseases.GetMonogenicDiseaseObjectsList()
|
|
if (err != nil) { return err }
|
|
|
|
for _, monogenicDiseaseObject := range monogenicDiseaseObjectsList{
|
|
|
|
diseaseName := monogenicDiseaseObject.DiseaseName
|
|
|
|
for _, genomePairIdentifier := range allGenomePairIdentifiersList{
|
|
|
|
_, _, _, _, _, _, _, err = GetOffspringMonogenicDiseaseInfoFromGeneticAnalysis(coupleAnalysisObject, diseaseName, genomePairIdentifier)
|
|
if (err != nil) { return err }
|
|
}
|
|
|
|
diseaseVariantObjectsList := monogenicDiseaseObject.VariantsList
|
|
|
|
for _, diseaseVariantObject := range diseaseVariantObjectsList{
|
|
|
|
variantIdentifierHex := diseaseVariantObject.VariantIdentifier
|
|
|
|
variantIdentifier, err := encoding.DecodeHexStringTo3ByteArray(variantIdentifierHex)
|
|
if (err != nil) { return err }
|
|
|
|
for _, genomePairIdentifier := range allGenomePairIdentifiersList{
|
|
|
|
_, _, _, _, _, _, _, _, _, _, err := GetOffspringMonogenicDiseaseVariantInfoFromGeneticAnalysis(coupleAnalysisObject, diseaseName, variantIdentifier, genomePairIdentifier)
|
|
if (err != nil) { return err }
|
|
}
|
|
}
|
|
}
|
|
|
|
polygenicDiseaseObjectsList, err := polygenicDiseases.GetPolygenicDiseaseObjectsList()
|
|
if (err != nil) { return err }
|
|
|
|
for _, diseaseObject := range polygenicDiseaseObjectsList{
|
|
|
|
diseaseName := diseaseObject.DiseaseName
|
|
|
|
for _, genomePairIdentifier := range allGenomePairIdentifiersList{
|
|
|
|
_, _, _, _, _, _, err := GetOffspringPolygenicDiseaseInfoFromGeneticAnalysis(coupleAnalysisObject, diseaseName, genomePairIdentifier)
|
|
if (err != nil) { return err }
|
|
}
|
|
|
|
diseaseLocusObjectsList := diseaseObject.LociList
|
|
|
|
for _, diseaseLocusObject := range diseaseLocusObjectsList{
|
|
|
|
locusIdentifierHex := diseaseLocusObject.LocusIdentifier
|
|
|
|
locusIdentifier, err := encoding.DecodeHexStringTo3ByteArray(locusIdentifierHex)
|
|
if (err != nil) { return err }
|
|
|
|
for _, genomePairIdentifier := range allGenomePairIdentifiersList{
|
|
|
|
_, _, _, _, _, err := GetOffspringPolygenicDiseaseLocusInfoFromGeneticAnalysis(coupleAnalysisObject, diseaseName, locusIdentifier, genomePairIdentifier)
|
|
if (err != nil) { return err }
|
|
}
|
|
}
|
|
}
|
|
|
|
traitObjectsList, err := traits.GetTraitObjectsList()
|
|
if (err != nil) { return err }
|
|
|
|
for _, traitObject := range traitObjectsList{
|
|
|
|
traitName := traitObject.TraitName
|
|
|
|
for _, genomePairIdentifier := range allGenomePairIdentifiersList{
|
|
|
|
_, _, _, _, err := GetOffspringTraitInfoFromGeneticAnalysis(coupleAnalysisObject, traitName, genomePairIdentifier)
|
|
if (err != nil) { return err }
|
|
}
|
|
|
|
traitRulesList := traitObject.RulesList
|
|
|
|
for _, traitRuleObject := range traitRulesList{
|
|
|
|
ruleIdentifierHex := traitRuleObject.RuleIdentifier
|
|
|
|
ruleIdentifier, err := encoding.DecodeHexStringTo3ByteArray(ruleIdentifierHex)
|
|
if (err != nil) { return err }
|
|
|
|
for _, genomePairIdentifier := range allGenomePairIdentifiersList{
|
|
|
|
_, _, _, err := GetOffspringTraitRuleInfoFromGeneticAnalysis(coupleAnalysisObject, traitName, ruleIdentifier, genomePairIdentifier)
|
|
if (err != nil) { return err }
|
|
}
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
|