示例#1
0
 def getPeaks(self, mapNum, pos, radius=RADIUS):
     """Get a list of peaks in the map near a given position
     
     ARGUMENTS:
         mapNum      - the molecule number of the Coot map to use
         pos         - the coordinates to search near
     OPTIONAL ARGUMENTS:
         radius      - how far from pos should we look for peaks?
                       defaults to RADIUS (defined at the top of this file)
     RETURNS:
         closePeaks  - a list of peaks in the format [x, y, z, density]
     """
     
     (x, y, z) = pos
     
     #determine if we've already done a peak search for this map
     if not mapNum in self.__peakList:
         
         peakList = []
         peakHash = dict()
         
         #go through all sigma levels and do a peak search
         curSigma = GET_PEAKS_STARTING_SIGMA
         while curSigma >= GET_PEAKS_ENDING_SIGMA:
             
             #do a peak search at the current sigma level
             curPeaks = map_peaks_py(mapNum, curSigma)
             
             #go through each peak we found and make sure we hadn't found it already
             for peak in curPeaks:
                 #check peakHash for this peak
                 try:
                     peakHash[peak[0]][peak[1]][peak[2]]
                 except KeyError:
                     #if it's not there, add it to peakList and peakHash
                     peakList.append(peak)
                     if not(peakHash.has_key(peak[0])):
                         peakHash[peak[0]] = dict()
                     if not(peakHash[peak[0]].has_key(peak[1])):
                         peakHash[peak[0]][peak[1]] = dict()
                     if not(peakHash[peak[0]][peak[1]].has_key(peak[2])):
                         peakHash[peak[0]][peak[1]][peak[2]] = True
             
             curSigma -= GET_PEAKS_SIGMA_STEP
         
         #once we've found all the peaks in this map, store them
         self.__peakList[mapNum] = peakList
     
     
     closePeaks = map_peaks_near_point_from_list_py(mapNum, self.__peakList[mapNum], x, y, z, radius)
     
     for curPeak in closePeaks:
         (x, y, z) = curPeak
         density = density_at_point(mapNum, x, y, z)
         curPeak.append(density)
     
     return closePeaks
示例#2
0
文件: nextPhos.py 项目: benmwebb/coot
 def getPeaks(self, mapNum, pos, radius=RADIUS):
     """Get a list of peaks in the map near a given position
     
     ARGUMENTS:
         mapNum      - the molecule number of the Coot map to use
         pos         - the coordinates to search near
     OPTIONAL ARGUMENTS:
         radius      - how far from pos should we look for peaks?
                       defaults to RADIUS (defined at the top of this file)
     RETURNS:
         closePeaks  - a list of peaks in the format [x, y, z, density]
     """
     
     (x, y, z) = pos
     
     #determine if we've already done a peak search for this map
     if not mapNum in self.__peakList:
         
         peakList = []
         peakHash = dict()
         
         #go through all sigma levels and do a peak search
         curSigma = GET_PEAKS_STARTING_SIGMA
         while curSigma >= GET_PEAKS_ENDING_SIGMA:
             
             #do a peak search at the current sigma level
             curPeaks = map_peaks_py(mapNum, curSigma)
             
             #go through each peak we found and make sure we hadn't found it already
             for peak in curPeaks:
                 #check peakHash for this peak
                 try:
                     peakHash[peak[0]][peak[1]][peak[2]]
                 except KeyError:
                     #if it's not there, add it to peakList and peakHash
                     peakList.append(peak)
                     if not(peakHash.has_key(peak[0])):
                         peakHash[peak[0]] = dict()
                     if not(peakHash[peak[0]].has_key(peak[1])):
                         peakHash[peak[0]][peak[1]] = dict()
                     if not(peakHash[peak[0]][peak[1]].has_key(peak[2])):
                         peakHash[peak[0]][peak[1]][peak[2]] = True
             
             curSigma -= GET_PEAKS_SIGMA_STEP
         
         #once we've found all the peaks in this map, store them
         self.__peakList[mapNum] = peakList
     
     
     closePeaks = map_peaks_near_point_from_list_py(mapNum, self.__peakList[mapNum], x, y, z, radius)
     
     for curPeak in closePeaks:
         (x, y, z) = curPeak
         density = density_at_point(mapNum, x, y, z)
         curPeak.append(density)
     
     return closePeaks
示例#3
0
 def findBase(self, mapNum, sugar, phos5, phos3, baseType, direction = 3):
     """Rotate the sugar center by 360 degrees in ROTATE_SUGAR_INTERVAL increments
     
     ARGUMENTS:
         mapNum   - the molecule number of the Coot map to use
         sugar    - the coordinates of the C1' atom
         phos5    - the coordinates of the 5' phosphate
         phos3    - the coordinates of the 3' phosphate
         baseType - the base type (A, C, G, or U)
     OPTIONAL ARGUMENTS:
         direction - which direction are we tracing the chain
                     if it is 5 (i.e. 3'->5'), then phos5 and phos3 will be flipped
                     all other values will be ignored
                     defaults to 3 (i.e. 5'->3')
     RETURNS:
         baseObj  - a list of [baseType, baseCoordinates]
     """
     
     if direction == 5:
         (phos5, phos3) = (phos3, phos5)
     
     #calculate the bisector of the phos-sugar-phos angle
     #first, calculate a normal to the phos-sugar-phos plane
     sugarPhos5Vec = minus(phos5, sugar)
     sugarPhos3Vec = minus(phos3, sugar)
     normal = crossProd(sugarPhos5Vec, sugarPhos3Vec)
     normal = scalarProd(normal, 1.0/magnitude(normal))
     
     phosSugarPhosAngle = angle(phos5, sugar, phos3)
     
     bisector = rotate(sugarPhos5Vec, normal, phosSugarPhosAngle/2.0)
     
     
     #flip the bisector around (so it points away from the phosphates) and scale its length to 5 A
     startingBasePos = scalarProd(bisector, -1/magnitude(bisector))
     
     #rotate the base baton by 10 degree increments about half of a sphere
     rotations = [startingBasePos] #a list of coordinates for all of the rotations
     for curTheta in range(-90, -1, 10) + range(10, 91, 10):
         curRotation = rotate(startingBasePos, normal, curTheta)
         rotations.append(curRotation) #here's where the phi=0 rotation is accounted for
         
         for curPhi in range(-90, -1, 10) + range(10, 91, 10):
             rotations.append(rotate(curRotation, startingBasePos, curPhi))
             
     #test electron density along all base batons
     for curBaton in rotations:
         curDensityTotal = 0
         densityList = []
         for i in range(1, 9):
             (x, y, z) = plus(sugar, scalarProd(i/2.0, curBaton))
             curPointDensity = density_at_point(mapNum, x, y, z)
             curDensityTotal += curPointDensity
             densityList.append(curPointDensity)
         curBaton.append(curDensityTotal)        #the sum of the density (equivalent to the mean for ordering purposes)
         curBaton.append(median(densityList))    #the median of the density
         curBaton.append(min(densityList))       #the minimum of the density
     
     #find the baton with the max density (as measured using the median)
     #Note that we ignore the sum and minimum of the density.  Those calculations could be commented out,
     #   but they may be useful at some point in the future.  When we look at higher resolutions maybe?
     #   Besides, they're fast calculations.)
     baseDir = max(rotations, key = lambda x: x[4])
     
     #rotate the stock base+sugar structure to align with the base baton
     rotationAngle = angle(self.__baseStrucs["C"]["C4"], [0,0,0], baseDir)
     axis = crossProd(self.__baseStrucs["C"]["C4"], baseDir[0:3])
     
     orientedBase = rotateAtoms(self.__baseStrucs["C"], axis, rotationAngle)
     
     #rotate the base about chi to find the best fit to density
     bestFitBase = None
     maxDensity = -999999
     for curAngle in range(0,360,5):
         rotatedBase = rotateAtoms(orientedBase, orientedBase["C4"], curAngle, sugar)
         curDensity = 0
         for curAtom in ["N1", "C2", "N3", "C4", "C5", "C6"]:
             curDensity += density_at_point(mapNum, rotatedBase[curAtom][0], rotatedBase[curAtom][1], rotatedBase[curAtom][2])
         
         #this is "pseudoChi" because it uses the 5' phosphate in place of the O4' atom
         pseudoChi = torsion(phos5, sugar, rotatedBase["N1"], rotatedBase["N3"])
         curDensity *= self.__pseudoChiInterp.interp(pseudoChi)
         
         if curDensity > maxDensity:
             maxDensity = curDensity
             bestFitBase = rotatedBase
     
     baseObj = ["C", bestFitBase]
     
     #mutate the base to the appropriate type
     if baseType != "C":
         baseObj = self.mutateBase(baseObj, baseType)
     
     return baseObj
示例#4
0
 def findSugar(self, mapNum, phos5, phos3):
     """find potential C1' locations between the given 5' and 3' phosphate coordinates
     
     ARGUMENTS:
         mapNum      - the molecule number of the Coot map to use
         phos5       - the coordinates of the 5' phosphate
         phos3       - the coordinates of the 3' phosphate
     RETURNS:
         sugarMaxima - a list of potential C1' locations, each listed as [x, y, z, score]
     """
     
     #calculate the distance between the two phosphatse
     phosPhosDist = dist(phos5, phos3)
     
     #calculate a potential spot for the sugar based on the phosphate-phosphate distance
     #projDist is how far along the 3'P-5'P vector the sugar center should be (measured from the 3'P)
     #perpDist is how far off from the 3'P-5'P vector the sugar center should be
     
     #these functions are for the sugar center, which is what we try to find here
     #since it will be more in the center of the density blob
     perpDist = -0.185842*phosPhosDist**2 + 1.62296*phosPhosDist - 0.124146
     projDist = 0.440092*phosPhosDist + 0.909732
     
     #if we wanted to find the C1' instead of the sugar center, we'd use these functions
     #however, finding the C1' directly causes our density scores to be less accurate
     #so we instead use the functions above to find the sugar center and later adjust our
     #coordinates to get the C1' location
     #perpDist = -0.124615*phosPhosDist**2 + 0.955624*phosPhosDist + 2.772573
     #projDist = 0.466938*phosPhosDist + 0.649833
     
     
     #calculate the normal to the plane defined by 3'P, 5'P, and a dummy point
     normal = crossProd([10,0,0], minus(phos3, phos5))
     
     #make sure the magnitude of the normal is not zero (or almost zero)
     #if it is zero, that means that our dummy point was co-linear with the 3'P-5'P vector
     #and we haven't calculated a normal
     #if the magnitude is almost zero, then the dummy point was almost co-linear and we have to worry about rounding error
     #in either of those cases, just use a different dummy point
     #they should both be incredibly rare cases, but it doesn't hurt to be safe
     if magnitude(normal) < 0.001:
         #print "Recalculating normal"
         normal = crossProd([0,10,0], minus(phos5, phos3))
     
     
     #scale the normal to the length of perpDist
     perpVector = scalarProd(normal, perpDist/magnitude(normal))
     
     #calculate the 3'P-5'P vector and scale it to the length of projDist
     projVector = minus(phos3, phos5)
     projVector = scalarProd(projVector, projDist/magnitude(projVector))
     
     #calculate a possible sugar location
     sugarLoc = plus(phos5, projVector)
     sugarLoc = plus(sugarLoc, perpVector)
     
     #rotate the potential sugar location around the 3'P-5'P vector to generate a list of potential sugar locations
     sugarRotationPoints = self.__rotateSugarCenter(phos5, phos3, sugarLoc)
     
     #test each potential sugar locations to find the one with the best electron density
     for curSugarLocFull in sugarRotationPoints:
         curSugarLoc = curSugarLocFull[0:3] #the rotation angle is stored as curSugarLocFull[4], so we trim that off for curSugarLoc
         curDensityTotal = 0
         #densityList = []   #if desired, this could be used to generate additional statistics on the density (such as the median or quartiles)
         
         #check density along the 5'P-sugar vector
         phosSugarVector = minus(curSugarLoc, phos5)
         phosSugarVector = scalarProd(phosSugarVector, 1.0/(DENSITY_CHECK_POINTS+1))
         for i in range(1, DENSITY_CHECK_POINTS+1):
             (x, y, z) = plus(phos5, scalarProd(i, phosSugarVector))
             curPointDensity = density_at_point(mapNum, x, y, z)
             curDensityTotal += curPointDensity
             #densityList.append(curPointDensity)
             
         
         #check at the sugar center
         (x, y, z) = curSugarLoc
         curPointDensity = density_at_point(mapNum, x, y, z)
         curDensityTotal += curPointDensity
         #densityList.append(curPointDensity)
         
         #check along the sugar-3'P vector
         sugarPhosVector = minus(phos3, curSugarLoc)
         sugarPhosVector = scalarProd(sugarPhosVector, 1.0/(DENSITY_CHECK_POINTS+1))
         for i in range(1, DENSITY_CHECK_POINTS+1):
             (x, y, z) = plus(curSugarLoc, scalarProd(i, sugarPhosVector))
             curPointDensity = density_at_point(mapNum, x, y, z)
             curDensityTotal += curPointDensity
             #densityList.append(curPointDensity)
         
         curSugarLocFull.append(curDensityTotal)
         #curSugarLocFull.extend([curDensityTotal, median(densityList), lowerQuartile(densityList), min(densityList)])#, pointList])
     
     #find all the local maxima
     sugarMaxima = []
     curPeakHeight = sugarRotationPoints[-1][4]
     nextPeakHeight = sugarRotationPoints[0][4]
     sugarRotationPoints.append(sugarRotationPoints[0]) #copy the first point to the end so that we can properly check the last point
     for i in range(0, len(sugarRotationPoints)-1):
         prevPeakHeight = curPeakHeight
         curPeakHeight  = nextPeakHeight
         nextPeakHeight = sugarRotationPoints[i+1][4]
         if prevPeakHeight < curPeakHeight and curPeakHeight >=  nextPeakHeight:
             sugarMaxima.append(sugarRotationPoints[i])
     
     #sort the local maxima by their density score
     sugarMaxima.sort(key = lambda x: x[4], reverse = True)
     
     #adjust all the sugar center coordinates so that they represent the corresponding C1' coordinates
     for i in range(0, len(sugarMaxima)):
         curSugar = sugarMaxima[i][0:3]
         #rotate a vector 148 degrees from the phosphate bisector
         phosAngle = angle(phos5, curSugar, phos3)
         phos5vector = minus(phos5, curSugar)
         axis = crossProd(minus(phos3, curSugar), phos5vector)
         axis = scalarProd(axis, 1/magnitude(axis))
         c1vec = rotate(phos5vector, axis, 148.539123-phosAngle/2)
         
         #scale the vector to the appropriate length
         c1vec = scalarProd(c1vec, 1.235367/magnitude(c1vec))
         
         #rotate the vector about the phosphate bisector
         phosBisectorAxis = rotate(phos5vector, axis, -phosAngle/2)
         phosBisectorAxis = scalarProd(phosBisectorAxis, 1/magnitude(phosBisectorAxis)) 
         c1vec = rotate(c1vec, phosBisectorAxis, -71.409162)
         
         sugarMaxima[i][0:3] = plus(c1vec, curSugar)
     
     return sugarMaxima
示例#5
0
文件: nextPhos.py 项目: benmwebb/coot
 def findBase(self, mapNum, sugar, phos5, phos3, baseType, direction = 3):
     """Rotate the sugar center by 360 degrees in ROTATE_SUGAR_INTERVAL increments
     
     ARGUMENTS:
         mapNum   - the molecule number of the Coot map to use
         sugar    - the coordinates of the C1' atom
         phos5    - the coordinates of the 5' phosphate
         phos3    - the coordinates of the 3' phosphate
         baseType - the base type (A, C, G, or U)
     OPTIONAL ARGUMENTS:
         direction - which direction are we tracing the chain
                     if it is 5 (i.e. 3'->5'), then phos5 and phos3 will be flipped
                     all other values will be ignored
                     defaults to 3 (i.e. 5'->3')
     RETURNS:
         baseObj  - a list of [baseType, baseCoordinates]
     """
     
     if direction == 5:
         (phos5, phos3) = (phos3, phos5)
     
     #calculate the bisector of the phos-sugar-phos angle
     #first, calculate a normal to the phos-sugar-phos plane
     sugarPhos5Vec = minus(phos5, sugar)
     sugarPhos3Vec = minus(phos3, sugar)
     normal = crossProd(sugarPhos5Vec, sugarPhos3Vec)
     normal = scalarProd(normal, 1.0/magnitude(normal))
     
     phosSugarPhosAngle = angle(phos5, sugar, phos3)
     
     bisector = rotate(sugarPhos5Vec, normal, phosSugarPhosAngle/2.0)
     
     
     #flip the bisector around (so it points away from the phosphates) and scale its length to 5 A
     startingBasePos = scalarProd(bisector, -1/magnitude(bisector))
     
     #rotate the base baton by 10 degree increments about half of a sphere
     rotations = [startingBasePos] #a list of coordinates for all of the rotations
     for curTheta in range(-90, -1, 10) + range(10, 91, 10):
         curRotation = rotate(startingBasePos, normal, curTheta)
         rotations.append(curRotation) #here's where the phi=0 rotation is accounted for
         
         for curPhi in range(-90, -1, 10) + range(10, 91, 10):
             rotations.append(rotate(curRotation, startingBasePos, curPhi))
             
     #test electron density along all base batons
     for curBaton in rotations:
         curDensityTotal = 0
         densityList = []
         for i in range(1, 9):
             (x, y, z) = plus(sugar, scalarProd(i/2.0, curBaton))
             curPointDensity = density_at_point(mapNum, x, y, z)
             curDensityTotal += curPointDensity
             densityList.append(curPointDensity)
         curBaton.append(curDensityTotal)        #the sum of the density (equivalent to the mean for ordering purposes)
         curBaton.append(median(densityList))    #the median of the density
         curBaton.append(min(densityList))       #the minimum of the density
     
     #find the baton with the max density (as measured using the median)
     #Note that we ignore the sum and minimum of the density.  Those calculations could be commented out,
     #   but they may be useful at some point in the future.  When we look at higher resolutions maybe?
     #   Besides, they're fast calculations.)
     baseDir = max(rotations, key = lambda x: x[4])
     
     #rotate the stock base+sugar structure to align with the base baton
     rotationAngle = angle(self.__baseStrucs["C"]["C4"], [0,0,0], baseDir)
     axis = crossProd(self.__baseStrucs["C"]["C4"], baseDir[0:3])
     
     orientedBase = rotateAtoms(self.__baseStrucs["C"], axis, rotationAngle)
     
     #rotate the base about chi to find the best fit to density
     bestFitBase = None
     maxDensity = -999999
     for curAngle in range(0,360,5):
         rotatedBase = rotateAtoms(orientedBase, orientedBase["C4"], curAngle, sugar)
         curDensity = 0
         for curAtom in ["N1", "C2", "N3", "C4", "C5", "C6"]:
             curDensity += density_at_point(mapNum, rotatedBase[curAtom][0], rotatedBase[curAtom][1], rotatedBase[curAtom][2])
         
         #this is "pseudoChi" because it uses the 5' phosphate in place of the O4' atom
         pseudoChi = torsion(phos5, sugar, rotatedBase["N1"], rotatedBase["N3"])
         curDensity *= self.__pseudoChiInterp.interp(pseudoChi)
         
         if curDensity > maxDensity:
             maxDensity = curDensity
             bestFitBase = rotatedBase
     
     baseObj = ["C", bestFitBase]
     
     #mutate the base to the appropriate type
     if baseType != "C":
         baseObj = self.mutateBase(baseObj, baseType)
     
     return baseObj
示例#6
0
文件: nextPhos.py 项目: benmwebb/coot
 def findSugar(self, mapNum, phos5, phos3):
     """find potential C1' locations between the given 5' and 3' phosphate coordinates
     
     ARGUMENTS:
         mapNum      - the molecule number of the Coot map to use
         phos5       - the coordinates of the 5' phosphate
         phos3       - the coordinates of the 3' phosphate
     RETURNS:
         sugarMaxima - a list of potential C1' locations, each listed as [x, y, z, score]
     """
     
     #calculate the distance between the two phosphatse
     phosPhosDist = dist(phos5, phos3)
     
     #calculate a potential spot for the sugar based on the phosphate-phosphate distance
     #projDist is how far along the 3'P-5'P vector the sugar center should be (measured from the 3'P)
     #perpDist is how far off from the 3'P-5'P vector the sugar center should be
     
     #these functions are for the sugar center, which is what we try to find here
     #since it will be more in the center of the density blob
     perpDist = -0.185842*phosPhosDist**2 + 1.62296*phosPhosDist - 0.124146
     projDist = 0.440092*phosPhosDist + 0.909732
     
     #if we wanted to find the C1' instead of the sugar center, we'd use these functions
     #however, finding the C1' directly causes our density scores to be less accurate
     #so we instead use the functions above to find the sugar center and later adjust our
     #coordinates to get the C1' location
     #perpDist = -0.124615*phosPhosDist**2 + 0.955624*phosPhosDist + 2.772573
     #projDist = 0.466938*phosPhosDist + 0.649833
     
     
     #calculate the normal to the plane defined by 3'P, 5'P, and a dummy point
     normal = crossProd([10,0,0], minus(phos3, phos5))
     
     #make sure the magnitude of the normal is not zero (or almost zero)
     #if it is zero, that means that our dummy point was co-linear with the 3'P-5'P vector
     #and we haven't calculated a normal
     #if the magnitude is almost zero, then the dummy point was almost co-linear and we have to worry about rounding error
     #in either of those cases, just use a different dummy point
     #they should both be incredibly rare cases, but it doesn't hurt to be safe
     if magnitude(normal) < 0.001:
         #print "Recalculating normal"
         normal = crossProd([0,10,0], minus(phos5, phos3))
     
     
     #scale the normal to the length of perpDist
     perpVector = scalarProd(normal, perpDist/magnitude(normal))
     
     #calculate the 3'P-5'P vector and scale it to the length of projDist
     projVector = minus(phos3, phos5)
     projVector = scalarProd(projVector, projDist/magnitude(projVector))
     
     #calculate a possible sugar location
     sugarLoc = plus(phos5, projVector)
     sugarLoc = plus(sugarLoc, perpVector)
     
     #rotate the potential sugar location around the 3'P-5'P vector to generate a list of potential sugar locations
     sugarRotationPoints = self.__rotateSugarCenter(phos5, phos3, sugarLoc)
     
     #test each potential sugar locations to find the one with the best electron density
     for curSugarLocFull in sugarRotationPoints:
         curSugarLoc = curSugarLocFull[0:3] #the rotation angle is stored as curSugarLocFull[4], so we trim that off for curSugarLoc
         curDensityTotal = 0
         #densityList = []   #if desired, this could be used to generate additional statistics on the density (such as the median or quartiles)
         
         #check density along the 5'P-sugar vector
         phosSugarVector = minus(curSugarLoc, phos5)
         phosSugarVector = scalarProd(phosSugarVector, 1.0/(DENSITY_CHECK_POINTS+1))
         for i in range(1, DENSITY_CHECK_POINTS+1):
             (x, y, z) = plus(phos5, scalarProd(i, phosSugarVector))
             curPointDensity = density_at_point(mapNum, x, y, z)
             curDensityTotal += curPointDensity
             #densityList.append(curPointDensity)
             
         
         #check at the sugar center
         (x, y, z) = curSugarLoc
         curPointDensity = density_at_point(mapNum, x, y, z)
         curDensityTotal += curPointDensity
         #densityList.append(curPointDensity)
         
         #check along the sugar-3'P vector
         sugarPhosVector = minus(phos3, curSugarLoc)
         sugarPhosVector = scalarProd(sugarPhosVector, 1.0/(DENSITY_CHECK_POINTS+1))
         for i in range(1, DENSITY_CHECK_POINTS+1):
             (x, y, z) = plus(curSugarLoc, scalarProd(i, sugarPhosVector))
             curPointDensity = density_at_point(mapNum, x, y, z)
             curDensityTotal += curPointDensity
             #densityList.append(curPointDensity)
         
         curSugarLocFull.append(curDensityTotal)
         #curSugarLocFull.extend([curDensityTotal, median(densityList), lowerQuartile(densityList), min(densityList)])#, pointList])
     
     #find all the local maxima
     sugarMaxima = []
     curPeakHeight = sugarRotationPoints[-1][4]
     nextPeakHeight = sugarRotationPoints[0][4]
     sugarRotationPoints.append(sugarRotationPoints[0]) #copy the first point to the end so that we can properly check the last point
     for i in range(0, len(sugarRotationPoints)-1):
         prevPeakHeight = curPeakHeight
         curPeakHeight  = nextPeakHeight
         nextPeakHeight = sugarRotationPoints[i+1][4]
         if prevPeakHeight < curPeakHeight and curPeakHeight >=  nextPeakHeight:
             sugarMaxima.append(sugarRotationPoints[i])
     
     #sort the local maxima by their density score
     sugarMaxima.sort(key = lambda x: x[4], reverse = True)
     
     #adjust all the sugar center coordinates so that they represent the corresponding C1' coordinates
     for i in range(0, len(sugarMaxima)):
         curSugar = sugarMaxima[i][0:3]
         #rotate a vector 148 degrees from the phosphate bisector
         phosAngle = angle(phos5, curSugar, phos3)
         phos5vector = minus(phos5, curSugar)
         axis = crossProd(minus(phos3, curSugar), phos5vector)
         axis = scalarProd(axis, 1/magnitude(axis))
         c1vec = rotate(phos5vector, axis, 148.539123-phosAngle/2)
         
         #scale the vector to the appropriate length
         c1vec = scalarProd(c1vec, 1.235367/magnitude(c1vec))
         
         #rotate the vector about the phosphate bisector
         phosBisectorAxis = rotate(phos5vector, axis, -phosAngle/2)
         phosBisectorAxis = scalarProd(phosBisectorAxis, 1/magnitude(phosBisectorAxis)) 
         c1vec = rotate(c1vec, phosBisectorAxis, -71.409162)
         
         sugarMaxima[i][0:3] = plus(c1vec, curSugar)
     
     return sugarMaxima