def _raw_fft(a, n=None, axis=-1, init_function=fftpack.cffti,
work_function=fftpack.cfftf, fft_cache = _fft_cache ):
a = Numeric.asarray(a)
if n == None: n = a.shape[axis]
try:
wsave = fft_cache[n]
except(KeyError):
wsave = init_function(n)
fft_cache[n] = wsave
if a.shape[axis] != n:
s = list(a.shape)
if s[axis] > n:
index = [slice(None)]*len(s)
index[axis] = slice(0,n)
a = a[index]
else:
index = [slice(None)]*len(s)
index[axis] = slice(0,s[axis])
s[axis] = n
z = Numeric.zeros(s, a.typecode())
z[index] = a
a = z
if axis != -1:
a = Numeric.swapaxes(a, axis, -1)
r = work_function(a, wsave)
if axis != -1:
r = Numeric.swapaxes(r, axis, -1)
return r
def solSpace(veclist, base=2):
"""Takes a list of vectors defining a basis, and returns a list of possible values for the mod space"""
solutions = [(Numeric.nonzero(veclist[0]) + 1).tolist()] # first solution is trivial, constant portion of space
parameters = len(veclist) - 1 # find the total number of parameterized vectors
combos = pow(base, parameters) # find the total number of solutions (base number to the power of parameters)
for i in range(1, combos): # for each combo (starting at one, because we already have the zeroth
val = i
sum = veclist[0] # grab the constant
parm = 1 # index into the parameters
while val > 0:
mult = val % base # the multiplier for the row
val = val / base # the remainder for the next row
if mult == 0: # if the multiplier is 0, skip to the next vector
parm += 1
continue
add = veclist[parm] * mult # multiply parameter vector by multiplier
sum = modAdd(sum, add, base) # perform addition
sol = (Numeric.nonzero(sum) + 1).tolist() # convert to a list of lights
if not (sol in solutions): # if this solution isn't unique, don't add it
solutions.append(sol)
answer = solutions[0]
for sol in range(1, len(solutions)): # for
if len(solutions[sol]) < len(answer):
answer = solutions[sol]
return answer
def spline_extension(x, y, y2, xmin=None, xmax=None): """x, y, y2 = spline_extension(x_vals,y_vals, y2vals, xmin=None, xmax=None) returns the x, y, y2 table for the spline as needed by splint() with adjustments to allow quadratic extrapolation outside the range x[0]-x[-1], from xmin (or x[0] if xmin is None) to xmax (or x[-1] if xmax is None), working from x, y, y2 from an already-created spline""" xl=[x] yl=[y] y2l=[y2] if xmin is not None: h0=x[1]-x[0] h1=xmin-x[0] yextrap=y[0]+((y[1]-y[0])/h0 - h0*(y2[0]+2.0*y2[1])/6.0)*h1+y2[0]*h1*h1/2.0 yl.insert(0, (yextrap,)) xl.insert(0, (xmin,)) y2l.insert(0, (y2[0],)) if xmax is not None: h0=x[-1]-x[-2] h1=xmax-x[-1] yextrap=y[-1]+((y[-1]-y[-2])/h0 + h0*(2.0*y2[-2]+y2[-1])/6.0)*h1+y2[-1]*h1*h1/2.0 yl.append((yextrap,)) xl.append((xmax,)) y2l.append((y2[-1],)) return Numeric.concatenate(xl), Numeric.concatenate(yl), Numeric.concatenate(y2l)
def __init__( self, w, h, over ): self.w = w self.h = h self.last_update = pygame.time.get_ticks( ) self.first_time = self.last_update self.surface = pygame.surface.Surface( (w, h), SRCALPHA, 32 ) self.surface.convert_alpha( ) self.over = over parray = pygame.surfarray.pixels3d( self.surface ) parray[:,:] = (255, 255, 255) self.ttma = Numeric.zeros( (w, h), 'b' ) self.dv = Numeric.zeros( (w, h), 'b' ) self.rand_plus = Numeric.zeros( (w, h), 'b' ) self.rand_minus = Numeric.zeros( (w, h), 'b' ) self.active = False def center_dist( i, j ): x = w/2.0 - i y = h/2.0 - j d = math.sqrt( x*x + y*y ) d = 1.0 - pow( d/max( w/2, h/2 ), 2.0 ) if d < 0: return 0 return int( d*255 ) jr = range( 0, self.h ) ir = range( 0, self.w ) for j in jr: for i in ir: self.dv[i,j] = center_dist( i, j ) self.rand_plus[i,j] = random.random( )*20 self.rand_minus[i,j] = random.random( )*20
def __getitem__(self, item):
if type(item) != type(0):
return SubTrajectory(self, Numeric.arange(len(self)))[item]
if item >= len(self):
raise IndexError
tindex = Numeric.add.reduce(Numeric.greater_equal(item, self.nsteps))-1
return self.trajectories[tindex][item-self.nsteps[tindex]]
def getFreq(self, seconds):
if self.fake:
base = 300
if random.random() < .2:
freq = base + randint(-50,50)
else:
freq = base + randint(-200, 200)
#freq = (random.random() * 400) + 100.0
distance = freq * 0.0051 - 0.0472
return (distance, freq, 1, 1, 1, 1)
data = self.read(seconds)
self.timestamp = time.time()
transform = FFT.real_fft(data).real
minFreq = 20
maxFreq = 700
minFreqPos = int(minFreq * seconds)
maxFreqPos = int(maxFreq * seconds)
minFreqPos = max(0, minFreqPos)
maxFreqPos = min(int(self.sample_rate * seconds), maxFreqPos)
if minFreqPos == maxFreqPos:
self.lastFreq = int(self.sample_rate * sampleTime/ 2.0)
return
elif minFreqPos > maxFreqPos:
minFreqPos, maxFreqPos = maxFreqPos, minFreqPos
freqPos = Numeric.argmax(transform[1+minFreqPos:maxFreqPos])
value = transform[1+minFreqPos:maxFreqPos][freqPos]
freq = int((freqPos + minFreqPos) / seconds)
distance = freq * 0.0051 - 0.0472
bestFreqPos = Numeric.argmax(transform[1:])
bestValue = transform[1:][bestFreqPos]
bestFreq = int(bestFreqPos / seconds)
return (distance, freq, value, transform[0], bestFreq, bestValue)
def set_data (self, evt):
dB = evt.data
L = len (dB)
if self.peak_hold:
if self.peak_vals is None:
self.peak_vals = dB
else:
self.peak_vals = Numeric.maximum(dB, self.peak_vals)
dB = self.peak_vals
x = max(abs(self.facsink.sample_rate), abs(self.facsink.baseband_freq))
sf = 1000.0
units = "ms"
x_vals = ((Numeric.arrayrange (L/2)
* ( (sf / self.facsink.sample_rate ) )) )
points = Numeric.zeros((len(x_vals), 2), Numeric.Float64)
points[:,0] = x_vals
points[:,1] = dB[0:L/2]
lines = plot.PolyLine (points, colour='green') # DARKRED
graphics = plot.PlotGraphics ([lines],
title=self.facsink.title,
xLabel = units, yLabel = "dB")
self.Draw (graphics, xAxis=None, yAxis=self.y_range)
self.update_y_range ()
def __init__(self,filename):
try:
file = open(filename,'r')
file.close()
except IOError:
raise UserInputException('%s does not exist' % filename)
img = Image.open(filename)
self.filename = filename
self.size = max(img.size[0],img.size[1])
img = img.convert('I') #convert to int
temp = Numeric.fromstring(img.tostring(), Numeric.Int32)
# I am not exactly sure why PI and Numeric's tostring and
# fromstring method are transposed relative to eachother,
# but this code is what works
temp.shape = img.size[1],img.size[0]
# pad values if necessary
self.data = Numeric.zeros((self.size,self.size),Numeric.Int32)
self.data[0:temp.shape[0],0:temp.shape[1]] = temp
self.data = Numeric.transpose(self.data)
def subcounts(self,prefix=[]):
if not prefix:
return Numeric.array([m._count for m in self.t_table.itervalues()])
elif prefix[0] not in self.t_table:
return Numeric.array([0])
else:
return self.t_table[prefix[0]].subcounts(prefix[1:])
def LinearLeastSquaresFit(xdata,ydata):
"""
Special case of polynomialLeastSquaresFit,
which returns the R^2 value
intercept,slope,R_squared = LinearLeastSquaresFit(xdata,ydata)
"""
xdata=Numeric.array(xdata)
ydata=Numeric.array(ydata)
# form that LeastSquaresFit wants the data in
data=map(lambda x,y:(x,y),xdata,ydata)
# I am not sure if the particular guess for parameters will result in a error in some cases
lsq=polynomialLeastSquaresFit(parameters=(0,0), data=data)
intercept=lsq[0][0]
slope=lsq[0][1]
avg_y=mean(ydata)
predicted_data = intercept + slope*xdata
numerator=Numeric.sum((predicted_data-ydata)**2)
denominator=Numeric.sum((ydata-avg_y)**2)
R_squared = 1 - numerator/denominator
return intercept,slope, R_squared
def process(fname):
"""Process verif output file.
fname: name of file
return: tuple of (exp_name, solver, dx, dt, dome_e, max_e, min_e, mean_e, sd_e)"""
# extract errors
ncf = Scientific.IO.NetCDF.NetCDFFile(fname)
diff = ncf.variables["thke"][-1, :, :] - ncf.variables["thk"][-1, :, :]
centre = (Numeric.shape(diff)[0] - 1) / 2
dome_e = diff[centre, centre]
diff = Numeric.ravel(diff)
max_e = max(diff)
min_e = min(diff)
hist = histogram.histogram(100)
hist.set_ranges_uniform(round_down(min_e), round_up(max_e))
for e in diff.tolist():
hist.increment(e)
mean_e = hist.mean()
sd_e = hist.sigma()
config = ncf.title.split(",")
exp_name = config[0][-1]
solver = config[1].strip()
dx = float(config[2].strip()[:-2])
dt = float(config[3].strip()[:-1])
ncf.close()
return (exp_name, solver, dx, dt, dome_e, max_e, min_e, mean_e, sd_e)
def main():
# Retrieve user input
try:
f = open(sys.argv[1], "r")
lines = f.readlines()
except:
print "\n usage: " + sys.argv[0] + " CO2_angles.dat\n"
sys.exit(0)
# Read in the data
angles, probs = [], []
for line in lines:
row = line.split()
angles.append(float(row[0]))
probs.append(float(row[1]))
# Do the rescaling
for i in range(len(angles)):
factor = ((math.sin(angles[i] * (math.pi / 180.0))) ** 2) ** 0.5
if factor < 1.0e-03:
factor = 1.0e-03
probs[i] /= factor
norm = Numeric.sum(Numeric.array(probs))
# Write to output file
out = open("CO2_angles.dat.norm", "w")
for i in range(len(angles) - 1):
out.write(str(angles[i]) + " " + str(probs[i] / norm) + "\n")
out.close()
def solve_linear_equations(a, b):
one_eq = len(b.shape) == 1
if one_eq:
b = b[:, Numeric.NewAxis]
_assertRank2(a, b)
_assertSquareness(a)
n_eq = a.shape[0]
n_rhs = b.shape[1]
if n_eq != b.shape[0]:
raise LinAlgError, 'Incompatible dimensions'
t =_commonType(a, b)
# lapack_routine = _findLapackRoutine('gesv', t)
if _array_kind[t] == 1: # Complex routines take different arguments
lapack_routine = lapack_lite.zgesv
else:
lapack_routine = lapack_lite.dgesv
a, b = _fastCopyAndTranspose(t, a, b)
pivots = Numeric.zeros(n_eq, 'l')
results = lapack_routine(n_eq, n_rhs, a, n_eq, pivots, b, n_eq, 0)
if results['info'] > 0:
raise LinAlgError, 'Singular matrix'
if one_eq:
return Numeric.ravel(b) # I see no need to copy here
else:
return multiarray.transpose(b) # no need to copy
def _ticks(self, lower, upper):
ideal = (upper-lower)/7.
log = Numeric.log10(ideal)
power = Numeric.floor(log)
fraction = log-power
factor = 1.
error = fraction
for f, lf in self._multiples:
e = Numeric.fabs(fraction-lf)
if e < error:
error = e
factor = f
grid = factor * 10.**power
if power > 3 or power < -3:
format = '%+7.0e'
elif power >= 0:
digits = max(1, int(power))
format = '%' + `digits`+'.0f'
else:
digits = -int(power)
format = '%'+`digits+2`+'.'+`digits`+'f'
ticks = []
t = -grid*Numeric.floor(-lower/grid)
while t <= upper:
ticks.append( (t, format % (t,)) )
t = t + grid
return ticks
def removePolygons(self):
""" Remove all the polygons from the object. """
self.polygonsX = Numeric.array([], Numeric.Float)
self.polygonsY = Numeric.array([], Numeric.Float)
self.polygonBeginningsIndex = Numeric.array([], Numeric.Int)
self.polygonNumberOfItems = Numeric.array([], Numeric.Int)
def boundingBox(self):
p1, p2 = self.objects[0].boundingBox()
for o in self.objects[1:]:
p1o, p2o = o.boundingBox()
p1 = Numeric.minimum(p1, p1o)
p2 = Numeric.maximum(p2, p2o)
return p1, p2
def _axisInterval(self, spec, lower, upper):
if spec is None:
return None
if spec == 'minimal':
if lower == upper:
return lower-0.5, upper+0.5
else:
return lower, upper
if spec == 'automatic':
range = upper-lower
if range == 0.:
return lower-0.5, upper+0.5
log = Numeric.log10(range)
power = Numeric.floor(log)
fraction = log-power
if fraction <= 0.05:
power = power-1
grid = 10.**power
lower = lower - lower % grid
mod = upper % grid
if mod != 0:
upper = upper - mod + grid
return lower, upper
if type(spec) == type(()):
lower, upper = spec
if lower <= upper:
return lower, upper
else:
return upper, lower
raise ValueError, str(spec) + ': illegal axis specification'
def GetArray(self):
input = self.__export.GetInput()
input.UpdateInformation()
type = input.GetScalarType()
extent = input.GetWholeExtent()
numComponents = input.GetNumberOfScalarComponents()
dim = (extent[5]-extent[4]+1,
extent[3]-extent[2]+1,
extent[1]-extent[0]+1)
if (numComponents > 1):
dim = dim + (numComponents,)
size = dim[0]*dim[1]*dim[2]*numComponents*self.__sizeDict[type]
if _NEW_NUMERIC:
imArray = Numeric.zeros((size,),Numeric.UnsignedInt8)
self.__export.Export(imArray)
else:
imString = Numeric.zeros((size,),
Numeric.UnsignedInt8).tostring()
self.__export.Export(imString)
imArray = Numeric.fromstring(imString,self.__typeDict[type])
# just to remind myself of the dangers of memory management
del imString
# reshape array appropriately.
imArray = Numeric.reshape(imArray, dim)
# convert unsigned short to int to avoid sign issues
if (type == VTK_UNSIGNED_SHORT and self.__ConvertUnsignedShortToInt):
imArray = umath.bitwise_and(imArray.astype(Numeric.Int32),0xffff)
return imArray
def length(self):
"""Returns a scalar field corresponding to the length (norm) of
the vector field."""
l = Numeric.sqrt(Numeric.add.reduce(self.values**2, -1))
try: default = Numeric.sqrt(Numeric.add.reduce(self.default))
except ValueError: default = None
return ScalarField(self.axes, l, default, 0)
def _setsize(self):
self.width = string.atoi(self.canvas.cget('width'))
self.height = string.atoi(self.canvas.cget('height'))
self.plotbox_size = 0.97*Numeric.array([self.width, -self.height])
xo = 0.5*(self.width-self.plotbox_size[0])
yo = self.height-0.5*(self.height+self.plotbox_size[1])
self.plotbox_origin = Numeric.array([xo, yo])
def draw(self, graphics):
"""Draws the graphics object |graphics|, which can be
a PolyLine3D or a VisualizationGraphics object."""
self.last_draw = (graphics, )
self.configure(cursor='watch')
self.update_idletasks()
graphics.project(self.axis, self.plane)
p1, p2 = graphics.boundingBoxPlane()
center = 0.5*(p1+p2)
scale = self.plotbox_size / (p2-p1)
sign = scale/Numeric.fabs(scale)
if self.scale is None:
minscale = Numeric.minimum.reduce(Numeric.fabs(scale))
self.scale = 0.9*minscale
scale = sign*self.scale
box_center = self.plotbox_origin + 0.5*self.plotbox_size
shift = -center*scale + box_center + self.translate
graphics.scaleAndShift(scale, shift)
items, depths = graphics.lines()
sort = Numeric.argsort(depths)
for index in sort:
x1, y1, x2, y2, color, width = items[index]
Line(self.canvas, x1, y1, x2, y2, fill=color, width=width)
self.configure(cursor='top_left_arrow')
self.update_idletasks()
def computeTriangle(tri):
"""This is a nested function which computes the angles in a triangle
or on the face of a tetrahedron.
Could employ dot product or cosine & sine rules.
Input: three references to points in array 'cells'
Output: three angles in degrees (list)
"""
# define three rotations of the same triangle so that the same
# algorithm can be used to find each angle
a = points[tri[0]]; b = points[tri[1]]; c = points[tri[2]]
tris = [[a, b, c], [b, c, a], [c, b, a]]
angles = []
for i in tris:
# define 2 vectors representing 2 sides of the triangle
# either side of the angle to be calculated
r_ab = Numeric.transpose(i[1]) - i[0]
r_ac = Numeric.transpose(i[2]) - i[0]
# calculate the angle between the two sides
rdotr = Numeric.dot(r_ab, r_ac)
modrr = math.sqrt(sum(r_ab**2))*math.sqrt(sum(r_ac**2))
angle = math.degrees(math.acos(rdotr / modrr))
angles.append(angle)
# tangles = Numeric.zeros([3],Numeric.Float32)
# print len(angles)
# print angles[0], angles[1], angles[2]
tangles = [angles[0], angles[1], angles[2]]
return tangles
def GetLatLongString(ddvalue,lltype='latitude'):
""" Convert a decimal degree value to a
string appropriate for Lat/Long
display.
ddvalue- position in decimal degrees
lltype- latitude or longitude
returns: lat/long string
"""
import Numeric
deg=int(abs(ddvalue))
min=int((abs(ddvalue)-deg)*60)
sec=int((abs(ddvalue)-deg-(float(min)/60.0))*3600.0)
if lltype == 'latitude':
if Numeric.sign(ddvalue) == -1:
ch='S'
else:
ch='N'
else:
if Numeric.sign(ddvalue) == -1:
ch='W'
else:
ch='E'
nstr="%dd%d'%.1f''%s" % (deg,min,sec,ch)
return nstr
def _conv_numpy_to_numeric(array):
kind = array.dtype.kind
if kind == 'V':
raise FlavorError( "the ``numeric`` flavor does not support "
"heterogeneous arrays" )
# It seems that the array protocol in Numeric does leak. See
# http://comments.gmane.org/gmane.comp.python.numeric.general/12563
# for more info on this issue.
##if kind != 'S':
## return Numeric.asarray(array) # use the array protocol
shape = array.shape
if kind == 'S':
if array.itemsize > 1:
# Numeric does not support character arrays with elements
# with a size > 1. Simulate with an additional dimension.
shape = shape + (array.itemsize,)
typecode = 'c'
else:
# See the above note about the Numeric leak.
typecode = _numtype_from_nptype[array.dtype.type]
# Convert to a contiguous buffer (``tostring()`` is very efficient).
arrstr = array.tostring()
array = Numeric.fromstring(arrstr, typecode)
array = Numeric.reshape(array, shape)
return array
def raster_add( s_fh, s_xoff, s_yoff, s_xsize, s_ysize, s_band_n,
t_fh, t_xoff, t_yoff, t_xsize, t_ysize, t_band_n,
nodata ):
import Numeric
if verbose != 0:
print 'Copy %d,%d,%d,%d to %d,%d,%d,%d.' \
% (s_xoff, s_yoff, s_xsize, s_ysize,
t_xoff, t_yoff, t_xsize, t_ysize )
s_band = s_fh.GetRasterBand( s_band_n )
t_band = t_fh.GetRasterBand( t_band_n )
data_src = s_band.ReadAsArray( s_xoff, s_yoff, s_xsize, s_ysize,
t_xsize, t_ysize )
data_dst = t_band.ReadAsArray( t_xoff, t_yoff, t_xsize, t_ysize )
nodata_test = Numeric.equal(data_src,s_band.GetNoDataValue())
data_src_fill = Numeric.choose( nodata_test, (data_src, 0) )
to_write = Numeric.add(data_src_fill,data_dst)
t_band.WriteArray( to_write, t_xoff, t_yoff )
return 0
def main():
# Retrieve user input
try:
f = open(sys.argv[1],'r')
lines = f.readlines()
f.close()
except:
print '\n usage: '+sys.argv[0]+' XY.dat\n'
sys.exit(0)
# Parse the data
t, y = [], []
for line in lines:
t.append(float(line.split()[0]))
y.append(float(line.split()[1]))
# Calculate the FFT and get the frequencies
N = float(len(t))
dt = t[1] - t[0]
T = N * dt
df = 1.0 / T
f = Numeric.arange(N,typecode=Numeric.Float)*df
H = ( FFT.fft(y)*Numeric.conjugate(FFT.fft(y)) ).real / N
# Write to file
out = open('PSD.dat','w')
for i in range(len(f)/2):
out.write(str(f[i])+' '+str(H[i])+'\n')
out.close()
def overshootPath(pts):
result = []
for i in range(1, len(pts)-1):
p2 = pts[i]
back = 0
i2 = i
while back < 40 and i2 > 0:
back += Vector(pts[i2 + 1] - pts[i2]).length()
i2 -= 1
p0 = pts[i2]
back = 0
i2 = i
while back < 25 and i2 > 0:
back += Vector(pts[i2 + 1] - pts[i2]).length()
i2 -= 1
p1 = pts[i2]
f = 1
d = 5
p = -f/d * p0 + -(f*2)/d * p1 + (d + f * 3)/d * p2
result.append(num.array([p[0], p[1]]))
nearPts = num.concatenate((pts[:15], pts[-15:]))
inner = sum(nearPts) / len(nearPts)
result = [inner] + result[-2:] + result + result[:7]
return result
def GetAlphabeticGridString(index):
""" Get string for reference grid horizontal
index (1='A',2='B',...,27='AA',...)
"""
# This function doesn't work yet.
alphabet=['A','B','C','D','E','F','G','H','I','J','K',
'L','M','N','O','P','Q','R','S','T','U','V',
'W','X','Y','Z']
alen=len(alphabet)
sc=Numeric.log(alen)
nletters=int(Numeric.log(index)/sc)
str=''
rem=index
for idx in range(nletters,-1,-1):
rint=int(rem/pow(alen,idx-1))
rem=rem-rint*pow(alen,idx-1)
print 'rint ',rint,' rem: ',rem
if (rint == 0) and (len(str) == 0):
continue
if rem == 0:
str=str+alphabet[0]
else:
str=str+alphabet[rint-1]
return str
def _getMatrix(data, dof):
"""Create the matrices A and b for a spline with 4 data points."""
# We need to be sure that we've got exactly 4 data points.
assert(Numeric.shape(data)[0] == 4)
A = Numeric.zeros((12, 12))
b = [Numeric.zeros((12,)) for i in range(dof)]
row = 0
for t in range(1,4):
# Constrain the spline to fit the 4 points in this chunk of the
# trajectory.
col = (t - 1) * 4
A[row, col:col + 4] = [1, t, t**2, t**3]
for i in range(dof): b[i][row] = data[t - 1, i]
row += 1
A[row, col:col + 4] = [1, t + 1, (t + 1)**2, (t + 1)**3]
for i in range(dof): b[i][row] = data[t, i]
row += 1
# Constrain the first and second derivatives at each of the
# internal points to be equal.
if t < 3:
A[row + 4, col:col + 8] = [0, 1, 2 * t, 3 * t**2, 0, -1, -2 * t, -3 * t**2]
A[row + 5, col:col + 8] = [0, 0, 2, 6 * t, 0, 0, -2, -6 * t]
# Constrain the second derivative of the end points of the trajectory to
# be 0.
A[-2, :4] = [0, 0, 2, 6]
A[-1, -4:] = [0, 0, 2, 24]
return (A, b)
def __find_opt_w_p_node(self):
"""Help function for load_balancing()
Finds and returns the optimal number of walkers
per node for a possibly non-uniform set of nodes
"""
timings = self.pypar.gather(Numeric.array([abs(self.t1-self.t0)]),
self.master_rank)
tmp_timings = copy.deepcopy(timings)
timings = self.pypar.broadcast(tmp_timings,
self.master_rank)
C = self.no_of_walkers/sum(1./timings)
tmp_loc_walkers = C/timings
self.loc_walkers = self.NumericFloat2IntList(tmp_loc_walkers)
remainders = tmp_loc_walkers-self.loc_walkers
while sum(self.loc_walkers) < self.no_of_walkers:
maxarg = Numeric.argmax(remainders)
self.loc_walkers[maxarg] += 1
remainders[maxarg] = 0
if self.master and self.first_balance and\
not hasattr(self,'silent'):
print timings
print self.loc_walkers
return self.loc_walkers
def op_less_than(self, value, filter_keys):
return Numeric.arrayrange(value)
def check_numpy_array_argument_return(self):
import numpy as N
f = PyCFunction('foo')
f += Variable('a', N.ndarray, 'in, out')
foo = f.build()
assert_equal(foo(N.array([1, 2])), N.array([1, 2]))
def __init__(self, *args):
Qt.QWidget.__init__(self, *args)
layout = Qt.QGridLayout(self)
# try to create a plot for SciPy arrays
try:
# import does_not_exist
import numpy
# make a curve and copy the data
numpy_curve = Qwt.QwtPlotCurve('y = lorentzian(x)')
x = numpy.arange(0.0, 10.0, 0.01)
y = lorentzian(x)
numpy_curve.setData(x, y)
# here, we know we can plot NumPy arrays
numpy_plot = Qwt.QwtPlot(self)
numpy_plot.setTitle('numpy array')
numpy_plot.setCanvasBackground(Qt.Qt.white)
numpy_plot.plotLayout().setCanvasMargin(0)
numpy_plot.plotLayout().setAlignCanvasToScales(True)
# insert a curve and make it red
numpy_curve.attach(numpy_plot)
numpy_curve.setPen(Qt.QPen(Qt.Qt.red))
layout.addWidget(numpy_plot, 0, 0)
numpy_plot.replot()
except ImportError as message:
print("%s: %s" % (ImportError, message))
print("Install NumPy to plot plot NumPy arrays")
except TypeError as message:
print("%s: %s" % (TypeError, message))
print("Rebuild PyQwt to plot NumPy arrays")
# try to create a plot for Numeric arrays
try:
# import does_not_exist
import Numeric
# make a curve and copy the data
numeric_curve = Qwt.QwtPlotCurve('y = lorentzian(x)')
x = Numeric.arange(0.0, 10.0, 0.01)
y = lorentzian(x)
numeric_curve.setData(x, y)
# here, we know we can plot Numeric arrays
numeric_plot = Qwt.QwtPlot(self)
numeric_plot.setTitle('Numeric array')
numeric_plot.setCanvasBackground(Qt.Qt.white)
numeric_plot.plotLayout().setCanvasMargin(0)
numeric_plot.plotLayout().setAlignCanvasToScales(True)
# insert a curve and make it red
numeric_curve.attach(numeric_plot)
numeric_curve.setPen(Qt.QPen(Qt.Qt.red))
layout.addWidget(numeric_plot, 0, 1)
numeric_plot.replot()
except ImportError as message:
print("%s: %s" % (ImportError, message))
print("Install Numeric to plot Numeric arrays")
except TypeError as message:
print("%s: %s" % (TypeError, message))
print("Rebuild PyQwt to plot Numeric arrays")
# try to create a plot for numarray arrays
try:
# import does_not_exist
import numarray
# make a curve and copy the data
numarray_curve = Qwt.QwtPlotCurve('y = lorentzian(x)')
x = numarray.arange(0.0, 10.0, 0.01)
y = lorentzian(x)
numarray_curve.setData(x, y)
# here, we know we can plot numarray arrays
numarray_plot = Qwt.QwtPlot(self)
numarray_plot.setTitle('numarray array')
numarray_plot.setCanvasBackground(Qt.Qt.white)
numarray_plot.plotLayout().setCanvasMargin(0)
numarray_plot.plotLayout().setAlignCanvasToScales(True)
# insert a curve and make it red
numarray_curve.attach(numarray_plot)
numarray_curve.setPen(Qt.QPen(Qt.Qt.red))
layout.addWidget(numarray_plot, 1, 0)
numarray_plot.replot()
except ImportError as message:
print("%s: %s" % (ImportError, message))
print("Install numarray to plot numarray arrays")
except TypeError as message:
print("%s: %s" % (TypeError, message))
print("Rebuild PyQwt to plot numarray arrays")
# create a plot widget for lists of Python floats
list_plot = Qwt.QwtPlot(self)
list_plot.setTitle('Python list')
list_plot.setCanvasBackground(Qt.Qt.white)
list_plot.plotLayout().setCanvasMargin(0)
list_plot.plotLayout().setAlignCanvasToScales(True)
x = drange(0.0, 10.0, 0.01)
y = [lorentzian(item) for item in x]
# insert a curve, make it red and copy the lists
list_curve = Qwt.QwtPlotCurve('y = lorentzian(x)')
list_curve.attach(list_plot)
list_curve.setPen(Qt.QPen(Qt.Qt.red))
list_curve.setData(x, y)
layout.addWidget(list_plot, 1, 1)
list_plot.replot()
def op_between(self, value, filter_keys):
return Numeric.arrayrange(*value)
def op_greater_equal(self, value, filter_keys):
return Numeric.arrayrange(value, len(self))
def op_greater_than(self, value, filter_keys):
return Numeric.arrayrange(value + 1, len(self))
def op_less_equal(self, value, filter_keys):
return Numeric.arrayrange(value + 1)
def __init__(self, startfile, communicator=None, deforming_mesh=False):
"""Initialize the object.
Keyword arguments:
startfile -- the name of the SUmb input parameter file
communicator -- an MPI communicator for specifying which processors
to run on (optional)
deforming_mesh -- set to True or False whether or not this is a
deforming mesh case (optional, default is False)
"""
# Make sure the parameter file exists
if not os.path.isfile(startfile):
print 'Error: Could not find file %s' % startfile
return None
# Setup a mesh object
self.Mesh = SUmbMesh()
# Create a Python communicator to mirror the Fortran
# SUmb_COMM_WORLD and set the Fortran SUmb communicator to the
# Python one.
if (communicator is not None):
self.sumb_comm_world = communicator
else:
self.sumb_comm_world = mpi.COMM_WORLD.comm_create(
mpi.COMM_WORLD[:])
sumb.communication.sumb_comm_world = int(self.sumb_comm_world)
self.Mesh.sumb_comm_world = self.sumb_comm_world
# Store the name of the input file
self.startfile = startfile
sumb.inputio.paramfile[0:len(startfile)] = startfile
# Determine the rank and number of processors inside the group
# defined by sumb_comm_world.
self.myid = sumb.communication.myid = self.sumb_comm_world.rank
self.nproc = sumb.communication.nproc = self.sumb_comm_world.size
# Allocate the memory for SENDREQUESTS and RECVREQUESTS.
try:
sumb.communication.sendrequests = Numeric.zeros(
(self.sumb_comm_world.size))
sumb.communication.recvrequests = Numeric.zeros(
(self.sumb_comm_world.size))
except:
print "Memory allocation failure for SENDREQUESTS " \
"and RECVREQUESTS."
return
# Set the SUmb module value of standalonemode to false and
# the value of deforming_grid to the input value.
sumb.iteration.standalonemode = False
sumb.iteration.deforming_grid = deforming_mesh
# Write the intro message
sumb.writeintromessage()
# Read the parameter file
sumb.readparamfile()
# Partition the blocks and read the grid
sumb.partitionandreadgrid()
# Perform the preprocessing task
sumb.preprocessing()
# Initialize the flow variables
sumb.initflow()
# Create dictionary of variables we are monitoring
nmon = sumb.monitor.nmon[0]
self.monnames = {}
for i in range(nmon):
self.monnames[string.strip(
sumb.monitor.monnames[i].tostring())] = i
# Create dictionary of the family names
sumb.mdgetfamilynames()
nfamilies = sumb.mddata.mdnfamilies[0]
self.Mesh.families = {}
for i in range(nfamilies):
self.Mesh.families[string.strip(
sumb.mddata.mdfamilynames[i].tostring())] = i + 1
sumb.mdcreatensurfnodes()
# Determine the total number of blocks in the mesh and store it
self.Mesh.nmeshblocks = self.sumb_comm_world.allreduce(
sumb.block.ndom[0], mpi.SUM)
return
import Numeric, hist, math, random
a = Numeric.array(
map(
lambda x: map(lambda y: float(y), x.split()),
open("/cdat/dafe/mccann/luminosity/tunes.dat",
"r").read().splitlines()))
execfile("/cdat/dafe/mccann/luminosity/tmp.py")
def cotT(aline):
myx = random.gauss(bx, bdx)
myy = random.gauss(by, bdy)
myz = 0.
if random.random() > bzgap:
myz = random.gauss(bz, bdz1)
else:
myz = random.gauss(bz, bdz2)
(westx, westy, westz, eastx, easty, eastz) = aline
westcotT = (westz + myz) / math.sqrt((westx + myx)**2 + (westy + myy)**2)
eastcotT = (eastz + myz) / math.sqrt((eastx + myx)**2 + (easty + myy)**2)
return (westcotT - eastcotT) / 2.
(bx, by, bz) = (0., 0., 0.)
(bdx, bdy, bdz1, bdz2, bzgap) = (0., 0., 0., 0., 0.)
def test(x, y, z, dx, dy, dz1, dz2, zgap):
global bx, by, bz, bdx, bdy, bdz1, bdz2, bzgap
def take(self, rows):
return Numeric.take(self.data, rows)
def all_reduce(self, x):
xs = self.pypar.gather(Numeric.array([x]), self.master_rank)
return self.pypar.broadcast(float(Numeric.sum(xs)), self.master_rank)
def sma(input, length):
# return the sma for the current bar (input[0])
return Numeric.sum(input[0:length]) / length
ttl1='Ideal Wall'
elif data['tw']==0:
ttl1='No Wall'
else:
ttl1 = '%s=10^{%g}'%(ttl,(cmath.log10(data[var_key]).real))
try:
g._add_to_queue([Gnuplot.Data(evalsr,evalsi,with='points ps 2',title=ttl1)])
if i == int(ref):
g.itemlist[-1].set_option(with='points ps 3')
except (ValueError):
continue
var_list.append(data[var_key])
for i in range(len(matching_files)):
print matching_files[i],':',var_list[i],'; ',
print ''
inds = Numeric.argsort(var_list)
g.itemlist = list(Numeric.take(g.itemlist,inds))
if min(var_list)==-1:
g.itemlist.append(g.itemlist[0])
g.itemlist = g.itemlist[1:]
tt = ''
for i in range(len(print_keys)):
if print_keys[i] != var_key:
tt = tt+'%s=%g, '%(print_keys[i],d1.data[print_keys[i]])
g.title(tt[:-2])
set_ytics = 'set ytics ('
set_xtics = 'set xtics ('
for i in range(2):
for j in range(-int(cmath.log10(scale_fac).real)+0,13,1):
scale = (-1)**i*10**j
if j%2 != 0:
def NumericFloat2IntList(self, x):
return Numeric.array(x.tolist(), 'i').tolist()
self.uiinboundinterval = uidata.Integer('Interval', 10, 'rw', persist=True)
inboundcontainer = uidata.Container('Inbound')
inboundcontainer.addObjects((self.uiinboundhostname,
self.uiinboundusername,
self.uiinboundpassword,
self.uiinboundinterval))
testsettingsmethod = uidata.Method('Confirm', self.testSettings)
settingscontainer = uidata.Container('Settings')
settingscontainer.addObjects((addresscontainer, outboundcontainer,
inboundcontainer, testsettingsmethod))
container = uidata.LargeContainer('Email')
container.addObjects((statuscontainer, settingscontainer))
self.uicontainer.addObject(container)
'''
if __name__ == '__main__':
import getpass
import Numeric
numericimage = Numeric.ones((256, 256))
imagestring = NumericImage2String(numericimage)
message = makeMessage('*****@*****.**', '*****@*****.**',
'testing email', 'this is a test...', imagestring)
send(message, 'cronus1')
#username = getpass.getuser()
username = '******'
password = getpass.getpass()
print waitForReply(message, 'mail.scripps.edu', username, password)
def main():
# Grab config file from command line ========================================
if sys.argv[1]:
configFile = sys.argv[1]
else:
print "Please supply a config file."
return
# Parse config file =========================================================
file = open(configFile, 'r')
fileContents = file.read()
pattern = re.compile(r"^(\w+)\s*=(.*)$", re.M)
config = pattern.findall(fileContents)
config = dict(config)
for key in config:
config[key] = config[key].strip()
#print key+": "+config[key]
# Construct the problem =====================================================
#=== Comm ===#
comm = Epetra.PyComm()
#=== Map ===#
# These two lines work correctly...
n = 19881
map = Epetra.Map(n, 0, comm)
# ...this doesn't...but we'd like to create the map directly from the file...
#(ierr, map) = EpetraExt.MatrixMarketFileToMap(config['A_FILE'], comm)
#=== Matrix ===#
(ierr,
matrix) = EpetraExt.MatrixMarketFileToCrsMatrix(config['A_FILE'], map)
#=== LHS ===#
if config.has_key('X_FILE') and config['X_FILE']:
file = open(config['X_FILE'], 'r')
fileContents = file.read()
pattern = re.compile(r"\s*\d+\s+\d+\s+((?:-|\d|.)+)\s*$", re.M)
values = pattern.findall(fileContents)
values = [float(v) for v in values]
lhs = Epetra.Vector(map, Numeric.array(values))
else:
lhs = Epetra.Vector(map)
lhs.Random()
#=== RHS ===#
if config.has_key('B_FILE') and config['B_FILE']:
file = open(config['B_FILE'], 'r')
fileContents = file.read()
pattern = re.compile(r"\s*\d+\s+\d+\s+((?:-|\d|.)+)\s*$", re.M)
values = pattern.findall(fileContents)
values = [float(v) for v in values]
rhs = Epetra.Vector(map, Numeric.array(values))
else:
rhs = Epetra.Vector(map)
rhs.PutScalar(0.0)
# Solve the problem =========================================================
# sets up the parameters for ML using a python dictionary
mlList = {}
mlList['output'] = 10
if config.has_key('SMOOTHER_TYPE') and config['SMOOTHER_TYPE']:
mlList['smoother: type'] = config['SMOOTHER_TYPE']
if config.has_key('SMOOTHER_SWEEPS') and config['SMOOTHER_SWEEPS']:
mlList['smoother: sweeps'] = int(config['SMOOTHER_SWEEPS'])
if config.has_key('SMOOTHER_MLS_POLYNOMIAL_ORDER'
) and config['SMOOTHER_MLS_POLYNOMIAL_ORDER']:
mlList['smoother: MLS plynomial order'] = int(
config['SMOOTHER_MLS_POLYNOMIAL_ORDER'])
if config.has_key('COARSE_TYPE') and config['COARSE_TYPE']:
mlList['coarse: type'] = config['COARSE_TYPE']
if config.has_key('COARSE_SWEEPS') and config['COARSE_SWEEPS']:
mlList['coarse: sweeps'] = int(config['COARSE_SWEEPS'])
if config.has_key('COARSE_MLS_POLYNOMIAL_ORDER'
) and config['COARSE_MLS_POLYNOMIAL_ORDER']:
mlList['coarse: MLS plynomial order'] = int(
config['COARSE_MLS_POLYNOMIAL_ORDER'])
if config.has_key('MAX_LEVELS') and config['MAX_LEVELS']:
mlList['max levels'] = int(config['MAX_LEVELS'])
if config.has_key('AGGREGATION_TYPE') and config['AGGREGATION_TYPE']:
mlList['aggregation: type'] = config['AGGREGATION_TYPE']
if config.has_key('AGGREGATION_DAMPING_FACTOR'
) and config['AGGREGATION_DAMPING_FACTOR']:
mlList['aggregation: damping factor'] = float(
config['AGGREGATION_DAMPING_FACTOR'])
# creates the preconditioner and computes it
prec = ML.MultiLevelPreconditioner(matrix, False)
prec.SetParameterList(mlList)
prec.ComputePreconditioner()
# sets up the solver, specifies Prec as preconditioner, and solves using CG.
solver = AztecOO.AztecOO(matrix, lhs, rhs)
solver.SetPrecOperator(prec)
solver.SetAztecOption(AztecOO.AZ_solver, AztecOO.AZ_cg)
solver.SetAztecOption(AztecOO.AZ_output, 16)
solver.Iterate(1550, 1e-5)
def ReadRaster(raster, x, y, w, h):
"""读取栅格数据（用来保证越界不会出错）
@type raster: gdal.RasterDataset
@param raster: 数据集
@type x:int
@type y:int
@type w:int
@type h: int
@param x,y,w,h: 读取栅格的矩形大小
"""
rasw, rash = raster.RasterXSize, raster.RasterYSize
bandcount = raster.RasterCount
begx, begy, width, height = x, y, w, h
exwr, exwl, exhb, exht = 0, 0, 0, 0 #超过图像范围的行列
if x < 0:
begx = 0
exwl = -x
width -= exwl
if y < 0:
begy = 0
exht = -y
height -= exht
if x + w > rasw:
exwr = x + w - rasw
width = rasw - begx
if y + h > rash:
exhb = y + h - rash
height = rash - begy
print begx, begy, width, height
data = raster.ReadAsArray(begx, begy, width, height)
datatype = data.typecode()
data = RRGGBB2RGBRGB(data)
#进行数组的扩展和补充
if exwl > 0 and exwr > 0:
data1 = Num.zeros((height, exwl, bandcount), datatype)
data2 = Num.zeros((height, exwr, bandcount), datatype)
data = Num.concatenate((data1, data, data2), 1)
elif exwl > 0:
data1 = Num.zeros((height, exwl, bandcount), datatype)
data = Num.concatenate((data1, data), 1)
elif exwr > 0:
data2 = Num.zeros((height, exwr, bandcount), datatype)
data = Num.concatenate((data, data2), 1)
if exht > 0 and exhb > 0:
data1 = Num.zeros((exht, w, bandcount), datatype)
data2 = Num.zeros((exhb, w, bandcount), datatype)
data = Num.concatenate((data1, data, data2))
elif exht > 0:
data1 = Num.zeros((exht, w, bandcount), datatype)
data = Num.concatenate((data1, data))
elif exhb > 0:
data2 = Num.zeros((exhb, w, bandcount), datatype)
data = Num.concatenate((data, data2))
return data
def main():
pygame.init()
screen = pygame.display.set_mode((640, 480))
im1 = pygame.Surface(screen.get_size())
#im1= im1.convert()
im1.fill((100, 0, 0))
im2 = pygame.Surface(screen.get_size())
im2.fill((0, 50, 0))
# we make a srcalpha copy of it.
#im3= im2.convert(SRCALPHA)
im3 = im2
im3.set_alpha(127)
images = {}
images[K_1] = im2
images[K_2] = pygame.image.load(os.path.join(data_dir, "chimp.bmp"))
images[K_3] = pygame.image.load(os.path.join(data_dir, "alien3.gif"))
images[K_4] = pygame.image.load(os.path.join(data_dir, "liquid.bmp"))
img_to_blit = im2.convert()
iaa = img_to_blit.convert_alpha()
blits = {}
blits[K_a] = BLEND_ADD
blits[K_s] = BLEND_SUB
blits[K_m] = BLEND_MULT
blits[K_EQUALS] = BLEND_MAX
blits[K_MINUS] = BLEND_MIN
blitsn = {}
blitsn[K_a] = "BLEND_ADD"
blitsn[K_s] = "BLEND_SUB"
blitsn[K_m] = "BLEND_MULT"
blitsn[K_EQUALS] = "BLEND_MAX"
blitsn[K_MINUS] = "BLEND_MIN"
screen.blit(im1, (0, 0))
pygame.display.flip()
clock = pygame.time.Clock()
print("one pixel is:%s:" % [im1.get_at((0, 0))])
going = True
while going:
clock.tick(60)
for event in pygame.event.get():
if event.type == QUIT:
going = False
if event.type == KEYDOWN:
usage()
if event.type == KEYDOWN and event.key == K_ESCAPE:
going = False
elif event.type == KEYDOWN and event.key in images.keys():
img_to_blit = images[event.key]
iaa = img_to_blit.convert_alpha()
elif event.type == KEYDOWN and event.key in blits.keys():
t1 = time.time()
# blits is a dict keyed with key -> blit flag. eg BLEND_ADD.
im1.blit(img_to_blit, (0, 0), None, blits[event.key])
t2 = time.time()
print("one pixel is:%s:" % [im1.get_at((0, 0))])
print("time to do:%s:" % (t2 - t1))
elif event.type == KEYDOWN and event.key in [K_t]:
for bkey in blits.keys():
t1 = time.time()
for x in range(300):
im1.blit(img_to_blit, (0, 0), None, blits[bkey])
t2 = time.time()
# show which key we're doing...
onedoing = blitsn[bkey]
print("time to do :%s: is :%s:" % (onedoing, t2 - t1))
elif event.type == KEYDOWN and event.key in [K_o]:
t1 = time.time()
# blits is a dict keyed with key -> blit flag. eg BLEND_ADD.
im1.blit(iaa, (0, 0))
t2 = time.time()
print("one pixel is:%s:" % [im1.get_at((0, 0))])
print("time to do:%s:" % (t2 - t1))
elif event.type == KEYDOWN and event.key == K_SPACE:
# this additive blend without clamp two surfaces.
#im1.set_alpha(127)
#im1.blit(im1, (0,0))
#im1.set_alpha(255)
t1 = time.time()
im1p = pygame.surfarray.pixels2d(im1)
im2p = pygame.surfarray.pixels2d(im2)
im1p += im2p
del im1p
del im2p
t2 = time.time()
print("one pixel is:%s:" % [im1.get_at((0, 0))])
print("time to do:%s:" % (t2 - t1))
elif event.type == KEYDOWN and event.key in [K_z]:
t1 = time.time()
im1p = pygame.surfarray.pixels3d(im1)
im2p = pygame.surfarray.pixels3d(im2)
im1p16 = im1p.astype(Numeric.UInt16)
im2p16 = im1p.astype(Numeric.UInt16)
im1p16 += im2p16
im1p16 = Numeric.minimum(im1p16, 255)
pygame.surfarray.blit_array(im1, im1p16)
del im1p
del im2p
t2 = time.time()
print("one pixel is:%s:" % [im1.get_at((0, 0))])
print("time to do:%s:" % (t2 - t1))
elif event.type == KEYDOWN and event.key in [K_r, K_g, K_b]:
# this adds one to each pixel.
colmap = {}
colmap[K_r] = 0x10000
colmap[K_g] = 0x00100
colmap[K_b] = 0x00001
im1p = pygame.surfarray.pixels2d(im1)
im1p += colmap[event.key]
del im1p
print("one pixel is:%s:" % [im1.get_at((0, 0))])
elif event.type == KEYDOWN and event.key == K_p:
print("one pixel is:%s:" % [im1.get_at((0, 0))])
elif event.type == KEYDOWN and event.key == K_f:
# this additive blend without clamp two surfaces.
t1 = time.time()
im1.set_alpha(127)
im1.blit(im2, (0, 0))
im1.set_alpha(255)
t2 = time.time()
print("one pixel is:%s:" % [im1.get_at((0, 0))])
print("time to do:%s:" % (t2 - t1))
screen.blit(im1, (0, 0))
pygame.display.flip()
pygame.quit()
import biggles, Numeric
x = [9.460 - 0.020, 9.460, 10.023 - 0.020, 10.023, 10.355 - 0.020, 10.355]
y = [0.9990, 0.9921, 1.0002, 0.9969, 0.9983, 0.9928]
dy = [0.0025, 0.0020, 0.0017, 0.0037, 0.0029, 0.0023]
p = biggles.Table(2, 1)
p[0, 0] = biggles.FramedPlot()
p[0, 0].add(biggles.Points(x, y, symboltype="filled circle"))
p[0, 0].add(biggles.SymmetricErrorBarsY(x, y, dy))
p[0, 0].add(biggles.LineY(1.))
p[0, 0].x1.range = 9.3, 10.5
p[0, 0].y1.range = 0.985, 1.0035
p[0, 0].x1.label = "Center of mass energy (GeV)"
p[0, 0].y1.label = "BB lumi / GG lumi"
p[1, 0] = biggles.FramedPlot()
p[1,0].add(biggles.Curve([9.3, 9.4, 9.4, 9.5, 9.5, 10, 10, 10.1, 10.1, 10.3, 10.3, 10.4, 10.4, 10.5],\
Numeric.array([0, 0, 350.3*0.025/8.993, 350.3*0.025/8.993, 0, 0, 142.32*0.020/7.945, 142.32*0.020/7.945, 0, 0, 96.14*0.024/7.361, 96.14*0.024/7.361, 0, 0])*18/350.3))
p[1, 0].x1.range = 9.3, 10.5
p[1, 0].x1.label = "Center of mass energy (GeV)"
p[1, 0].y1.label = r"Size of $\Upsilon \to e^+e^-$ correction"
p[1, 0].y1.range = 0., 0.06
p.show()
p.write_eps("lumiratio.eps")
def guess_cb(self, *args):
"""Guess image geometry parameters."""
def correlation(array1, array2):
"""Calculate correlation coefficient of two arrays."""
n_elems = float(array1.shape[0])
M1 = Numeric.add.reduce(array1)
M2 = Numeric.add.reduce(array2)
D1 = Numeric.add.reduce(array1 * array1) - M1 * M1 / n_elems
D2 = Numeric.add.reduce(array2 * array2) - M2 * M2 / n_elems
K = (Numeric.add.reduce(array1 * array2) - M1 * M2 / n_elems) / math.sqrt(D1 * D2)
return K
header = long(self.header_entry.get_text())
width = long(self.width_entry.get_text())
height = long(self.height_entry.get_text())
bands = long(self.bands_entry.get_text())
gdaltype = \
gdal.GetDataTypeByName(self.type_list[self.type_menu.get_history()])
numtype = gdalnumeric.GDALTypeCodeToNumericTypeCode(gdaltype)
depth = gdal.GetDataTypeSize(gdaltype) / 8
filename = self.open_entry.get_text()
if os.path.isfile(filename) == 0:
gvutils.error('Input file '+filename+' does not exist!')
return
filesize = os.stat(filename)[ST_SIZE]
if filesize < header:
gvutils.error('Specified header size larger then file size!')
return
imagesize = (filesize - header) / bands / depth
if width != 0 and height == 0:
height = imagesize / width
elif width == 0 and height != 0:
width = imagesize / height
else:
rawfile = open(filename, 'rb')
longt = 40.0 # maximum possible height/width ratio
cor_coef = 0.0
w = long(math.sqrt(imagesize / longt))
w_max = long(math.sqrt(imagesize * longt))
if (self.swap_menu.get_history() == 0 \
and sys.byteorder == 'little') or \
(self.swap_menu.get_history() == 1 and sys.byteorder == 'big'):
swap = 0
else:
swap = 1
while w < w_max:
if imagesize % w == 0:
scanlinesize = w * depth
h = imagesize / w
rawfile.seek(header + h / 2 * scanlinesize)
buf1 = rawfile.read(scanlinesize)
buf2 = rawfile.read(scanlinesize)
a1 = Numeric.fromstring(buf1, numtype)
a2 = Numeric.fromstring(buf2, numtype)
if swap:
a1.byteswapped()
a2.byteswapped()
try:
tmp = correlation(a1.astype(Numeric.Float32), a2.astype(Numeric.Float32))
except:
# catch 0 division errors
gvutils.error('Unable to guess image geometry!')
return
if tmp > cor_coef:
cor_coef = tmp
width = w
height = h
w += 1
self.width_entry.set_text(str(width))
self.height_entry.set_text(str(height))
# Prep the individual data files (makes topocentric data)
print "\n\n**** Making topocentric data files...\n\n"
ns = []
epochs = []
for filenum in xrange(len(files)):
file = files[filenum]
if (datatype == 'pkmb'):
(nout, dt, epoch) = pkmb_prepdata(optlist, file, filenum)
ns.append(nout)
epochs.append(epoch)
if (numout):
epochs.append(epochs[0] + numout * dt / 86400.0)
ns.append(0)
ns = Numeric.asarray(ns)
epochs = Numeric.asarray(epochs)
# Calculate the amount of padding to add after each file
binsneeded = ((epochs[1:] - epochs[:-1]) * 86400.0 / dt + 0.5).astype('i')
padbins = binsneeded - ns[:-1]
# Add padding to the data topocentric files we just wrote
print "\n\n**** Adding padding...\n\n"
for filenum in xrange(len(padbins)):
outfile = optlist['o'] + ` filenum ` + '.dat'
if (padbins[filenum] > 0):
command = 'patchdata ' + ` padbins[
import gnosis.xml.pickle as xml_pickle
import Numeric, array
import funcs
funcs.set_parser()
class foo:
pass
f = foo()
f.a = Numeric.array([[1, 2, 3, 4], [5, 6, 7, 8]])
f.b = Numeric.array([1.2, 2.3, 3.4, 4.5])
f.y = array.array('b', [1, 2, 3, 4])
f.z = array.array('f', [1, 2, 3, 4])
a = Numeric.array([6, 7, 8, 9])
def testfoo(o1, o2):
for attr in ['a', 'b', 'y', 'z', 'l', 'd', 'e']:
if getattr(o1, attr) != getattr(o2, attr):
raise "ERROR(1)"
# make sure refs work
f.l = [a, a, a]
f.d = {'One': a, 'Two': Numeric.array([10, 11, 12])}
def __init__(self, addressLength, dataLength):
self.addressDecoder = Neuron(randomBits(addressLength))
self.counters = Numeric.zeros(dataLength)
def _test_soomfunc(self, fn, want, *args):
args = [Numeric.array(a, typecode='l') for a in args]
result = fn(*args)
self.assertEqual(result.typecode(), 'l')
self.assertEqual(list(result), want)
def main():
"""
Return desired atomic coordinates
"""
try:
num_x_trans = int(sys.argv[1])
num_y_trans = int(sys.argv[2])
num_z_trans = int(sys.argv[3])
basis_type = sys.argv[4]
except IndexError:
print '\nusage: ' + sys.argv[
0] + ' x_trans, y_trans, z_trans, basis_type\n'
sys.exit(0)
a = 1.0
if basis_type == 'hcp':
a1 = Numeric.array([1.0, 0.0, 0.0]) * a
a2 = Numeric.array([-0.5, 3**0.5 / 2.0, 0.0]) * a
a3 = Numeric.array([0.0, 0.0, (8.0 / 3.0)**0.5]) * a
else:
a1 = Numeric.array([a, 0.0, 0.0])
a2 = Numeric.array([0.0, a, 0.0])
a3 = Numeric.array([0.0, 0.0, a])
sc = Numeric.array([[0.0, 0.0, 0.0]])
hcp = Numeric.array([[0.0, 0.0, 0.0]])
bcc = Numeric.array([[0.0, 0.0, 0.0], [0.5, 0.5, 0.5]])
fcc = Numeric.array([[0.0, 0.0, 0.0], [0.5, 0.5, 0.0], [0.5, 0.0, 0.5],
[0.0, 0.5, 0.5]])
cI16_JY = Numeric.array([[4.0E-02, 4.0E-02, 4.0E-02],
[4.6E-01, 9.6E-01, 5.4E-01],
[9.6E-01, 5.4E-01, 4.6E-01],
[2.9E-01, 2.9E-01, 2.9E-01],
[5.4E-01, 4.6E-01, 9.6E-01],
[2.1E-01, 7.1E-01, 7.9E-01],
[7.1E-01, 7.9E-01, 2.1E-01],
[7.9E-01, 2.1E-01, 7.1E-01],
[5.4E-01, 5.4E-01, 5.4E-01],
[9.6E-01, 4.6E-01, 4.0E-02],
[4.6E-01, 4.0E-02, 9.6E-01],
[4.0E-02, 9.6E-01, 4.6E-01],
[7.9E-01, 7.9E-01, 7.9E-01],
[7.1E-01, 2.1E-01, 2.9E-01],
[2.1E-01, 2.9E-01, 7.1E-01],
[2.9E-01, 7.1E-01, 2.1E-01]])
tetragonal_nitrogen = Numeric.array([[0.098, 0.098, 0.0],
[0.902, 0.902, 0.0],
[0.402, 0.598, 0.5],
[0.598, 0.402, 0.5]])
Nepsilon = Numeric.array([[0.0477444, 0.0394043, 0.949856],
[0.952256, 0.960596, 0.0501445],
[0.531101, 0.438327, 0.442201],
[0.435612, 0.359518, 0.54249],
[0.172472, 0.502245, 0.925462],
[0.22403, 0.399988, 0.031043],
[0.648548, 0.489154, 0.910909],
[0.700106, 0.386897, 0.0164902],
[0.0960269, 0.157856, 0.472166],
[0.970638, 0.227801, 0.589518],
[0.0374346, 0.633818, 0.458946],
[0.912046, 0.703763, 0.576298],
[0.540886, 0.00789884, 0.7523],
[0.446018, 0.90098, 0.706547],
[0.606758, 0.94395, 0.272419],
[0.51189, 0.837031, 0.226665]])
cgN = Numeric.array([[0.067000, 0.067000, 0.067000],
[0.567000, 0.933000, 0.567000],
[0.933000, 0.433000, 0.433000],
[0.567000, 0.433000, 0.933000],
[0.500000, 0.500000, 0.500000],
[0.933000, 0.433000, 0.000000],
[0.500000, 0.067000, 0.933000],
[0.067000, 0.933000, 0.433000]])
Nchain = Numeric.array([[0.000000, 0.000000, 0.000000],
[0.000000, 0.500000, 0.1300000],
[0.500000, 0.000000, 0.500000],
[0.500000, 0.500000, 0.6300000]])
# Nchain = Numeric.array([ [0.000000, 0.000000, 0.000000], [0.000000, 1.275000, 0.680000],
# [1.055000, 0.000000, 2.616500], [1.055000, 1.275000, 3.297000] ])
basis_atoms = locals()[basis_type]
bravis_lattice = []
for i in range(num_x_trans):
for j in range(num_y_trans):
for k in range(num_z_trans):
for l in range(len(basis_atoms)):
bravis_lattice.append(i * a1 + j * a2 + k * a3 +
basis_atoms[l])
filename = 'xred.dat'
outputFile = open(filename, 'w')
for triple in bravis_lattice:
xcart = a / float(num_x_trans) * (triple[0])
ycart = a / float(num_y_trans) * (triple[1])
zcart = a / float(num_z_trans) * (triple[2])
outputFile.write(' % .8f' % xcart + ' % .8f' % ycart +
' % .8f' % zcart + '\n')
outputFile.close()
#!/usr/bin/python2.3
import caca
import math
from random import Random
from math import *
import Numeric as N
ret = caca.init()
r = N.zeros(256)
g = N.zeros(256)
b = N.zeros(256)
a = N.zeros(256)
rand = Random()
# Our pixel array
pixels = N.zeros(32*32*4)
#pixels = pixelst.tolist()
for i in range(0,256):
r[i] = i
g[i] = i
b[i] = i
a[i] = 128
bitmap = caca.create_bitmap(32,32,32,32*4,0x00FF0000, 0x0000FF00, 0x000000FF, 0xFF000000)
#caca.set_bitmap_palette(bitmap, r, g, b, a)
cffile.history = '%s: %s' % (datetime.datetime.today(),
string.join(sys.argv))
num = int(1.1 * options.margin_radius / options.delta + 0.5)
num = 2 * (num - 1) + 1
# creating dimensions
cffile.createDimension('x0', num - 1)
cffile.createDimension('x1', num)
cffile.createDimension('y0', num - 1)
cffile.createDimension('y1', num)
cffile.createDimension('level', 1)
cffile.createDimension('time', None)
#creating variables
delta = options.delta * 1000.
varx = cffile.createVariable('x0')
varx[:] = (delta / 2. + delta * Numeric.arange(num - 1)).astype(
Numeric.Float32)
varx = cffile.createVariable('x1')
varx[:] = (delta * Numeric.arange(num)).astype(Numeric.Float32)
vary = cffile.createVariable('y0')
vary[:] = (delta / 2. + delta * Numeric.arange(num - 1)).astype(
Numeric.Float32)
vary = cffile.createVariable('y1')
vary[:] = (delta * Numeric.arange(num)).astype(Numeric.Float32)
varlevel = cffile.createVariable('level')
varlevel[0] = 1
vartime = cffile.createVariable('time')
vartime[0] = 0
def distance(self, otherAddress):
xor = Numeric.logical_xor(self.address, otherAddress)
sum = reduce(operator.add, xor)
return sum
def _maxwellboltzmanndistribution(masses, temp):
xi = RandomArray.standard_normal(shape=(len(masses), 3))
momenta = xi * Numeric.sqrt(masses * temp)[:, Numeric.NewAxis]
return momenta
import Numeric, os
os.chdir('c:/temp')
data2 = Numeric.array([ [0,54,100], [87,230,5], [161,120,24] ])
data3 = Numeric.array([ [0,100,23], [78,29,1], [134,245,0] ])
print data2
print data3
ndvi = (data3 - data2) / (data3 + data2)
mask = Numeric.greater(data3 + data2, 0)
print mask
ndvi = Numeric.choose(mask, (-99, (data3 - data2) / (data3 + data2)))
data3 = data3.astype(Numeric.Float16)
data2 = data2.astype(Numeric.Float16)
ndvi = Numeric.choose(mask, (-99, (data3 - data2) / (data3 + data2)))
print ndvi
import gdal
from gdalconst import *
driver = gdal.GetDriverByName('HFA')
ds = driver.Create('sample1.img', 3, 3, 1, GDT_Float32)
band = ds.GetRasterBand(1)
band.WriteArray(ndvi, 0, 0)
ds = None
ds = driver.Create('sample2.img', 3, 3, 1, GDT_Float32)
band = ds.GetRasterBand(1)
band.WriteArray(ndvi, 0, 0)
ds = None
ds = driver.Create('sample3.img', 3, 3, 1, GDT_Float32)
band = ds.GetRasterBand(1)
band.WriteArray(ndvi, 0, 0)
band.FlushCache()
band.SetNoDataValue(-99)
band.GetStatistics(0,1)
