# -*- coding: utf-8 -*-
# Copyright (c) 2016-2017, Zhijiang Yao, Jie Dong and Dongsheng Cao
# All rights reserved.
# This file is part of the PyBioMed.
# The contents are covered by the terms of the BSD license
# which is included in the file license.txt, found at the root
# of the PyBioMed source tree.
"""
##########################################################################################
This module is used for computing the Autocorrelation descriptors based different
properties of AADs.You can also input your properties of AADs, then it can help you
to compute Autocorrelation descriptors based on the property of AADs. Currently, You
can get 720 descriptors for a given protein sequence based on our provided physicochemical
properties of AADs. You can freely use and distribute it. If you hava any problem,
you could contact with us timely!
References:
[1]: http://www.genome.ad.jp/dbget/aaindex.html
[2]:Feng, Z.P. and Zhang, C.T. (2000) Prediction of membrane protein types based on
the hydrophobic index of amino acids. J Protein Chem, 19, 269-275.
[3]:Horne, D.S. (1988) Prediction of protein helix content from an autocorrelation
analysis of sequence hydrophobicities. Biopolymers, 27, 451-477.
[4]:Sokal, R.R. and Thomson, B.A. (2006) Population structure inferred by local
spatial autocorrelation: an Usage from an Amerindian tribal population. Am J
Phys Anthropol, 129, 121-131.
Authors: Zhijiang Yao and Dongsheng Cao.
Date: 2016.06.04
Email: gadsby@163.com
##########################################################################################
"""
import math, string
AALetter = ["A", "R", "N", "D", "C", "Q", "E", "G", "H", "I", "L", "K", "M", "F", "P", "S", "T", "W", "Y", "V"]
_Hydrophobicity = {"A": 0.02, "R": -0.42, "N": -0.77, "D": -1.04, "C": 0.77, "Q": -1.10, "E": -1.14, "G": -0.80,
"H": 0.26, "I": 1.81, "L": 1.14, "K": -0.41, "M": 1.00, "F": 1.35, "P": -0.09, "S": -0.97,
"T": -0.77, "W": 1.71, "Y": 1.11, "V": 1.13}
_AvFlexibility = {"A": 0.357, "R": 0.529, "N": 0.463, "D": 0.511, "C": 0.346, "Q": 0.493, "E": 0.497, "G": 0.544,
"H": 0.323, "I": 0.462, "L": 0.365, "K": 0.466, "M": 0.295, "F": 0.314, "P": 0.509, "S": 0.507,
"T": 0.444, "W": 0.305, "Y": 0.420, "V": 0.386}
_Polarizability = {"A": 0.046, "R": 0.291, "N": 0.134, "D": 0.105, "C": 0.128, "Q": 0.180, "E": 0.151, "G": 0.000,
"H": 0.230, "I": 0.186, "L": 0.186, "K": 0.219, "M": 0.221, "F": 0.290, "P": 0.131, "S": 0.062,
"T": 0.108, "W": 0.409, "Y": 0.298, "V": 0.140}
_FreeEnergy = {"A": -0.368, "R": -1.03, "N": 0.0, "D": 2.06, "C": 4.53, "Q": 0.731, "E": 1.77, "G": -0.525, "H": 0.0,
"I": 0.791, "L": 1.07, "K": 0.0, "M": 0.656, "F": 1.06, "P": -2.24, "S": -0.524, "T": 0.0, "W": 1.60,
"Y": 4.91, "V": 0.401}
_ResidueASA = {"A": 115.0, "R": 225.0, "N": 160.0, "D": 150.0, "C": 135.0, "Q": 180.0, "E": 190.0, "G": 75.0,
"H": 195.0, "I": 175.0, "L": 170.0, "K": 200.0, "M": 185.0, "F": 210.0, "P": 145.0, "S": 115.0,
"T": 140.0, "W": 255.0, "Y": 230.0, "V": 155.0}
_ResidueVol = {"A": 52.6, "R": 109.1, "N": 75.7, "D": 68.4, "C": 68.3, "Q": 89.7, "E": 84.7, "G": 36.3, "H": 91.9,
"I": 102.0, "L": 102.0, "K": 105.1, "M": 97.7, "F": 113.9, "P": 73.6, "S": 54.9, "T": 71.2, "W": 135.4,
"Y": 116.2, "V": 85.1}
_Steric = {"A": 0.52, "R": 0.68, "N": 0.76, "D": 0.76, "C": 0.62, "Q": 0.68, "E": 0.68, "G": 0.00, "H": 0.70, "I": 1.02,
"L": 0.98, "K": 0.68, "M": 0.78, "F": 0.70, "P": 0.36, "S": 0.53, "T": 0.50, "W": 0.70, "Y": 0.70, "V": 0.76}
_Mutability = {"A": 100.0, "R": 65.0, "N": 134.0, "D": 106.0, "C": 20.0, "Q": 93.0, "E": 102.0, "G": 49.0, "H": 66.0,
"I": 96.0, "L": 40.0, "K": -56.0, "M": 94.0, "F": 41.0, "P": 56.0, "S": 120.0, "T": 97.0, "W": 18.0,
"Y": 41.0, "V": 74.0}
###You can continuely add other properties of AADs to compute the descriptors of protein sequence.
_AAProperty = (
_Hydrophobicity, _AvFlexibility, _Polarizability, _FreeEnergy, _ResidueASA, _ResidueVol, _Steric, _Mutability)
_AAPropertyName = (
'_Hydrophobicity', '_AvFlexibility', '_Polarizability', '_FreeEnergy', '_ResidueASA', '_ResidueVol', '_Steric',
'_Mutability')
##################################################################################################
def _mean(listvalue):
"""
The mean value of the list data.
"""
return sum(listvalue) / len(listvalue)
##################################################################################################
def _std(listvalue, ddof=1):
"""
The standard deviation of the list data.
"""
mean = _mean(listvalue)
temp = [math.pow(i - mean, 2) for i in listvalue]
res = math.sqrt(sum(temp) / (len(listvalue) - ddof))
return res
##################################################################################################
[docs]def NormalizeEachAAP(AAP):
"""
####################################################################################
All of the amino acid indices are centralized and
standardized before the calculation.
Usage:
result=NormalizeEachAAP(AAP)
Input: AAP is a dict form containing the properties of 20 amino acids.
Output: result is the a dict form containing the normalized properties
of 20 amino acids.
####################################################################################
"""
if len(AAP.values()) != 20:
print 'You can not input the correct number of properities of Amino acids!'
else:
Result = {}
for i, j in AAP.items():
Result[i] = (j - _mean(AAP.values())) / _std(AAP.values(), ddof=0)
return Result
[docs]def CalculateEachNormalizedMoreauBrotoAuto(ProteinSequence, AAP, AAPName):
"""
####################################################################################
you can use the function to compute MoreauBrotoAuto
descriptors for different properties based on AADs.
Usage:
result=CalculateEachNormalizedMoreauBrotoAuto(protein,AAP,AAPName)
Input: protein is a pure protein sequence.
AAP is a dict form containing the properties of 20 amino acids (e.g., _AvFlexibility).
AAPName is a string used for indicating the property (e.g., '_AvFlexibility').
Output: result is a dict form containing 30 Normalized Moreau-Broto autocorrelation
descriptors based on the given property.
####################################################################################
"""
AAPdic = NormalizeEachAAP(AAP)
Result = {}
for i in range(1, 31):
temp = 0
for j in range(len(ProteinSequence) - i):
temp = temp + AAPdic[ProteinSequence[j]] * AAPdic[ProteinSequence[j + 1]]
if len(ProteinSequence) - i == 0:
Result['MoreauBrotoAuto' + AAPName + str(i)] = round(temp / (len(ProteinSequence)), 3)
else:
Result['MoreauBrotoAuto' + AAPName + str(i)] = round(temp / (len(ProteinSequence) - i), 3)
return Result
[docs]def CalculateEachMoranAuto(ProteinSequence, AAP, AAPName):
"""
####################################################################################
you can use the function to compute MoranAuto
descriptors for different properties based on AADs.
Usage:
result=CalculateEachMoranAuto(protein,AAP,AAPName)
Input: protein is a pure protein sequence.
AAP is a dict form containing the properties of 20 amino acids (e.g., _AvFlexibility).
AAPName is a string used for indicating the property (e.g., '_AvFlexibility').
Output: result is a dict form containing 30 Moran autocorrelation
descriptors based on the given property.
####################################################################################
"""
AAPdic = NormalizeEachAAP(AAP)
cds = 0
for i in AALetter:
cds = cds + (ProteinSequence.count(i)) * (AAPdic[i])
Pmean = cds / len(ProteinSequence)
cc = []
for i in ProteinSequence:
cc.append(AAPdic[i])
K = (_std(cc, ddof=0)) ** 2
Result = {}
for i in range(1, 31):
temp = 0
for j in range(len(ProteinSequence) - i):
temp = temp + (AAPdic[ProteinSequence[j]] - Pmean) * (AAPdic[ProteinSequence[j + i]] - Pmean)
if len(ProteinSequence) - i == 0:
Result['MoranAuto' + AAPName + str(i)] = round(temp / (len(ProteinSequence)) / K, 3)
else:
Result['MoranAuto' + AAPName + str(i)] = round(temp / (len(ProteinSequence) - i) / K, 3)
return Result
[docs]def CalculateEachGearyAuto(ProteinSequence, AAP, AAPName):
"""
####################################################################################
you can use the function to compute GearyAuto
descriptors for different properties based on AADs.
Usage:
result=CalculateEachGearyAuto(protein,AAP,AAPName)
Input: protein is a pure protein sequence.
AAP is a dict form containing the properties of 20 amino acids (e.g., _AvFlexibility).
AAPName is a string used for indicating the property (e.g., '_AvFlexibility').
Output: result is a dict form containing 30 Geary autocorrelation
descriptors based on the given property.
####################################################################################
"""
AAPdic = NormalizeEachAAP(AAP)
cc = []
for i in ProteinSequence:
cc.append(AAPdic[i])
K = ((_std(cc)) ** 2) * len(ProteinSequence) / (len(ProteinSequence) - 1)
Result = {}
for i in range(1, 31):
temp = 0
for j in range(len(ProteinSequence) - i):
temp = temp + (AAPdic[ProteinSequence[j]] - AAPdic[ProteinSequence[j + i]]) ** 2
if len(ProteinSequence) - i == 0:
Result['GearyAuto' + AAPName + str(i)] = round(temp / (2 * (len(ProteinSequence))) / K, 3)
else:
Result['GearyAuto' + AAPName + str(i)] = round(temp / (2 * (len(ProteinSequence) - i)) / K, 3)
return Result
##################################################################################################
[docs]def CalculateNormalizedMoreauBrotoAuto(ProteinSequence, AAProperty, AAPropertyName):
"""
####################################################################################
A method used for computing MoreauBrotoAuto for all properties.
Usage:
result=CalculateNormalizedMoreauBrotoAuto(protein,AAP,AAPName)
Input: protein is a pure protein sequence.
AAProperty is a list or tuple form containing the properties of 20 amino acids (e.g., _AAProperty).
AAPName is a list or tuple form used for indicating the property (e.g., '_AAPropertyName').
Output: result is a dict form containing 30*p Normalized Moreau-Broto autocorrelation
descriptors based on the given properties.
####################################################################################
"""
Result = {}
for i in range(len(AAProperty)):
Result[AAPropertyName[i]] = CalculateEachNormalizedMoreauBrotoAuto(ProteinSequence, AAProperty[i],
AAPropertyName[i])
return Result
[docs]def CalculateMoranAuto(ProteinSequence, AAProperty, AAPropertyName):
"""
####################################################################################
A method used for computing MoranAuto for all properties
Usage:
result=CalculateMoranAuto(protein,AAP,AAPName)
Input: protein is a pure protein sequence.
AAProperty is a list or tuple form containing the properties of 20 amino acids (e.g., _AAProperty).
AAPName is a list or tuple form used for indicating the property (e.g., '_AAPropertyName').
Output: result is a dict form containing 30*p Moran autocorrelation
descriptors based on the given properties.
####################################################################################
"""
Result = {}
for i in range(len(AAProperty)):
Result[AAPropertyName[i]] = CalculateEachMoranAuto(ProteinSequence, AAProperty[i], AAPropertyName[i])
return Result
[docs]def CalculateGearyAuto(ProteinSequence, AAProperty, AAPropertyName):
"""
####################################################################################
A method used for computing GearyAuto for all properties
Usage:
result=CalculateGearyAuto(protein,AAP,AAPName)
Input: protein is a pure protein sequence.
AAProperty is a list or tuple form containing the properties of 20 amino acids (e.g., _AAProperty).
AAPName is a list or tuple form used for indicating the property (e.g., '_AAPropertyName').
Output: result is a dict form containing 30*p Geary autocorrelation
descriptors based on the given properties.
####################################################################################
"""
Result = {}
for i in range(len(AAProperty)):
Result[AAPropertyName[i]] = CalculateEachGearyAuto(ProteinSequence, AAProperty[i], AAPropertyName[i])
return Result
########################NormalizedMoreauBorto##################################
[docs]def CalculateNormalizedMoreauBrotoAutoHydrophobicity(ProteinSequence):
"""
####################################################################################
Calculte the NormalizedMoreauBorto Autocorrelation descriptors based on
hydrophobicity.
Usage:
result=CalculateNormalizedMoreauBrotoAutoHydrophobicity(protein)
Input: protein is a pure protein sequence.
Output: result is a dict form containing 30 Normalized Moreau-Broto Autocorrelation
descriptors based on Hydrophobicity.
####################################################################################
"""
result = CalculateEachNormalizedMoreauBrotoAuto(ProteinSequence, _Hydrophobicity, '_Hydrophobicity')
return result
[docs]def CalculateNormalizedMoreauBrotoAutoAvFlexibility(ProteinSequence):
"""
####################################################################################
Calculte the NormalizedMoreauBorto Autocorrelation descriptors based on
AvFlexibility.
Usage:
result=CalculateNormalizedMoreauBrotoAutoAvFlexibility(protein)
Input: protein is a pure protein sequence.
Output: result is a dict form containing 30 Normalized Moreau-Broto Autocorrelation
descriptors based on AvFlexibility.
####################################################################################
"""
result = CalculateEachNormalizedMoreauBrotoAuto(ProteinSequence, _AvFlexibility, '_AvFlexibility')
return result
[docs]def CalculateNormalizedMoreauBrotoAutoPolarizability(ProteinSequence):
"""
####################################################################################
Calculte the NormalizedMoreauBorto Autocorrelation descriptors based on
Polarizability.
Usage:
result=CalculateNormalizedMoreauBrotoAutoPolarizability(protein)
Input: protein is a pure protein sequence.
Output: result is a dict form containing 30 Normalized Moreau-Broto Autocorrelation
descriptors based on Polarizability.
####################################################################################
"""
result = CalculateEachNormalizedMoreauBrotoAuto(ProteinSequence, _Polarizability, '_Polarizability')
return result
[docs]def CalculateNormalizedMoreauBrotoAutoFreeEnergy(ProteinSequence):
"""
####################################################################################
Calculte the NormalizedMoreauBorto Autocorrelation descriptors based on
FreeEnergy.
Usage:
result=CalculateNormalizedMoreauBrotoAutoFreeEnergy(protein)
Input: protein is a pure protein sequence.
Output: result is a dict form containing 30 Normalized Moreau-Broto Autocorrelation
descriptors based on FreeEnergy.
####################################################################################
"""
result = CalculateEachNormalizedMoreauBrotoAuto(ProteinSequence, _FreeEnergy, '_FreeEnergy')
return result
[docs]def CalculateNormalizedMoreauBrotoAutoResidueASA(ProteinSequence):
"""
####################################################################################
Calculte the NormalizedMoreauBorto Autocorrelation descriptors based on
ResidueASA.
Usage:
result=CalculateNormalizedMoreauBrotoAutoResidueASA(protein)
Input: protein is a pure protein sequence.
Output: result is a dict form containing 30 Normalized Moreau-Broto Autocorrelation
descriptors based on ResidueASA.
####################################################################################
"""
result = CalculateEachNormalizedMoreauBrotoAuto(ProteinSequence, _ResidueASA, '_ResidueASA')
return result
[docs]def CalculateNormalizedMoreauBrotoAutoResidueVol(ProteinSequence):
"""
####################################################################################
Calculte the NormalizedMoreauBorto Autocorrelation descriptors based on
ResidueVol.
Usage:
result=CalculateNormalizedMoreauBrotoAutoResidueVol(protein)
Input: protein is a pure protein sequence.
Output: result is a dict form containing 30 Normalized Moreau-Broto Autocorrelation
descriptors based on ResidueVol.
####################################################################################
"""
result = CalculateEachNormalizedMoreauBrotoAuto(ProteinSequence, _ResidueVol, '_ResidueVol')
return result
[docs]def CalculateNormalizedMoreauBrotoAutoSteric(ProteinSequence):
"""
####################################################################################
Calculte the NormalizedMoreauBorto Autocorrelation descriptors based on Steric.
Usage:
result=CalculateNormalizedMoreauBrotoAutoSteric(protein)
Input: protein is a pure protein sequence.
Output: result is a dict form containing 30 Normalized Moreau-Broto Autocorrelation
descriptors based on Steric.
####################################################################################
"""
result = CalculateEachNormalizedMoreauBrotoAuto(ProteinSequence, _Steric, '_Steric')
return result
[docs]def CalculateNormalizedMoreauBrotoAutoMutability(ProteinSequence):
"""
####################################################################################
Calculte the NormalizedMoreauBorto Autocorrelation descriptors based on Mutability.
Usage:
result=CalculateNormalizedMoreauBrotoAutoMutability(protein)
Input: protein is a pure protein sequence.
Output: result is a dict form containing 30 Normalized Moreau-Broto Autocorrelation
descriptors based on Mutability.
####################################################################################
"""
result = CalculateEachNormalizedMoreauBrotoAuto(ProteinSequence, _Mutability, '_Mutability')
return result
############################################################################
##############################MoranAuto######################################
[docs]def CalculateMoranAutoHydrophobicity(ProteinSequence):
"""
####################################################################################
Calculte the MoranAuto Autocorrelation descriptors based on hydrophobicity.
Usage:
result=CalculateMoranAutoHydrophobicity(protein)
Input: protein is a pure protein sequence.
Output: result is a dict form containing 30 Moran Autocorrelation
descriptors based on hydrophobicity.
####################################################################################
"""
result = CalculateEachMoranAuto(ProteinSequence, _Hydrophobicity, '_Hydrophobicity')
return result
[docs]def CalculateMoranAutoAvFlexibility(ProteinSequence):
"""
####################################################################################
Calculte the MoranAuto Autocorrelation descriptors based on
AvFlexibility.
Usage:
result=CalculateMoranAutoAvFlexibility(protein)
Input: protein is a pure protein sequence.
Output: result is a dict form containing 30 Moran Autocorrelation
descriptors based on AvFlexibility.
####################################################################################
"""
result = CalculateEachMoranAuto(ProteinSequence, _AvFlexibility, '_AvFlexibility')
return result
[docs]def CalculateMoranAutoPolarizability(ProteinSequence):
"""
####################################################################################
Calculte the MoranAuto Autocorrelation descriptors based on
Polarizability.
Usage:
result=CalculateMoranAutoPolarizability(protein)
Input: protein is a pure protein sequence.
Output: result is a dict form containing 30 Moran Autocorrelation
descriptors based on Polarizability.
####################################################################################
"""
result = CalculateEachMoranAuto(ProteinSequence, _Polarizability, '_Polarizability')
return result
[docs]def CalculateMoranAutoFreeEnergy(ProteinSequence):
"""
####################################################################################
Calculte the MoranAuto Autocorrelation descriptors based on
FreeEnergy.
Usage:
result=CalculateMoranAutoFreeEnergy(protein)
Input: protein is a pure protein sequence.
Output: result is a dict form containing 30 Moran Autocorrelation
descriptors based on FreeEnergy.
####################################################################################
"""
result = CalculateEachMoranAuto(ProteinSequence, _FreeEnergy, '_FreeEnergy')
return result
[docs]def CalculateMoranAutoResidueASA(ProteinSequence):
"""
####################################################################################
Calculte the MoranAuto Autocorrelation descriptors based on
ResidueASA.
Usage:
result=CalculateMoranAutoResidueASA(protein)
Input: protein is a pure protein sequence.
Output: result is a dict form containing 30 Moran Autocorrelation
descriptors based on ResidueASA.
####################################################################################
"""
result = CalculateEachMoranAuto(ProteinSequence, _ResidueASA, '_ResidueASA')
return result
[docs]def CalculateMoranAutoResidueVol(ProteinSequence):
"""
####################################################################################
Calculte the MoranAuto Autocorrelation descriptors based on
ResidueVol.
Usage:
result=CalculateMoranAutoResidueVol(protein)
Input: protein is a pure protein sequence.
Output: result is a dict form containing 30 Moran Autocorrelation
descriptors based on ResidueVol.
####################################################################################
"""
result = CalculateEachMoranAuto(ProteinSequence, _ResidueVol, '_ResidueVol')
return result
[docs]def CalculateMoranAutoSteric(ProteinSequence):
"""
####################################################################################
Calculte the MoranAuto Autocorrelation descriptors based on
AutoSteric.
Usage:
result=CalculateMoranAutoSteric(protein)
Input: protein is a pure protein sequence.
Output: result is a dict form containing 30 Moran Autocorrelation
descriptors based on AutoSteric.
####################################################################################
"""
result = CalculateEachMoranAuto(ProteinSequence, _Steric, '_Steric')
return result
[docs]def CalculateMoranAutoMutability(ProteinSequence):
"""
####################################################################################
Calculte the MoranAuto Autocorrelation descriptors based on
Mutability.
Usage:
result=CalculateMoranAutoMutability(protein)
Input: protein is a pure protein sequence.
Output: result is a dict form containing 30 Moran Autocorrelation
descriptors based on Mutability.
####################################################################################
"""
result = CalculateEachMoranAuto(ProteinSequence, _Mutability, '_Mutability')
return result
############################################################################
################################GearyAuto#####################################
[docs]def CalculateGearyAutoHydrophobicity(ProteinSequence):
"""
####################################################################################
Calculte the GearyAuto Autocorrelation descriptors based on
hydrophobicity.
Usage:
result=CalculateGearyAutoHydrophobicity(protein)
Input: protein is a pure protein sequence.
Output: result is a dict form containing 30 Geary Autocorrelation
descriptors based on hydrophobicity.
####################################################################################
"""
result = CalculateEachGearyAuto(ProteinSequence, _Hydrophobicity, '_Hydrophobicity')
return result
[docs]def CalculateGearyAutoAvFlexibility(ProteinSequence):
"""
####################################################################################
Calculte the GearyAuto Autocorrelation descriptors based on
AvFlexibility.
Usage:
result=CalculateGearyAutoAvFlexibility(protein)
Input: protein is a pure protein sequence.
Output: result is a dict form containing 30 Geary Autocorrelation
descriptors based on AvFlexibility.
####################################################################################
"""
result = CalculateEachGearyAuto(ProteinSequence, _AvFlexibility, '_AvFlexibility')
return result
[docs]def CalculateGearyAutoPolarizability(ProteinSequence):
"""
####################################################################################
Calculte the GearyAuto Autocorrelation descriptors based on
Polarizability.
Usage:
result=CalculateGearyAutoPolarizability(protein)
Input: protein is a pure protein sequence.
Output: result is a dict form containing 30 Geary Autocorrelation
descriptors based on Polarizability.
####################################################################################
"""
result = CalculateEachGearyAuto(ProteinSequence, _Polarizability, '_Polarizability')
return result
[docs]def CalculateGearyAutoFreeEnergy(ProteinSequence):
"""
####################################################################################
Calculte the GearyAuto Autocorrelation descriptors based on
FreeEnergy.
Usage:
result=CalculateGearyAutoFreeEnergy(protein)
Input: protein is a pure protein sequence.
Output: result is a dict form containing 30 Geary Autocorrelation
descriptors based on FreeEnergy.
####################################################################################
"""
result = CalculateEachGearyAuto(ProteinSequence, _FreeEnergy, '_FreeEnergy')
return result
[docs]def CalculateGearyAutoResidueASA(ProteinSequence):
"""
####################################################################################
Calculte the GearyAuto Autocorrelation descriptors based on
ResidueASA.
Usage:
result=CalculateGearyAutoResidueASA(protein)
Input: protein is a pure protein sequence.
Output: result is a dict form containing 30 Geary Autocorrelation
descriptors based on ResidueASA.
####################################################################################
"""
result = CalculateEachGearyAuto(ProteinSequence, _ResidueASA, '_ResidueASA')
return result
[docs]def CalculateGearyAutoResidueVol(ProteinSequence):
"""
####################################################################################
Calculte the GearyAuto Autocorrelation descriptors based on
ResidueVol.
Usage:
result=CalculateGearyAutoResidueVol(protein)
Input: protein is a pure protein sequence.
Output: result is a dict form containing 30 Geary Autocorrelation
descriptors based on ResidueVol.
####################################################################################
"""
result = CalculateEachGearyAuto(ProteinSequence, _ResidueVol, '_ResidueVol')
return result
[docs]def CalculateGearyAutoSteric(ProteinSequence):
"""
####################################################################################
Calculte the GearyAuto Autocorrelation descriptors based on
Steric.
Usage:
result=CalculateGearyAutoSteric(protein)
Input: protein is a pure protein sequence.
Output: result is a dict form containing 30 Geary Autocorrelation
descriptors based on Steric.
####################################################################################
"""
result = CalculateEachGearyAuto(ProteinSequence, _Steric, '_Steric')
return result
[docs]def CalculateGearyAutoMutability(ProteinSequence):
"""
####################################################################################
Calculte the GearyAuto Autocorrelation descriptors based on
Mutability.
Usage:
result=CalculateGearyAutoMutability(protein)
Input: protein is a pure protein sequence.
Output: result is a dict form containing 30 Geary Autocorrelation
descriptors based on Mutability.
####################################################################################
"""
result = CalculateEachGearyAuto(ProteinSequence, _Mutability, '_Mutability')
return result
##################################################################################################
[docs]def CalculateNormalizedMoreauBrotoAutoTotal(ProteinSequence):
"""
####################################################################################
A method used for computing normalized Moreau Broto autocorrelation descriptors based
on 8 proterties of AADs.
Usage:
result=CalculateNormalizedMoreauBrotoAutoTotal(protein)
Input: protein is a pure protein sequence.
Output: result is a dict form containing 30*8=240 normalized Moreau Broto
autocorrelation descriptors based on the given properties(i.e., _AAPropert).
####################################################################################
"""
result = {}
result.update(CalculateNormalizedMoreauBrotoAutoHydrophobicity(ProteinSequence))
result.update(CalculateNormalizedMoreauBrotoAutoAvFlexibility(ProteinSequence))
result.update(CalculateNormalizedMoreauBrotoAutoPolarizability(ProteinSequence))
result.update(CalculateNormalizedMoreauBrotoAutoFreeEnergy(ProteinSequence))
result.update(CalculateNormalizedMoreauBrotoAutoResidueASA(ProteinSequence))
result.update(CalculateNormalizedMoreauBrotoAutoResidueVol(ProteinSequence))
result.update(CalculateNormalizedMoreauBrotoAutoSteric(ProteinSequence))
result.update(CalculateNormalizedMoreauBrotoAutoMutability(ProteinSequence))
return result
[docs]def CalculateMoranAutoTotal(ProteinSequence):
"""
####################################################################################
A method used for computing Moran autocorrelation descriptors based on 8 properties of AADs.
Usage:
result=CalculateMoranAutoTotal(protein)
Input: protein is a pure protein sequence.
Output: result is a dict form containing 30*8=240 Moran
autocorrelation descriptors based on the given properties(i.e., _AAPropert).
####################################################################################
"""
result = {}
result.update(CalculateMoranAutoHydrophobicity(ProteinSequence))
result.update(CalculateMoranAutoAvFlexibility(ProteinSequence))
result.update(CalculateMoranAutoPolarizability(ProteinSequence))
result.update(CalculateMoranAutoFreeEnergy(ProteinSequence))
result.update(CalculateMoranAutoResidueASA(ProteinSequence))
result.update(CalculateMoranAutoResidueVol(ProteinSequence))
result.update(CalculateMoranAutoSteric(ProteinSequence))
result.update(CalculateMoranAutoMutability(ProteinSequence))
return result
[docs]def CalculateGearyAutoTotal(ProteinSequence):
"""
####################################################################################
A method used for computing Geary autocorrelation descriptors based on 8 properties of AADs.
Usage:
result=CalculateGearyAutoTotal(protein)
Input: protein is a pure protein sequence.
Output: result is a dict form containing 30*8=240 Geary
autocorrelation descriptors based on the given properties(i.e., _AAPropert).
####################################################################################
"""
result = {}
result.update(CalculateGearyAutoHydrophobicity(ProteinSequence))
result.update(CalculateGearyAutoAvFlexibility(ProteinSequence))
result.update(CalculateGearyAutoPolarizability(ProteinSequence))
result.update(CalculateGearyAutoFreeEnergy(ProteinSequence))
result.update(CalculateGearyAutoResidueASA(ProteinSequence))
result.update(CalculateGearyAutoResidueVol(ProteinSequence))
result.update(CalculateGearyAutoSteric(ProteinSequence))
result.update(CalculateGearyAutoMutability(ProteinSequence))
return result
##################################################################################################
[docs]def CalculateAutoTotal(ProteinSequence):
"""
####################################################################################
A method used for computing all autocorrelation descriptors based on 8 properties of AADs.
Usage:
result=CalculateGearyAutoTotal(protein)
Input: protein is a pure protein sequence.
Output: result is a dict form containing 30*8*3=720 normalized Moreau Broto, Moran, and Geary
autocorrelation descriptors based on the given properties(i.e., _AAPropert).
####################################################################################
"""
result = {}
result.update(CalculateNormalizedMoreauBrotoAutoTotal(ProteinSequence))
result.update(CalculateMoranAutoTotal(ProteinSequence))
result.update(CalculateGearyAutoTotal(ProteinSequence))
return result
##################################################################################################
if __name__ == "__main__":
protein = "ADGCGVGEGTGQGPMCNCMCMKWVYADEDAADLESDSFADEDASLESDSFPWSNQRVFCSFADEDAS"
temp1 = CalculateNormalizedMoreauBrotoAuto(protein, AAProperty=_AAProperty, AAPropertyName=_AAPropertyName)
# print temp1
temp2 = CalculateMoranAutoMutability(protein)
print temp2
print len(CalculateAutoTotal(protein))
