def _CalculateGearyAutocorrelation(mol, lag=1, propertylabel="m"): """ ################################################################# **Internal used only** Calculation of Geary autocorrelation descriptors based on different property weights. Usage: res=_CalculateGearyAutocorrelation(mol,lag=1,propertylabel='m') Input: mol is a molecule object. lag is the topological distance between atom i and atom j. propertylabel is the weighted property. Output: res is a numeric value. ################################################################# """ Natom = mol.GetNumAtoms() prolist = [] for i in mol.GetAtoms(): temp = GetRelativeAtomicProperty(i.GetSymbol(), propertyname=propertylabel) prolist.append(temp) aveweight = sum(prolist) / Natom tempp = [numpy.square(x - aveweight) for x in prolist] GetDistanceMatrix = Chem.GetDistanceMatrix(mol) res = 0.0 index = 0 for i in range(Natom): for j in range(Natom): if GetDistanceMatrix[i, j] == lag: atom1 = mol.GetAtomWithIdx(i) atom2 = mol.GetAtomWithIdx(j) temp1 = GetRelativeAtomicProperty( element=atom1.GetSymbol(), propertyname=propertylabel ) temp2 = GetRelativeAtomicProperty( element=atom2.GetSymbol(), propertyname=propertylabel ) res = res + numpy.square(temp1 - temp2) index = index + 1 else: res = res + 0.0 if sum(tempp) == 0 or index == 0: result = 0 else: result = (res / index / 2) / (sum(tempp) / (Natom - 1)) return round(result, 3)
def CalculateVDWVolumeMoRSE(ChargeCoordinates): """ ################################################################# The calculation of 3-D MoRse descriptors based on atomic van der Waals volume. ################################################################# """ R=_GetR(n=30) temp=[] VDW=[] for i in ChargeCoordinates: #if i[0]!='H': temp.append([float(i[0]),float(i[1]),float(i[2])]) VDW.append(GetRelativeAtomicProperty(i[3],'V')) DM=_GetGementricalDistanceMatrix(temp) nAT=len(temp) RDFresult={} for kkk,Ri in enumerate(R): res=0.0 for j in range(nAT-1): for k in range(j+1,nAT): res=res+VDW[j]*VDW[k]*math.sin(Ri*DM[j,k])/(Ri*DM[j,k]) RDFresult['MoRSE'+'V'+str(kkk+1)]=round(res,3) return RDFresult
def CalculateSandersonElectronegativityMoRSE(lcoordinates): """ ################################################################# The calculation of 3-D MoRse descriptors based on atomic sanderson electronegativity. ################################################################# """ R=_GetR(n=30) temp=[] En=[] for i in lcoordinates: #if i[0]!='H': temp.append([float(i[0]),float(i[1]),float(i[2])]) En.append(GetRelativeAtomicProperty(i[3],'En')) DM=_GetGementricalDistanceMatrix(temp) nAT=len(temp) RDFresult={} for kkk,Ri in enumerate(R): res=0.0 for j in range(nAT-1): for k in range(j+1,nAT): res=res+En[j]*En[k]*math.sin(Ri*DM[j,k])/(Ri*DM[j,k]) RDFresult['MoRSE'+'E'+str(kkk+1)]=round(res,3) return RDFresult
def CalculatePolarizabilityMoRSE(lcoordinates): """ ################################################################# The calculation of 3-D MoRse descriptors based on atomic polarizablity. ################################################################# """ R=_GetR(n=30) temp=[] polarizability=[] for i in lcoordinates: #if i[0]!='H': temp.append([float(i[0]),float(i[1]),float(i[2])]) polarizability.append(GetRelativeAtomicProperty(i[3],'alapha')) DM=_GetGementricalDistanceMatrix(temp) nAT=len(temp) RDFresult={} for kkk,Ri in enumerate(R): res=0.0 for j in range(nAT-1): for k in range(j+1,nAT): res=res+polarizability[j]*polarizability[k]*math.sin(Ri*DM[j,k])/(Ri*DM[j,k]) RDFresult['MoRSE'+'P'+str(kkk+1)]=round(res,3) return RDFresult
def CalculateVDWVolumeRDF(ChargeCoordinates): """ ################################################################# The calculation of radial distribution function (RDF) descriptors based on atomic van der Waals volume. ################################################################# """ R = _GetR(n=30) temp = [] VDW = [] # ChargeCoordinates=_ReadCoordinates('temp.arc') for i in ChargeCoordinates: #if i[0]!='H': temp.append([float(i[1]), float(i[2]), float(i[3])]) VDW.append(GetRelativeAtomicProperty(i[0], 'V')) DM = GetGementricalDistanceMatrix(temp) nAT = len(temp) RDFresult = {} for kkk, Ri in enumerate(R): res = 0.0 for j in range(nAT - 1): for k in range(j + 1, nAT): res = res + VDW[j] * VDW[k] * math.exp( -_beta * math.pow(Ri - DM[j, k], 2)) RDFresult['RDF' + 'V' + str(kkk + 1)] = round(res, 3) return RDFresult
def CalculateSandersonElectronegativityRDF(lcoordinates): """ The calculation of radial distribution function (RDF) descriptors based on atomic electronegativity. """ R = _GetR(n=30) temp = [] EN = [] # lcoordinates=_ReadCoordinates('temp.arc') for i in lcoordinates: #if i[0]!='H': temp.append([float(i[0]), float(i[1]), float(i[2])]) EN.append(GetRelativeAtomicProperty(i[3], 'En')) DM = GetGementricalDistanceMatrix(temp) nAT = len(temp) RDFresult = {} for kkk, Ri in enumerate(R): res = 0.0 for j in range(nAT - 1): for k in range(j + 1, nAT): res = res + EN[j] * EN[k] * math.exp( -_beta * math.pow(Ri - DM[j, k], 2)) RDFresult['RDF' + 'E' + str(kkk + 1)] = round(res, 3) return RDFresult
def GetPropertyMatrix(AtomLabel, proname='m'): """ ################################################################# ################################################################# """ res = [] for i in AtomLabel: res.append(GetRelativeAtomicProperty(i, proname)) return scipy.matrix(scipy.diag(res))
def _CalculateMoreauBrotoAutocorrelation(mol, lag=1, propertylabel="m"): """ ################################################################# **Internal used only** Calculation of Moreau-Broto autocorrelation descriptors based on different property weights. Usage: res=_CalculateMoreauBrotoAutocorrelation(mol, lag=1,propertylabel='m') Input: mol is a molecule object. lag is the topological distance between atom i and atom j. propertylabel is the weighted property. Output: res is a numeric value. ################################################################# """ Natom = mol.GetNumAtoms() GetDistanceMatrix = Chem.GetDistanceMatrix(mol) res = 0.0 for i in range(Natom): for j in range(Natom): if GetDistanceMatrix[i, j] == lag: atom1 = mol.GetAtomWithIdx(i) atom2 = mol.GetAtomWithIdx(j) temp1 = GetRelativeAtomicProperty(element=atom1.GetSymbol(), propertyname=propertylabel) temp2 = GetRelativeAtomicProperty(element=atom2.GetSymbol(), propertyname=propertylabel) res = res + temp1 * temp2 else: res = res + 0.0 return round(numpy.log(res / 2 + 1), 3)
def _GetBurdenMatrix(mol, propertylabel='m'): """ ################################################################# *Internal used only** Calculate Burden matrix and their eigenvalues. ################################################################# """ mol = Chem.AddHs(mol) Natom = mol.GetNumAtoms() AdMatrix = Chem.GetAdjacencyMatrix(mol) bondindex = numpy.argwhere(AdMatrix) AdMatrix1 = numpy.array(AdMatrix, dtype=numpy.float32) #The diagonal elements of B, Bii, are either given by #the carbon normalized atomic mass, #van der Waals volume, Sanderson electronegativity, #and polarizability of atom i. for i in range(Natom): atom = mol.GetAtomWithIdx(i) temp = GetRelativeAtomicProperty(element=atom.GetSymbol(), propertyname=propertylabel) AdMatrix1[i, i] = round(temp, 3) #The element of B connecting atoms i and j, Bij, #is equal to the square root of the bond #order between atoms i and j. for i in bondindex: bond = mol.GetBondBetweenAtoms(int(i[0]), int(i[1])) if bond.GetBondType().name == 'SINGLE': AdMatrix1[i[0], i[1]] = round(numpy.sqrt(1), 3) if bond.GetBondType().name == "DOUBLE": AdMatrix1[i[0], i[1]] = round(numpy.sqrt(2), 3) if bond.GetBondType().name == "TRIPLE": AdMatrix1[i[0], i[1]] = round(numpy.sqrt(3), 3) if bond.GetBondType().name == "AROMATIC": AdMatrix1[i[0], i[1]] = round(numpy.sqrt(1.5), 3) ##All other elements of B (corresponding non bonded #atom pairs) are set to 0.001 bondnonindex = numpy.argwhere(AdMatrix == 0) for i in bondnonindex: if i[0] != i[1]: AdMatrix1[i[0], i[1]] = 0.001 return numpy.real(numpy.linalg.eigvals(AdMatrix1))