def __exposedResidues( self, ASA_values, sidechainCut=0.0, backboneCut=0.0, totalCut=0.0 ): """ Decide what is a surface exposed residue and what is not. sidechainCut, backboneCut, totalCut - float, cutoff value for what will be considered as a exposed residue. All three values have to pass the test. @param ASA_values: array with ASA values for side chains, backbone and total calculated in L{__read_residueASA}. @type ASA_values: array @param sidechainCut: cutoff ASA value for considering the side chain to consider thew residue being exposed (default: 0.0) @type sidechainCut: float @param backboneCut: cutoffvalue for back bone ASA @type backboneCut: float @param totalCut: cutoff for total ASA @type totalCut: float @return: residue mask, where 0 = burried @rtype: [1|0] """ col_0 = N.greater( N.transpose(ASA_values)[0], totalCut ) col_1 = N.greater( N.transpose(ASA_values)[1], backboneCut ) col_2 = N.greater( N.transpose(ASA_values)[2], sidechainCut ) col_012 = N.concatenate( ([col_0],[col_1],[col_2]) ) exposedList = N.greater(N.sum(col_012), 0) return exposedList
def mergeProfiles( self, p0, p1, maxOverlap=3 ): """ Merge profile p0 with profile p1, as long as they overlap in at most maxOverlap positions @param p0: profile @type p0: [float] @param p1: profile @type p1: [float] @param maxOverlap: maximal allowed overlap between profiles @type maxOverlap: int @return: array @rtype: """ p0 = self.__list2array( p0 ) p1 = self.__list2array( p1 ) overlap = N.greater( N.greater(p0,0) + N.greater(p1,0), 1 ) if N.sum( overlap ) <= maxOverlap: ## one of the two profiles will in most cases not belong to these ## positions. We can't decide which one is wrong, let's eliminate ## both values. Alternatively we could keep one, or the average, .. N.put( p1, N.nonzero( overlap ), 0 ) N.put( p0, N.nonzero( overlap ), 0 ) p0 = p0 + p1 return p0
def __exposedResidues(self, ASA_values, sidechainCut=0.0, backboneCut=0.0, totalCut=0.0): """ Decide what is a surface exposed residue and what is not. sidechainCut, backboneCut, totalCut - float, cutoff value for what will be considered as a exposed residue. All three values have to pass the test. @param ASA_values: array with ASA values for side chains, backbone and total calculated in L{__read_residueASA}. @type ASA_values: array @param sidechainCut: cutoff ASA value for considering the side chain to consider thew residue being exposed (default: 0.0) @type sidechainCut: float @param backboneCut: cutoffvalue for back bone ASA @type backboneCut: float @param totalCut: cutoff for total ASA @type totalCut: float @return: residue mask, where 0 = burried @rtype: [1|0] """ col_0 = N.greater(N.transpose(ASA_values)[0], totalCut) col_1 = N.greater(N.transpose(ASA_values)[1], backboneCut) col_2 = N.greater(N.transpose(ASA_values)[2], sidechainCut) col_012 = N.concatenate(([col_0], [col_1], [col_2])) exposedList = N.greater(N.sum(col_012), 0) return exposedList
def display(self): GL.glClearColor( 0.0, 0.0, 0.0, 0.0) GL.glClear( GL.GL_COLOR_BUFFER_BIT) GL.glColor3f( 1.0,1.0,0.0) self.x = self.x + self.move_x self.y = self.y + self.move_y self.age = self.age + 1 which = Numeric.greater( self.age, MAX_AGE) self.x = Numeric.choose( which, (self.x, RandomArray.random( NUMDOTS))) selfy = Numeric.choose( which, (self.y, RandomArray.random( NUMDOTS))) self.age = Numeric.choose( which, (self.age, 0)) self.x = Numeric.choose( Numeric.greater( self.x, 1.0), (self.x, self.x - 1.0)) self.y = Numeric.choose( Numeric.greater( self.y, 1.0), (self.y, self.y - 1.0)) x2 = RandomArray.random( NUMDOTS2) y2 = RandomArray.random( NUMDOTS2) v = Numeric.concatenate( (Numeric.transpose( Numeric.array( [self.x, self.y])), Numeric.transpose( Numeric.array( [self.x - 0.005, self.y + 0.005])), Numeric.transpose( Numeric.array( [self.x + 0.005, self.y - 0.005])), Numeric.transpose( Numeric.array( [x2, y2])))) #from opengltk.util import GLdouble #av = bufarray.readArray( v, GLdouble) #GL.glVertexPointer( 2, av) GL.glVertexPointer( 2, v) GL.glEnableClientState( GL.GL_VERTEX_ARRAY) #glplus.DrawArrays( GL.POINTS, len( av)) from opengltk import glplus glplus.DrawArrays( GL.GL_POINTS, len( v)) #GL.glDisableClientState( GL.VERTEX_ARRAY) GL.glFlush() GLUT.glutSwapBuffers()
def mergeProfiles(self, p0, p1, maxOverlap=3): """ Merge profile p0 with profile p1, as long as they overlap in at most maxOverlap positions @param p0: profile @type p0: [float] @param p1: profile @type p1: [float] @param maxOverlap: maximal allowed overlap between profiles @type maxOverlap: int @return: array @rtype: """ p0 = self.__list2array(p0) p1 = self.__list2array(p1) overlap = N.greater(N.greater(p0, 0) + N.greater(p1, 0), 1) if N.sum(overlap) <= maxOverlap: ## one of the two profiles will in most cases not belong to these ## positions. We can't decide which one is wrong, let's eliminate ## both values. Alternatively we could keep one, or the average, .. N.put(p1, N.nonzero(overlap), 0) N.put(p0, N.nonzero(overlap), 0) p0 = p0 + p1 return p0
def kNNimputeMA(arr2d, K=20, callback=None): """Returns a new 2D MA.array with missing values imputed from K nearest neighbours. Find K rows (axis 0) with the most similar values where similarity measure corresponds to weighted Euclidean distance. Imputed value = weighted average of the corresponding values of K nearest neighbours, where weights equal to tricubic distribution of distances to all rows. Impute missing rows by average over all rows. Version: 30.8.2005 """ arr2d = MA.asarray(arr2d) assert len(arr2d.shape) == 2, "2D array expected" # make a copy for imputation aImp2 = MA.array(arr2d) # leave out columns with 0 known values (columnInd: non-zero columns) columnCond = Numeric.greater(MA.count(arr2d, axis=0), 0) columnIndAll = Numeric.arange(arr2d.shape[1]) columnInd = Numeric.compress(columnCond, columnIndAll) # impute the rows where 0 < #known_values < #non_zero_columns, i.e. exclude the rows with 0 and all (non-zero-column) values countByRows = MA.count(arr2d, axis=1) for rowIdx in Numeric.compress(Numeric.logical_and(Numeric.greater(countByRows, 0), Numeric.less(countByRows, columnInd.shape[0])), Numeric.arange(arr2d.shape[0])): rowResized = MA.resize(arr2d[rowIdx], arr2d.shape) diff = arr2d - rowResized distances = MA.sqrt(MA.add.reduce((diff)**2, 1) / MA.count(diff, axis=1)) # nearest neighbours row indices (without the current row index) indSorted = MA.argsort(distances)[1:] distSorted = distances.take(indSorted) # number of distances different from MA.masked numNonMasked = distSorted.shape[0] - Numeric.add.reduce(Numeric.asarray(MA.getmaskarray(distSorted), Numeric.Int)) # number of distances to account for (K or less) if numNonMasked > 1: weightsSorted = MA.power(1-MA.power(distSorted/distSorted[numNonMasked-1],3),3) # tricubic distribution of all weights else: weightsSorted = Numeric.ones(distSorted.shape[0]) # compute average for each column separately in order to account for K non-masked values colInd4CurrRow = Numeric.compress(Numeric.logical_and(MA.getmaskarray(arr2d[rowIdx]), columnCond), columnIndAll) for colIdx in colInd4CurrRow: # column values sorted by distances columnVals = arr2d[:,colIdx].take(indSorted) # take only those weights where columnVals does not equal MA.masked weightsSortedCompressed = MA.compress(1-MA.getmaskarray(columnVals), weightsSorted) # impute from K (or possibly less) values aImp2[rowIdx,colIdx] = MA.average(columnVals.compressed()[:K], weights=weightsSortedCompressed[:K]) if callback: callback() # impute the unknown rows with average profile avrgRow = MA.average(arr2d, 0) for rowIdx in Numeric.compress(Numeric.equal(countByRows, 0), Numeric.arange(arr2d.shape[0])): aImp2[rowIdx] = avrgRow if callback: callback() return aImp2
def _arrayToImage(self, inArray): """ Generate a 1-channel PIL Image from an array of values from 0 to 1.0. Values larger than 1.0 are clipped, after adding them to the total clipped_pixels. Returns a one-channel (monochrome) Image. """ # PIL 'L' Images use a range of 0 to 255, so we scale the # input array to match. The pixels are scaled by 255, not # 256, so that 1.0 maps to fully white. max_pixel_value=255 inArray = (Numeric.floor(inArray * max_pixel_value)).astype(Numeric.Int) # Clip any values that are still larger than max_pixel_value to_clip = (Numeric.greater(inArray.ravel(),max_pixel_value)).sum() if (to_clip>0): # CEBALERT: no explanation of why clipped pixel count is # being accumulated. self.clipped_pixels = self.clipped_pixels + to_clip inArray.clip(0,max_pixel_value,out=inArray) self.verbose("Bitmap: clipped",to_clip,"image pixels that were out of range") r,c = inArray.shape # The size is (width,height), so we swap r and c: newImage = Image.new('L',(c,r),None) newImage.putdata(inArray.ravel()) return newImage
def __checkProfileIntegrity( self, profile, upperLimit=1.0, lowerLimit=-1.0): """ In some cases SurfaceRacer generates incorrect curvature values for some atoms. This function sets values outside a given range to 0 @param profile: profile name @type profile: str @param upperLimit: upper limit for a valid value (default: 1.0) @type upperLimit: float @param lowerLimit: lower limit for a valid value (default: -1.0) @type lowerLimit: float @return: profile with inspected values @rtype: [float] """ mask = N.greater( profile, upperLimit ) mask += N.less( profile, lowerLimit ) for i in N.nonzero(mask): print 'WARNING! Profile value %.2f set to O\n'%profile[i] profile[i] = 0 return profile
def __checkProfileIntegrity(self, profile, upperLimit=1.0, lowerLimit=-1.0): """ In some cases SurfaceRacer generates incorrect curvature values for some atoms. This function sets values outside a given range to 0 @param profile: profile name @type profile: str @param upperLimit: upper limit for a valid value (default: 1.0) @type upperLimit: float @param lowerLimit: lower limit for a valid value (default: -1.0) @type lowerLimit: float @return: profile with inspected values @rtype: [float] """ mask = N.greater(profile, upperLimit) mask += N.less(profile, lowerLimit) for i in N.nonzero(mask): print 'WARNING! Profile value %.2f set to O\n' % profile[i] profile[i] = 0 return profile
def stable_sd(x, n_sd=3., min_length=20): if len(x) < min_length: if len(x) == 1: return 0. else: return standardDeviation(x) x = Numeric.array(x) _x = x _outliers = 0. i = 0 while i < 10: mu = median(_x) sd = standardDeviation(_x, mu) outliers = Numeric.greater(abs(x-mu), n_sd*sd) if not Numeric.sum(outliers) or Numeric.sum(outliers==_outliers) == len(x): break _x = Numeric.compress(Numeric.logical_not(outliers), x) _outliers = outliers i += 1 return sd
def _arrayToImage(self, inArray): """ Generate a 1-channel PIL Image from an array of values from 0 to 1.0. Values larger than 1.0 are clipped, after adding them to the total clipped_pixels. Returns a one-channel (monochrome) Image. """ # PIL 'L' Images use a range of 0 to 255, so we scale the # input array to match. The pixels are scaled by 255, not # 256, so that 1.0 maps to fully white. max_pixel_value = 255 inArray = (Numeric.floor(inArray * max_pixel_value)).astype( Numeric.Int) # Clip any values that are still larger than max_pixel_value to_clip = (Numeric.greater(inArray.ravel(), max_pixel_value)).sum() if (to_clip > 0): # CEBALERT: no explanation of why clipped pixel count is # being accumulated. self.clipped_pixels = self.clipped_pixels + to_clip inArray.clip(0, max_pixel_value, out=inArray) self.verbose("Bitmap: clipped", to_clip, "image pixels that were out of range") r, c = inArray.shape # The size is (width,height), so we swap r and c: newImage = Image.new('L', (c, r), None) newImage.putdata(inArray.ravel()) return newImage
def __call__(self,**params_to_override): p = ParamOverrides(self,params_to_override) xsize,ysize = SheetCoordinateSystem(p.bounds,p.xdensity,p.ydensity).shape xsize,ysize = int(round(xsize)),int(round(ysize)) xdisparity = int(round(xsize*p.xdisparity)) ydisparity = int(round(xsize*p.ydisparity)) dotsize = int(round(xsize*p.dotsize)) bigxsize = 2*xsize bigysize = 2*ysize ndots=int(round(p.dotdensity * (bigxsize+2*dotsize) * (bigysize+2*dotsize) / min(dotsize,xsize) / min(dotsize,ysize))) halfdot = floor(dotsize/2) # Choose random colors and locations of square dots random_seed = p.random_seed random_array.seed(random_seed*12,random_seed*99) col=where(random_array.random((ndots))>=0.5, 1.0, -1.0) random_array.seed(random_seed*122,random_seed*799) xpos=floor(random_array.random((ndots))*(bigxsize+2*dotsize)) - halfdot random_array.seed(random_seed*1243,random_seed*9349) ypos=floor(random_array.random((ndots))*(bigysize+2*dotsize)) - halfdot # Construct arrays of points specifying the boundaries of each # dot, cropping them by the big image size (0,0) to (bigxsize,bigysize) x1=xpos.astype(Int) ; x1=choose(less(x1,0),(x1,0)) y1=ypos.astype(Int) ; y1=choose(less(y1,0),(y1,0)) x2=(xpos+(dotsize-1)).astype(Int) ; x2=choose(greater(x2,bigxsize),(x2,bigxsize)) y2=(ypos+(dotsize-1)).astype(Int) ; y2=choose(greater(y2,bigysize),(y2,bigysize)) # Draw each dot in the big image, on a blank background bigimage = zeros((bigysize,bigxsize)) for i in range(ndots): bigimage[y1[i]:y2[i]+1,x1[i]:x2[i]+1] = col[i] result = p.offset + p.scale*bigimage[ (ysize/2)+ydisparity:(3*ysize/2)+ydisparity , (xsize/2)+xdisparity:(3*xsize/2)+xdisparity ] for of in p.output_fns: of(result) return result
def map_angles(angles, period=None): """ maps angles into interval [-pi,pi] """ from numpy.oldnumeric import fmod, greater, logical_not if period is None: from numpy.oldnumeric import pi as period mask = greater(angles, 0.) return mask * (fmod(angles+period, 2*period)-period) + \ logical_not(mask) * (fmod(angles-period, 2*period)+period)
def map_angles(angles, period=None): """ maps angles into interval [-pi,pi] """ from numpy.oldnumeric import fmod, greater, logical_not if period is None: from numpy.oldnumeric import pi as period mask = greater(angles, 0.) return mask * (fmod(angles + period, 2 * period) - period) + \ logical_not(mask) * (fmod(angles - period, 2 * period) + period)
def draw(self): # XXX This method is not speed-optimized. I just wrote it to # get the job done. (Nonetheless, it seems faster than the C # version commented out above.) p = self.parameters # shorthand now_sec = VisionEgg.time_func() if self.start_times_sec is not None: # compute extinct dots and generate new positions replace_indices = Numeric.nonzero( Numeric.greater( now_sec - self.start_times_sec, p.dot_lifespan_sec) ) Numeric.put( self.start_times_sec, replace_indices, now_sec ) new_centers = np.random.standard_normal((3,len(replace_indices))) for i in range(3): Numeric.put( self.centers[i,:], replace_indices, new_centers[i,:] ) else: # initialize dot extinction values to random (uniform) distribution self.start_times_sec = RandomArray.uniform( now_sec - p.dot_lifespan_sec, now_sec, (self.constant_parameters.num_dots,)) time_delta_sec = now_sec - self.last_time_sec self.last_time_sec = now_sec # reset for next loop self.centers = self.centers + np.array(p.signal_vec)[:,np.newaxis]*time_delta_sec xyz = self.centers*p.start_position_variance + np.array(p.start_position_mean)[:,np.newaxis] xs = xyz[0,:] ys = xyz[1,:] zs = xyz[2,:] if p.on: gl.glEnable( gl.GL_POINT_SMOOTH ) # allow max_alpha value to control blending gl.glEnable( gl.GL_BLEND ) gl.glBlendFunc( gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA ) gl.glPointSize(p.dot_size) # Clear the modeview matrix gl.glMatrixMode(gl.GL_MODELVIEW) gl.glPushMatrix() gl.glDisable(gl.GL_TEXTURE_2D) draw_dots(xs,ys,zs,self.colors) gl.glDisable( gl.GL_POINT_SMOOTH ) # turn off gl.glPopMatrix()
def __categorizeHexSurf(self, cutoff=0.1): """ Compare complexes of list to native complex to see if their contact surfaces overlapp with the native complex. @param cutoff: fraction cutoff for defining a overlap (default: 0.1) @type cutoff: float @return: list of len(self.hexContacts) overlapping with native contact surface of lig and rec (0 - no overlap, 1 - rec OR lig overlapps, 2- rec AND lig overlapps) @rtype: [0|1|2] """ result = [ self.com.fractionNativeSurface( c, self.contacts ) for c in self.hexContacts ] result = [ N.sum( N.greater( o, cutoff ) ) for o in result ] return result
def __find_intervals(self, l): l = N.array(l) l = N.take(l, N.argsort(l)) globals().update( locals() ) break_points = N.nonzero(N.greater(l[1:] - l[:-1], 1)) start = 0 intervals = [] for i in range(len(break_points)): index = break_points[i] intervals.append(tuple(N.take(l, range(start, index + 1)))) start = index + 1 intervals.append(tuple(l[start:])) return intervals
def __find_intervals(self, l): l = N.array(l) l = N.take(l, N.argsort(l)) globals().update(locals()) break_points = N.nonzero(N.greater(l[1:] - l[:-1], 1)) start = 0 intervals = [] for i in range(len(break_points)): index = break_points[i] intervals.append(tuple(N.take(l, range(start, index + 1)))) start = index + 1 intervals.append(tuple(l[start:])) return intervals
def __categorizeHexSurf(self, cutoff=0.1): """ Compare complexes of list to native complex to see if their contact surfaces overlapp with the native complex. @param cutoff: fraction cutoff for defining a overlap (default: 0.1) @type cutoff: float @return: list of len(self.hexContacts) overlapping with native contact surface of lig and rec (0 - no overlap, 1 - rec OR lig overlapps, 2- rec AND lig overlapps) @rtype: [0|1|2] """ result = [ self.com.fractionNativeSurface(c, self.contacts) for c in self.hexContacts ] result = [N.sum(N.greater(o, cutoff)) for o in result] return result
def memberFrames(self, threshold=0.): """ Get indices of all frames belonging to each cluster. Each frame is guaranteed to belong, at least, to the cluster for which it has its maximum membership. If threshold > 0, it can additionally pop up in other clusters. @param threshold: minimal cluster membership or 0 to consider only max membership (default: 0) @type threshold: float @return: n_cluster, lst of lst of int, frame indices @rtype: [[int]] """ ## best cluster for each frame msm = self.memberships() maxMemb = N.argmax(msm, 0) r = [N.nonzero(N.equal(maxMemb, i)) for i in range(0, self.n_clusters)] r = [x.tolist() for x in r] ## same thing but now taking all above threshold ## -> same frame can end up in several clusters if threshold > 0.: r2 = [N.nonzero(N.greater(l, threshold)) for l in msm] ## add only additional frames for i in range(0, len(r)): try: frames = r[i].tolist() except: frames = r[i] r[i] = frames + [fr for fr in r2[i] if fr not in r[i]] ## sort frames within each cluster by their membership r = [self.membershipSort(r[i], i) for i in range(0, len(r))] return r
def flag_entries(_data, stats, bounds, z_max, atom_type='H',molType='protein'): l = [] for entry, val in _data.items(): classes = decompose_classes(val, bounds,molType=molType) for key, shifts in classes.items(): if not key in stats: print 'no stats', key continue mean, sd = stats[key][:2] Z = z_scores(shifts, mean, sd) if Numeric.sum(Numeric.greater(abs(Z), z_max)): l.append((entry, key)) return l
def memberFrames( self, threshold=0. ): """ Get indices of all frames belonging to each cluster. Each frame is guaranteed to belong, at least, to the cluster for which it has its maximum membership. If threshold > 0, it can additionally pop up in other clusters. @param threshold: minimal cluster membership or 0 to consider only max membership (default: 0) @type threshold: float @return: n_cluster, lst of lst of int, frame indices @rtype: [[int]] """ ## best cluster for each frame msm = self.memberships() maxMemb = N.argmax( msm, 0 ) r = [N.nonzero( N.equal(maxMemb, i) ) for i in range(0, self.n_clusters)] r = [ x.tolist() for x in r ] ## same thing but now taking all above threshold ## -> same frame can end up in several clusters if threshold > 0.: r2 = [ N.nonzero( N.greater( l, threshold) ) for l in msm ] ## add only additional frames for i in range(0, len( r ) ): try: frames = r[i].tolist() except: frames = r[i] r[i] = frames + [ fr for fr in r2[i] if fr not in r[i] ] ## sort frames within each cluster by their membership r = [ self.membershipSort( r[i], i) for i in range(0, len(r) )] return r
def rgrd(self, dataIn, missingValueIn, missingMatch, logYes = 'yes', positionIn = None, missingValueOut = None): """ #--------------------------------------------------------------------------------- # # PURPOSE: To perform all the tasks required to regrid the input data, dataIn, into the ouput data, # dataout along the level dimension only. # # DEFINITION: # # def rgrd(self, dataIn, missingValueIn, missingMatch, positionIn = None, missingValueOut = None): # # # PASSED : dataIn -- data to regrid # # missingValueIn -- the missing data value to use in setting missing in the mask. It is required # and there are two choices: # None -- there is no missing data # A number -- the value to use in the search for possible missing data. # The presence of missing data at a grid point leads to recording 0.0 in the mask. # # missingMatch -- the comparison scheme used in searching for missing data in dataIn using the value passed # in as missingValueIn. The choices are: # None -- used if None is the entry for missingValueIn # exact -- used if missingValue is the exact value from the file # greater -- the missing data value is equal to or greater than missingValueIn # less -- the missing data value is equal to or less than missingValueIn # # logYes -- choose the level regrid as linear in log of level or linear in level. Set to # 'yes' for log. Anything else is linear in level. # # # # positionIn -- a tuple with the numerical position of the dimensions # in C or Python order specified in the sequence longitude, # latitude, level and time. Longitude, latitude and level are # required. If time is missing submit None in its slot in the # tuple. Notice that the length of the tuple is always four. # # Explicitly, in terms of the shape of dataIn as returned by Python's shape function # # positionIn[0] contains the position of longitude in dataIn # positionIn[1] contains the position of latitude in dataIn # positionIn[2] contains the position of level in dataIn or None # positionIn[3] contains the position of time in dataIn or None # # As examples: # If the C order shape of 4D data is # (number of longitudes, number of times, number of levels, number of latitudes) # submit # (0, 3, 2, 1) # # If the C order shape of 3D data is # (number of longitudes, number of times, number oflatitudes) # submit # (0, 2, 1, None) # # Send in None if the shape is a subset of (time, level, # latitude, longitude) which is evaluated as follows: # 3D -- code assumes (2,1,0,None) # 4D -- code assumes (3,2,1,0) # # missingValueOut -- the value for the missing data used in writing the output data. If left at the # default entry, None, the code uses missingValueIn if present or as a last resort # 1.0e20 # # # RETURNED : dataOut -- the regridded data # # # USAGE: # # Example 1. To regrid dataIn into dataOut using all the defaults where None, None signifies no # missing data. # dataOut = x.rgrd(dataIn, None, None) # # Example 2. To regrid dataIn into dataOut using 1.0e20 and greater as the missing data # # dataOut = x.rgrd(dataIn, 1.e20, 'greater') # #---------------------------------------------------------------------------------------------------------------------""" # check the required input -- dataIn, missingValueIn and missingMatch # make sure that dataIn is an array try: z = len(dataIn) except TypeError: sendmsg('Error in calling the rgrd method -- dataIn must be an array') raise TypeError # check the missingValueIn pass if missingValueIn != None: try: z = abs(missingValueIn) except TypeError: sendmsg('Error in calling the rgrd method -- missingvalueIn must be None or a number. Now it is ', missingValueIn) raise TypeError # check the missingMatch pass missingPossibilities = ['greater', 'equal', 'less', None] if missingMatch not in missingPossibilities: msg = 'Error in missingMatch -- it must be None or the string greater, equal, or less. Now it is ' sendmsg(msg, missingMatch) raise ValueError # --- Check data type and change to float if necessary ---- if dataIn.dtype.char != 'f': dataIn = dataIn.astype(Numeric.Float32) dataShape = dataIn.shape numberDim = len(dataShape) if numberDim < 2: msg = 'Error in call to rgrd -- data must have at least 2 dimensions' sendmsg(msg) raise TypeError # --- evaluate positionIn ---- # --- make standard positionIn as a check---- positionList =[] for n in range(numberDim): # insert a sequence of numbers positionList.append(n) positionList.reverse() for n in range(numberDim, 4): # fill end of list with Nones positionList.append(None) positionCheck = tuple(positionList) standardPosition = 0 # transpose required if positionIn == None: # construct the default positionIn tuple positionIn = positionCheck standardPosition = 1 # no need for a transpose with this data else: if positionIn == positionCheck: # compare to the standard standardPosition = 1 # no need for a transpose with this data if len(positionIn) != 4: msg = 'Error in call to rgrd -- positionIn must be a tuple of length 4' sendmsg(msg) raise TypeError if standardPosition == 0: # transpose data to the standard order (t,z,y,x) newOrder, inverseOrder = checkorder(positionIn) dataIn = Numeric.transpose(dataIn, newOrder) # transpose data to standard order (t,z,y,x) dataIn = Numeric.array(dataIn.astype(Numeric.Float32), Numeric.Float32) # make contiguous # set dimension sizes and check for consistency if positionIn[0] != None: self.nlon = (dataShape[ positionIn[0] ]) else: self.nlon = 0 if positionIn[1] != None: self.nlat = (dataShape[ positionIn[1] ]) else: self.nlat = 0 if positionIn[2] != None: if self.nlevi != (dataShape[ positionIn[2] ]): msg = 'Level size is inconsistent with input data' sendmsg(msg) raise ValueError if positionIn[3] != None: self.ntime = (dataShape[ positionIn[3] ]) else: self.ntime = 0 # allocate memory for dataOut -- the array with new number of levels outList = list(dataIn.shape) for i in range(len(outList)): if outList[i] == self.nlevi: outList[i] = self.nlevo break dataOut = Numeric.zeros(tuple(outList), Numeric.Float32) # memory for aout if missingMatch == None: # if no missing do not pass None missingMatch = 'none' if missingValueIn == None: # if no missing do not pass None missingValueIn = 1.333e33 if logYes != 'yes': logYes = 'no' levIn = self.axisIn[:].astype(Numeric.Float64) levOut = self.axisOut[:].astype(Numeric.Float64) _regrid.rgdpressure(self.nlevi, self.nlevo, self.nlat, self.nlon, self.ntime, missingValueIn, missingMatch, logYes, levIn, levOut, dataIn, dataOut) if missingMatch == 'none': # if no missing do not pass None missingMatch = None if missingValueIn == 1.333e33: missingValueIn = None if standardPosition == 0: dataOut = Numeric.transpose(dataOut, inverseOrder) # transpose data to original order dataOut = Numeric.array(dataOut.astype(Numeric.Float32), Numeric.Float32) # make contiguous if missingValueOut != None: # set the missing value in data to missingValueOut if missingMatch == 'greater': if missingValueIn > 0.0: missing = 0.99*missingValueIn else: missing = 1.01*missingValueIn dataOut = Numeric.where(Numeric.greater(dataOut,missing), missingValueOut, dataOut) elif missingMatch == 'equal': missing = missingValueIn dataOut = Numeric.where(Numeric.equal(dataOut,missing), missingValueOut, dataOut) elif missingMatch == 'less': if missingValueIn < 0.0: missing = 0.99*missingValueIn else: missing = 1.01*missingValueIn dataOut = Numeric.where(Numeric.less(dataOut,missing), missingValueOut, dataOut) return dataOut
self.logfile.write("Catalog dimension mismatch: ", str(len(t1)), ' ', nsources) self.logfile.write( "Check patrameters in detectionCatalog.inpar and filterCatalog.inpar" ) #flux[i,:],fluxerr[i,:] = tableio.get_data(catalog,self.fluxColumns) flux[i, :], fluxerr[i, :] = t1, t2 flux[i, :] = pUtil.deNAN(flux[i, :]) # Those objects with flux equal or less than 0 are assigned a magnitude of 99 # and a limiting magnitude equal to their SExtractor photometric error. This # is interpreted by BPZ as a nondetection with zero flux and 1-sigma error # equal to the limiting magnitude nondetected = Numeric.less_equal( flux[i, :], 0.0) * Numeric.greater(fluxerr[i, :], 0.0) # Those objects with error flux and flux equal to 0 are assigned a magnitude of -99 # and a flux of 0, which is interpreted by SExtractor as a non-observed object nonobserved = Numeric.less_equal(fluxerr[i, :], 0.0) # When flux error > 100*(flux), mark as nonobserved (Benitez, 24-Oct-03). nonobserved = Numeric.where( fluxerr[i, :] > 100 * (abs(flux[i, :])), 1.0, nonobserved[:]) detected = Numeric.logical_not(nonobserved + nondetected) # Get the zero point for the final magnitudes
def identities(self, aln_dictionary): """ Create a dictionary that contains information about all the alignments in the aln_dictionary using pairwise comparisons. @param aln_dictionary: alignment dictionary @type aln_dictionary: dict @return: a dictionary of dictionaries with the sequence name as the top key. Each sub dictionary then has the keys: - 'name' - str, sequence name - 'seq' - str, sequence of - 'template_info' - list of the same length as the 'key' sequence excluding deletions. The number of sequences in the multiple alignment that contain information at this position. - 'ID' - dict, sequence identity in percent comparing the 'key' sequence to all other sequences (excluding deletions) - 'info_ID' - dict, same as 'ID' but compared to the template sequence length (i.e excluding deletions and insertions in the 'key' sequence ) - 'cov_ID' - dict, same as 'info_ID' but insertions are defined comparing to all template sequences (i.e where 'template_info' is zero ) @rtype: dict """ ## loop over all sequences in alignment for i in self.sequences_name: template_names = [] ## don't compare to self, remove current sequence for name in self.sequences_name: if(name is not i): template_names.append(name) ## loop over all sequences in alignment info_ID, ID, cov_ID = {}, {}, {} for y in self.sequences_name: ## identity = 0 ## info_identity = 0 ## cov_identity = 0 nb_of_identities = 0 nb_of_template = 0 template_info = [] nb_of_residues = 0 ## loop over the full length of the alignment for w in range(len(aln_dictionary["target"]["seq"])): ## skip deletions nb_of_info_res=0 if(aln_dictionary[i]["seq"][w] is not '-'): nb_of_residues += 1 ## count identities if(aln_dictionary[i]["seq"][w] == \ aln_dictionary[y]["seq"][w]): nb_of_identities += 1 ## length excluding insertions if(aln_dictionary[y]["seq"][w] is not '-'): nb_of_template += 1 ## loop over all sequences but self for z in template_names: ## count how many sequences contain alignment ## information at this position if(aln_dictionary[z]["seq"][w] is not '-'): nb_of_info_res += 1 template_info.append(nb_of_info_res) ## number of positions in which any other sequence ## contains alignment information nb_cov_res = N.sum( N.greater(template_info, 0) ) ## calculate identities info_ID[y] = ID[y] = cov_ID[y] = 0 ## RAIK: Hack, nb_of_... can turn 0 for fragmented alignments if nb_of_template: info_ID[y] = 100. * nb_of_identities / nb_of_template if nb_of_residues: ID[y] = 100. * nb_of_identities / nb_of_residues if nb_cov_res: cov_ID[y] = 100. * nb_of_identities / nb_cov_res aln_dictionary[i]["info_ID"] = info_ID aln_dictionary[i]["ID"] = ID aln_dictionary[i]["cov_ID"] = cov_ID aln_dictionary[i]["template_info"] = template_info return aln_dictionary
self.fluxColumns = tuple(fluxList) # the get_data function interface requires a tuple # Build the various columns arrays with the get_data function. # We read raw fluxes and errors into the flux,fluxerr arrays. # They are afterwards transformed to magnitudes pdb.set_trace() #xingxing flux[i,:],fluxerr[i,:] = tableio.get_data(catalog,self.fluxColumns) flux[i,:] = pUtil.deNAN(flux[i,:]) # Those objects with flux equal or less than 0 are assigned a magnitude of 99 # and a limiting magnitude equal to their SExtractor photometric error. This # is interpreted by BPZ as a nondetection with zero flux and 1-sigma error # equal to the limiting magnitude nondetected = Numeric.less_equal(flux[i,:],0.0)*Numeric.greater(fluxerr[i,:],0.0) # Those objects with error flux and flux equal to 0 are assigned a magnitude of -99 # and a flux of 0, which is interpreted by SExtractor as a non-observed object nonobserved = Numeric.less_equal(fluxerr[i,:],0.0) # When flux error > 100*(flux), mark as nonobserved (Benitez, 24-Oct-03). nonobserved = Numeric.where(fluxerr[i,:] > 100*(abs(flux[i,:])),1.0,nonobserved[:]) detected = Numeric.logical_not(nonobserved+nondetected) # Get the zero point for the final magnitudes zpoint = fUtil.zeroPoint(fitsfile) # pass the fits file to zeroPoint func
def createHexInp(recPdb, recModel, ligPdb, ligModel, comPdb=None, outFile=None, macDock=None, silent=0, sol=512): """ Prepare a Hex macro file for the docking of the receptor(s) against ligand(s). @param recPdb: hex-formatted PDB @type recPdb: str @param recModel: hex-formatted PDB @type recModel: str @param ligPdb: PDBModel, get distances from this one @type ligPdb: PDBModel @param ligModel: PDBModel, getdistances from this one @type ligModel: PDBModel @param comPdb: reference PDB @type comPdb: str @param outFile: base of file name for mac and out @type outFile: str @param macDock: None -> hex decides (from the size of the molecule), 1 -> force macroDock, 0-> force off (default: None) @type macDock: None|1|0 @param silent: don't print distances and macro warnings (default: 0) @type silent: 0|1 @param sol: number of solutions that HEx should save (default: 512) @type sol: int @return: HEX macro file name, HEX out generated bu the macro, macro docking status @rtype: str, str, boolean """ ## files and names recCode = t.stripFilename(recPdb)[0:4] ligCode = t.stripFilename(ligPdb)[0:4] outFile = outFile or recCode + '-' + ligCode ## hex macro name macName = t.absfile(outFile + '_hex.mac') ## hex rotation matrix output name outName_all = t.absfile(outFile + '_hex.out') outName_clust = t.absfile(outFile + '_hex_cluster.out') ## add surface profiles if not there if not recModel.atoms.has_key('relAS'): #t.flushPrint('\nCalculating receptor surface profile') rec_asa = PDBDope(recModel) rec_asa.addSurfaceRacer() if not ligModel.atoms.has_key('relAS'): #t.flushPrint('\nCalculating ligand surface profile') lig_asa = PDBDope(ligModel) lig_asa.addSurfaceRacer() ## surface masks, > 95% exposed rec_surf_mask = N.greater(recModel.profile('relAS'), 95) lig_surf_mask = N.greater(ligModel.profile('relAS'), 95) ## maximun and medisn distance from centre of mass to any surface atom recMax, recMin = centerSurfDist(recModel, rec_surf_mask) ligMax, ligMin = centerSurfDist(ligModel, lig_surf_mask) ## approxinate max and min center to centre distance maxDist = recMax + ligMax minDist = recMin + ligMin ## molecular separation and search range to be used in the docking molSep = (maxDist + minDist) / 2 molRange = 2 * (maxDist - molSep) if not silent: print 'Docking setup: %s\nRecMax: %.1f RecMin: %.1f\nLigMax: %.1f LigMin: %.1f\nMaxDist: %.1f MinDist: %.1f\nmolecular_separation: %.1f r12_range: %.1f\n' % ( outFile, recMax, recMin, ligMax, ligMin, maxDist, minDist, molSep, molRange) if recMax > 30 and ligMax > 30 and not silent: print '\nWARNING! Both the receptor and ligand radius is ', print 'greater than 30A.\n' ## determine docking mode to use macroDocking = 0 if macDock == None: if recMax > 35 and not silent: print '\nReceptor has a radius that exceeds 35A ', print '-> Macro docking will be used' macroDocking = 1 else: macroDocking = macDock ##################### ## write macro file macOpen = open(macName, 'w') macOpen.write('# -- ' + macName + ' --\n') macOpen.write(' \n') macOpen.write('open_receptor ' + t.absfile(recPdb) + '\n') macOpen.write('open_ligand ' + t.absfile(ligPdb) + '\n') if comPdb and comPdb[-4:] == '.pdb': macOpen.write('open_complex ' + comPdb + '\n') macOpen.write('\n') head = """ # -------------- general settings ---------------- disc_cache 1 # disc cache on (0 off) docking_sort_mode 1 # Sort solutions by cluster (0 by energy) docking_cluster_mode 1 # Display all clusters (0 display best) docking_cluster_threshold 2.00 # docking_cluster_bumps number # ------------ molecule orientation -------------- molecule_separation %(separation)i commit_view """ % ({ 'separation': round(molSep) }) macro = """ # -------------- macro docking ------------------- macro_min_coverage 25 macro_sphere_radius 15 macro_docking_separation 25 activate_macro_model""" tail = """ # -------------- docking setup ------------------- docking_search_mode 0 # full rotational search receptor_range_angle 180 # 0, 15, 30, 45, 60, 75, 90, 180 docking_receptor_samples 720 # 362, 492, 642, 720, 980, 1280 ligand_range_angle 180 docking_ligand_samples 720 twist_range_angle 360 # 0, 15, 30, 60, 90, 180, 360 docking_alpha_samples 128 # 64, 128, 256 r12_step 0.500000 # 0.1, 0.2, 0.25, 0.5, 0.75, 1, 1.5, 2 r12_range %(range)i docking_radial_filter 0 # Radial Envelope Filter - None grid_size 0.600 # 0.4, 0.5, 0.6, 0.75, 1.0 # docking_electrostatics 0 # use only surface complimentarity docking_electrostatics 1 # use electrostatic term for scoring clusters docking_main_scan 16 # docking_main_search 26 max_docking_solutions %(nr_sol)i # number of solutions to save # -------------- post-processing ---------------- docking_refine 0 # None # docking_refine 1 # Backbone Bumps # docking_refine 2 # MM energies # docking_refine 3 # MM minimization # ---------------- run docking ------------------ activate_docking # save_docking %(output_clust)s # save_range 1 512 ./ dock .pdb # ------------ also save all solutions ---------- docking_sort_mode 0 # Sort solutions by energy (1 by cluster) save_docking %(output_all)s""" \ %({'range':round(molRange), 'output_all':outName_all, 'nr_sol':int(sol), 'output_clust':outName_clust} ) macOpen.writelines(head) ## macro docking will not work with multiple models, if both are added to ## the hex macro file - macrodocking will be skipped during the docking run if macroDocking: macOpen.writelines(macro) macOpen.writelines(tail) macOpen.close() return macName, outName_all, macroDocking
def identities(self, aln_dictionary): """ Create a dictionary that contains information about all the alignments in the aln_dictionary using pairwise comparisons. @param aln_dictionary: alignment dictionary @type aln_dictionary: dict @return: a dictionary of dictionaries with the sequence name as the top key. Each sub dictionary then has the keys: - 'name' - str, sequence name - 'seq' - str, sequence of - 'template_info' - list of the same length as the 'key' sequence excluding deletions. The number of sequences in the multiple alignment that contain information at this position. - 'ID' - dict, sequence identity in percent comparing the 'key' sequence to all other sequences (excluding deletions) - 'info_ID' - dict, same as 'ID' but compared to the template sequence length (i.e excluding deletions and insertions in the 'key' sequence ) - 'cov_ID' - dict, same as 'info_ID' but insertions are defined comparing to all template sequences (i.e where 'template_info' is zero ) @rtype: dict """ ## loop over all sequences in alignment for i in self.sequences_name: template_names = [] ## don't compare to self, remove current sequence for name in self.sequences_name: if (name is not i): template_names.append(name) ## loop over all sequences in alignment info_ID, ID, cov_ID = {}, {}, {} for y in self.sequences_name: ## identity = 0 ## info_identity = 0 ## cov_identity = 0 nb_of_identities = 0 nb_of_template = 0 template_info = [] nb_of_residues = 0 ## loop over the full length of the alignment for w in range(len(aln_dictionary["target"]["seq"])): ## skip deletions nb_of_info_res = 0 if (aln_dictionary[i]["seq"][w] is not '-'): nb_of_residues += 1 ## count identities if(aln_dictionary[i]["seq"][w] == \ aln_dictionary[y]["seq"][w]): nb_of_identities += 1 ## length excluding insertions if (aln_dictionary[y]["seq"][w] is not '-'): nb_of_template += 1 ## loop over all sequences but self for z in template_names: ## count how many sequences contain alignment ## information at this position if (aln_dictionary[z]["seq"][w] is not '-'): nb_of_info_res += 1 template_info.append(nb_of_info_res) ## number of positions in which any other sequence ## contains alignment information nb_cov_res = N.sum(N.greater(template_info, 0)) ## calculate identities info_ID[y] = ID[y] = cov_ID[y] = 0 ## RAIK: Hack, nb_of_... can turn 0 for fragmented alignments if nb_of_template: info_ID[y] = 100. * nb_of_identities / nb_of_template if nb_of_residues: ID[y] = 100. * nb_of_identities / nb_of_residues if nb_cov_res: cov_ID[y] = 100. * nb_of_identities / nb_cov_res aln_dictionary[i]["info_ID"] = info_ID aln_dictionary[i]["ID"] = ID aln_dictionary[i]["cov_ID"] = cov_ID aln_dictionary[i]["template_info"] = template_info return aln_dictionary
def senddata(self): """computes selectionList, partitions the examples and updates infoc; sends out selectionList and selected/other dataStructure or None; """ if self.dataStructure and self.ps.shape[1]: # set selectionList alphas = [self.alphaA, self.alphaB, self.alphaI] selectors = [self.selectorA, self.selectorB, self.selectorI] selectionList = Numeric.ones((self.numExamples,)) boxSelectors = [self.boxSelectorA, self.boxSelectorB, self.boxSelectorI] for si in range(3): try: ## if selectors[si] and self.anovaType in [[0,1,3,4],[2,3,4],[4]][si]: if selectors[si] and boxSelectors[si].isEnabled(): selectionList = Numeric.logical_and(selectionList, Numeric.less(self.ps[si], float(alphas[si]))) except ValueError: print "Warning: cannot convert %s to float" % str(alphas[si]) pass self.infoc.setText('Sending out data...') if self.sendProbabilities: # create example table with probabilities ## print self.ps ## print Numeric.transpose(self.ps).shape etProb = orange.ExampleTable(orange.Domain([orange.FloatVariable("Factor A p-val"),orange.FloatVariable("Factor B p-val"),orange.FloatVariable("Interaction p-val")]), Numeric.transpose(self.ps)) # in etProb, convert p-val to meta attribute domProb = orange.Domain([]) domProb.addmetas(dict(zip([orange.newmetaid(),orange.newmetaid(),orange.newmetaid()], etProb.domain.variables))) etProb = orange.ExampleTable(domProb, etProb) else: # create new etProb without attributes/metas and of length equal to etProb etProb = orange.ExampleTable(orange.Domain([]), Numeric.zeros((selectionList.shape[0],0))) # partition dataStructure and send out data selectionList = selectionList.tolist() self.send("Example Selection", (self.selectorName, selectionList)) dataStructS = [] dataStructN = [] self.progressBarInit() if self.sendNotSelectedData: pbStep = 50./len(self.dataStructure) else: pbStep = 100./len(self.dataStructure) for (dsName, etList) in self.dataStructure: etListS = [et.select(selectionList) for et in etList] for i in range(len(etList)): # append probabilities (if etProb not empty) etListS[i] = orange.ExampleTable([etListS[i], etProb.select(selectionList)]) # add name etListS[i].name = etList[i].name dataStructS.append((dsName, etListS)) self.progressBarAdvance(pbStep) self.send("Selected Structured Data", dataStructS) if self.sendNotSelectedData: for (dsName, etList) in self.dataStructure: etListN = [et.select(selectionList, negate=1) for et in etList] for i in range(len(etList)): # append probabilities (if etProb not empty) etListN[i] = orange.ExampleTable([etListN[i], etProb.select(selectionList, negate=1)]) # add name etListN[i].name = etList[i].name dataStructN.append((dsName, etListN)) self.progressBarAdvance(pbStep) self.send("Other Structured Data", dataStructN) else: self.send("Other Structured Data", None) self.progressBarFinished() # report the number of selected examples numExamples = Numeric.add.reduce(Numeric.greater(selectionList, 0)) self.infoc.setText('Total of %d example%s match criteria.' % (numExamples, ['', 's'][int(numExamples!=1)])) else: self.send("Example Selection", None) self.send("Selected Structured Data", None) self.send("Other Structured Data", None)
def kNNimputeMA(arr2d, K=20, callback=None): """Returns a new 2D MA.array with missing values imputed from K nearest neighbours. Find K rows (axis 0) with the most similar values where similarity measure corresponds to weighted Euclidean distance. Imputed value = weighted average of the corresponding values of K nearest neighbours, where weights equal to tricubic distribution of distances to all rows. Impute missing rows by average over all rows. Version: 30.8.2005 """ arr2d = MA.asarray(arr2d) assert len(arr2d.shape) == 2, "2D array expected" # make a copy for imputation aImp2 = MA.array(arr2d) # leave out columns with 0 known values (columnInd: non-zero columns) columnCond = Numeric.greater(MA.count(arr2d, axis=0), 0) columnIndAll = Numeric.arange(arr2d.shape[1]) columnInd = Numeric.compress(columnCond, columnIndAll) # impute the rows where 0 < #known_values < #non_zero_columns, i.e. exclude the rows with 0 and all (non-zero-column) values countByRows = MA.count(arr2d, axis=1) for rowIdx in Numeric.compress( Numeric.logical_and(Numeric.greater(countByRows, 0), Numeric.less(countByRows, columnInd.shape[0])), Numeric.arange(arr2d.shape[0])): rowResized = MA.resize(arr2d[rowIdx], arr2d.shape) diff = arr2d - rowResized distances = MA.sqrt( MA.add.reduce((diff)**2, 1) / MA.count(diff, axis=1)) # nearest neighbours row indices (without the current row index) indSorted = MA.argsort(distances)[1:] distSorted = distances.take(indSorted) # number of distances different from MA.masked numNonMasked = distSorted.shape[0] - Numeric.add.reduce( Numeric.asarray(MA.getmaskarray(distSorted), Numeric.Int)) # number of distances to account for (K or less) if numNonMasked > 1: weightsSorted = MA.power( 1 - MA.power(distSorted / distSorted[numNonMasked - 1], 3), 3) # tricubic distribution of all weights else: weightsSorted = Numeric.ones(distSorted.shape[0]) # compute average for each column separately in order to account for K non-masked values colInd4CurrRow = Numeric.compress( Numeric.logical_and(MA.getmaskarray(arr2d[rowIdx]), columnCond), columnIndAll) for colIdx in colInd4CurrRow: # column values sorted by distances columnVals = arr2d[:, colIdx].take(indSorted) # take only those weights where columnVals does not equal MA.masked weightsSortedCompressed = MA.compress( 1 - MA.getmaskarray(columnVals), weightsSorted) # impute from K (or possibly less) values aImp2[rowIdx, colIdx] = MA.average(columnVals.compressed()[:K], weights=weightsSortedCompressed[:K]) if callback: callback() # impute the unknown rows with average profile avrgRow = MA.average(arr2d, 0) for rowIdx in Numeric.compress(Numeric.equal(countByRows, 0), Numeric.arange(arr2d.shape[0])): aImp2[rowIdx] = avrgRow if callback: callback() return aImp2
def draw(self): # XXX This method is not speed-optimized. I just wrote it to # get the job done. (Nonetheless, it seems faster than the C # version commented out above.) p = self.parameters # shorthand if p.center is not None: if not hasattr(VisionEgg.config, "_GAVE_CENTER_DEPRECATION"): logger = logging.getLogger('VisionEgg.Dots') logger.warning("Specifying DotArea2D by deprecated " "'center' parameter deprecated. Use " "'position' parameter instead. (Allows " "use of 'anchor' parameter to set to " "other values.)") VisionEgg.config._GAVE_CENTER_DEPRECATION = 1 p.anchor = 'center' p.position = p.center[0], p.center[ 1] # copy values (don't copy ref to tuple) if p.on: # calculate center center = VisionEgg._get_center(p.position, p.anchor, p.size) if p.anti_aliasing: if len(p.color) == 4 and not self._gave_alpha_warning: if p.color[3] != 1.0: logger = logging.getLogger('VisionEgg.Dots') logger.warning("The parameter anti_aliasing is " "set to true in the DotArea2D " "stimulus class, but the color " "parameter specifies an alpha " "value other than 1.0. To " "acheive the best anti-aliasing, " "ensure that the alpha value for " "the color parameter is 1.0.") self._gave_alpha_warning = 1 gl.glEnable(gl.GL_POINT_SMOOTH) # allow max_alpha value to control blending gl.glEnable(gl.GL_BLEND) gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA) else: gl.glDisable(gl.GL_BLEND) now_sec = VisionEgg.time_func() if self.start_times_sec is not None: # compute extinct dots and generate new positions replace_indices = Numeric.nonzero( Numeric.greater(now_sec - self.start_times_sec, p.dot_lifespan_sec)) Numeric.put(self.start_times_sec, replace_indices, now_sec) new_x_positions = RandomArray.uniform(0.0, 1.0, (len(replace_indices), )) Numeric.put(self.x_positions, replace_indices, new_x_positions) new_y_positions = RandomArray.uniform(0.0, 1.0, (len(replace_indices), )) Numeric.put(self.y_positions, replace_indices, new_y_positions) new_random_directions_radians = RandomArray.uniform( 0.0, 2 * math.pi, (len(replace_indices), )) Numeric.put(self.random_directions_radians, replace_indices, new_random_directions_radians) else: # initialize dot extinction values to random (uniform) distribution self.start_times_sec = RandomArray.uniform( now_sec - p.dot_lifespan_sec, now_sec, (self.constant_parameters.num_dots, )) signal_num_dots = int( round(p.signal_fraction * self.constant_parameters.num_dots)) time_delta_sec = now_sec - self.last_time_sec self.last_time_sec = now_sec # reset for next loop x_increment_normalized = math.cos( p.signal_direction_deg / 180.0 * math.pi ) * p.velocity_pixels_per_sec / p.size[0] * time_delta_sec y_increment_normalized = -math.sin( p.signal_direction_deg / 180.0 * math.pi ) * p.velocity_pixels_per_sec / p.size[1] * time_delta_sec self.x_positions[:signal_num_dots] += x_increment_normalized self.y_positions[:signal_num_dots] += y_increment_normalized num_random_dots = self.constant_parameters.num_dots - signal_num_dots random_x_increment_normalized = Numeric.cos( self.random_directions_radians[signal_num_dots:] ) * p.velocity_pixels_per_sec / p.size[0] * time_delta_sec random_y_increment_normalized = -Numeric.sin( self.random_directions_radians[signal_num_dots:] ) * p.velocity_pixels_per_sec / p.size[1] * time_delta_sec self.x_positions[signal_num_dots:] += random_x_increment_normalized self.y_positions[signal_num_dots:] += random_y_increment_normalized self.x_positions = Numeric.fmod(self.x_positions, 1.0) # wrap self.y_positions = Numeric.fmod(self.y_positions, 1.0) self.x_positions = Numeric.fmod(self.x_positions + 1, 1.0) # wrap again for values < 1 self.y_positions = Numeric.fmod(self.y_positions + 1, 1.0) xs = (self.x_positions - 0.5) * p.size[0] + center[0] ys = (self.y_positions - 0.5) * p.size[1] + center[1] if len(p.color) == 3: gl.glColor3f(*p.color) elif len(p.color) == 4: gl.glColor4f(*p.color) gl.glPointSize(p.dot_size) # Clear the modeview matrix gl.glMatrixMode(gl.GL_MODELVIEW) gl.glPushMatrix() gl.glDisable(gl.GL_TEXTURE_2D) if p.depth is None: depth = 0.0 else: gl.glEnable(gl.GL_DEPTH_TEST) depth = p.depth zs = (depth, ) * len(xs) # make N tuple with repeat value of depth draw_dots(xs, ys, zs) if p.anti_aliasing: gl.glDisable(gl.GL_POINT_SMOOTH) # turn off gl.glPopMatrix()
def createHexInp( recPdb, recModel, ligPdb, ligModel, comPdb=None, outFile=None, macDock=None, silent=0, sol=512 ): """ Prepare a Hex macro file for the docking of the receptor(s) against ligand(s). @param recPdb: hex-formatted PDB @type recPdb: str @param recModel: hex-formatted PDB @type recModel: str @param ligPdb: PDBModel, get distances from this one @type ligPdb: PDBModel @param ligModel: PDBModel, getdistances from this one @type ligModel: PDBModel @param comPdb: reference PDB @type comPdb: str @param outFile: base of file name for mac and out @type outFile: str @param macDock: None -> hex decides (from the size of the molecule), 1 -> force macroDock, 0-> force off (default: None) @type macDock: None|1|0 @param silent: don't print distances and macro warnings (default: 0) @type silent: 0|1 @param sol: number of solutions that HEx should save (default: 512) @type sol: int @return: HEX macro file name, HEX out generated bu the macro, macro docking status @rtype: str, str, boolean """ ## files and names recCode = t.stripFilename( recPdb )[0:4] ligCode = t.stripFilename( ligPdb )[0:4] outFile = outFile or recCode + '-' + ligCode ## hex macro name macName = t.absfile( outFile + '_hex.mac' ) ## hex rotation matrix output name outName_all = t.absfile( outFile + '_hex.out' ) outName_clust = t.absfile( outFile + '_hex_cluster.out') ## add surface profiles if not there if not recModel.atoms.has_key('relAS'): #t.flushPrint('\nCalculating receptor surface profile') rec_asa = PDBDope( recModel ) rec_asa.addSurfaceRacer() if not ligModel.atoms.has_key('relAS'): #t.flushPrint('\nCalculating ligand surface profile') lig_asa = PDBDope( ligModel ) lig_asa.addSurfaceRacer() ## surface masks, > 95% exposed rec_surf_mask = N.greater( recModel.profile('relAS'), 95 ) lig_surf_mask = N.greater( ligModel.profile('relAS'), 95 ) ## maximun and medisn distance from centre of mass to any surface atom recMax, recMin = centerSurfDist( recModel, rec_surf_mask ) ligMax, ligMin = centerSurfDist( ligModel, lig_surf_mask ) ## approxinate max and min center to centre distance maxDist = recMax + ligMax minDist = recMin + ligMin ## molecular separation and search range to be used in the docking molSep = ( maxDist + minDist ) / 2 molRange = 2 * ( maxDist - molSep ) if not silent: print 'Docking setup: %s\nRecMax: %.1f RecMin: %.1f\nLigMax: %.1f LigMin: %.1f\nMaxDist: %.1f MinDist: %.1f\nmolecular_separation: %.1f r12_range: %.1f\n'%(outFile, recMax, recMin, ligMax, ligMin, maxDist, minDist, molSep, molRange) if recMax > 30 and ligMax > 30 and not silent: print '\nWARNING! Both the receptor and ligand radius is ', print 'greater than 30A.\n' ## determine docking mode to use macroDocking = 0 if macDock==None: if recMax > 35 and not silent: print '\nReceptor has a radius that exceeds 35A ', print '-> Macro docking will be used' macroDocking = 1 else: macroDocking = macDock ##################### ## write macro file macOpen= open( macName, 'w') macOpen.write('# -- ' + macName + ' --\n') macOpen.write(' \n') macOpen.write('open_receptor '+ t.absfile(recPdb) +'\n') macOpen.write('open_ligand '+ t.absfile(ligPdb) +'\n') if comPdb and comPdb[-4:] == '.pdb': macOpen.write('open_complex '+comPdb+'\n') macOpen.write('\n') head = """ # -------------- general settings ---------------- disc_cache 1 # disc cache on (0 off) docking_sort_mode 1 # Sort solutions by cluster (0 by energy) docking_cluster_mode 1 # Display all clusters (0 display best) docking_cluster_threshold 2.00 # docking_cluster_bumps number # ------------ molecule orientation -------------- molecule_separation %(separation)i commit_view """%({'separation': round(molSep)} ) macro =""" # -------------- macro docking ------------------- macro_min_coverage 25 macro_sphere_radius 15 macro_docking_separation 25 activate_macro_model""" tail = """ # -------------- docking setup ------------------- docking_search_mode 0 # full rotational search receptor_range_angle 180 # 0, 15, 30, 45, 60, 75, 90, 180 docking_receptor_samples 720 # 362, 492, 642, 720, 980, 1280 ligand_range_angle 180 docking_ligand_samples 720 twist_range_angle 360 # 0, 15, 30, 60, 90, 180, 360 docking_alpha_samples 128 # 64, 128, 256 r12_step 0.500000 # 0.1, 0.2, 0.25, 0.5, 0.75, 1, 1.5, 2 r12_range %(range)i docking_radial_filter 0 # Radial Envelope Filter - None grid_size 0.600 # 0.4, 0.5, 0.6, 0.75, 1.0 # docking_electrostatics 0 # use only surface complimentarity docking_electrostatics 1 # use electrostatic term for scoring clusters docking_main_scan 16 # docking_main_search 26 max_docking_solutions %(nr_sol)i # number of solutions to save # -------------- post-processing ---------------- docking_refine 0 # None # docking_refine 1 # Backbone Bumps # docking_refine 2 # MM energies # docking_refine 3 # MM minimization # ---------------- run docking ------------------ activate_docking # save_docking %(output_clust)s # save_range 1 512 ./ dock .pdb # ------------ also save all solutions ---------- docking_sort_mode 0 # Sort solutions by energy (1 by cluster) save_docking %(output_all)s""" \ %({'range':round(molRange), 'output_all':outName_all, 'nr_sol':int(sol), 'output_clust':outName_clust} ) macOpen.writelines( head ) ## macro docking will not work with multiple models, if both are added to ## the hex macro file - macrodocking will be skipped during the docking run if macroDocking: macOpen.writelines( macro ) macOpen.writelines( tail ) macOpen.close() return macName, outName_all, macroDocking
def draw(self): # XXX This method is not speed-optimized. I just wrote it to # get the job done. (Nonetheless, it seems faster than the C # version commented out above.) p = self.parameters # shorthand if p.center is not None: if not hasattr(VisionEgg.config,"_GAVE_CENTER_DEPRECATION"): logger = logging.getLogger('VisionEgg.Dots') logger.warning("Specifying DotArea2D by deprecated " "'center' parameter deprecated. Use " "'position' parameter instead. (Allows " "use of 'anchor' parameter to set to " "other values.)") VisionEgg.config._GAVE_CENTER_DEPRECATION = 1 p.anchor = 'center' p.position = p.center[0], p.center[1] # copy values (don't copy ref to tuple) if p.on: # calculate center center = VisionEgg._get_center(p.position,p.anchor,p.size) if p.anti_aliasing: if len(p.color) == 4 and not self._gave_alpha_warning: if p.color[3] != 1.0: logger = logging.getLogger('VisionEgg.Dots') logger.warning("The parameter anti_aliasing is " "set to true in the DotArea2D " "stimulus class, but the color " "parameter specifies an alpha " "value other than 1.0. To " "acheive the best anti-aliasing, " "ensure that the alpha value for " "the color parameter is 1.0.") self._gave_alpha_warning = 1 gl.glEnable( gl.GL_POINT_SMOOTH ) # allow max_alpha value to control blending gl.glEnable( gl.GL_BLEND ) gl.glBlendFunc( gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA ) else: gl.glDisable( gl.GL_BLEND ) now_sec = VisionEgg.time_func() if self.start_times_sec is not None: # compute extinct dots and generate new positions replace_indices = Numeric.nonzero( Numeric.greater( now_sec - self.start_times_sec, p.dot_lifespan_sec) ) Numeric.put( self.start_times_sec, replace_indices, now_sec ) new_x_positions = RandomArray.uniform(0.0,1.0, (len(replace_indices),)) Numeric.put( self.x_positions, replace_indices, new_x_positions ) new_y_positions = RandomArray.uniform(0.0,1.0, (len(replace_indices),)) Numeric.put( self.y_positions, replace_indices, new_y_positions ) new_random_directions_radians = RandomArray.uniform(0.0,2*math.pi, (len(replace_indices),)) Numeric.put( self.random_directions_radians, replace_indices, new_random_directions_radians ) else: # initialize dot extinction values to random (uniform) distribution self.start_times_sec = RandomArray.uniform( now_sec - p.dot_lifespan_sec, now_sec, (self.constant_parameters.num_dots,)) signal_num_dots = int(round(p.signal_fraction * self.constant_parameters.num_dots)) time_delta_sec = now_sec - self.last_time_sec self.last_time_sec = now_sec # reset for next loop x_increment_normalized = math.cos(p.signal_direction_deg/180.0*math.pi) * p.velocity_pixels_per_sec / p.size[0] * time_delta_sec y_increment_normalized = -math.sin(p.signal_direction_deg/180.0*math.pi) * p.velocity_pixels_per_sec / p.size[1] * time_delta_sec self.x_positions[:signal_num_dots] += x_increment_normalized self.y_positions[:signal_num_dots] += y_increment_normalized num_random_dots = self.constant_parameters.num_dots - signal_num_dots random_x_increment_normalized = Numeric.cos(self.random_directions_radians[signal_num_dots:]) * p.velocity_pixels_per_sec / p.size[0] * time_delta_sec random_y_increment_normalized = -Numeric.sin(self.random_directions_radians[signal_num_dots:]) * p.velocity_pixels_per_sec / p.size[1] * time_delta_sec self.x_positions[signal_num_dots:] += random_x_increment_normalized self.y_positions[signal_num_dots:] += random_y_increment_normalized self.x_positions = Numeric.fmod( self.x_positions, 1.0 ) # wrap self.y_positions = Numeric.fmod( self.y_positions, 1.0 ) self.x_positions = Numeric.fmod( self.x_positions+1, 1.0 ) # wrap again for values < 1 self.y_positions = Numeric.fmod( self.y_positions+1, 1.0 ) xs = (self.x_positions - 0.5) * p.size[0] + center[0] ys = (self.y_positions - 0.5) * p.size[1] + center[1] if len(p.color)==3: gl.glColor3f(*p.color) elif len(p.color)==4: gl.glColor4f(*p.color) gl.glPointSize(p.dot_size) # Clear the modeview matrix gl.glMatrixMode(gl.GL_MODELVIEW) gl.glPushMatrix() gl.glDisable(gl.GL_TEXTURE_2D) if p.depth is None: depth = 0.0 else: gl.glEnable(gl.GL_DEPTH_TEST) depth = p.depth zs = (depth,)*len(xs) # make N tuple with repeat value of depth draw_dots(xs,ys,zs) if p.anti_aliasing: gl.glDisable( gl.GL_POINT_SMOOTH ) # turn off gl.glPopMatrix()