def kalman_filter(b,
V,
Phi,
y,
X,
sigma,
Sigma,
switch = 0,
D = None,
d = None,
G = None,
a = None,
c = None):
r"""
.. math::
:nowrap:
\begin{eqnarray*}
\beta_{t|t-1} = \Phi \: \beta_{t-1|t-1}\\
V_{t|t-1} = \Phi V_{t-1|t-1} \Phi ^T + \Sigma \\
e_t = y_t - X_t \beta_{t|t-1}\\
K_t = V_{t|t-1} X_t^T (\sigma + X_t V_{t|t-1} X_t )^{-1}\\
\beta_{t|t} = \beta_{t|t-1} + K_t e_t\\
V_{t|t} = (I - K_t X_t^T) V_{t|t-1}\\
\end{eqnarray*}
"""
n = scipy.shape(X)[1]
beta = scipy.empty(scipy.shape(X))
n = len(b)
if D is None:
D = scipy.ones((1, n))
if d is None:
d = scipy.matrix(1.)
if G is None:
G = scipy.identity(n)
if a is None:
a = scipy.zeros((n, 1))
if c is None:
c = scipy.ones((n, 1))
# import code; code.interact(local=locals())
(b, V) = kalman_predict(b, V, Phi, Sigma)
for i in xrange(len(X)):
beta[i] = scipy.array(b).T
(b, V, e, K) = kalman_upd(b,
V,
y[i],
X[i],
sigma,
Sigma,
switch,
D,
d,
G,
a,
c)
(b, V) = kalman_predict(b, V, Phi, Sigma)
return beta
def autolim(self, myattr, freqvect, margin=0.1,db=0):
if self.freqlim:
ind1=thresh(freqvect,self.freqlim[0])
ind2=thresh(freqvect,self.freqlim[1])
else:
ind1=0
ind2=-1
mymatrix=getattr(self,myattr)
if len(shape(mymatrix))==1:
submat=mymatrix[ind1:ind2]
else:
mymatrix=colwise(mymatrix)
submat=mymatrix[ind1:ind2,:]
if db:
submat=20*log10(submat)
# max and min need to be done columnwise
# (maybe a Krauss matrix max)
if len(shape(submat))==2:
mymax=[]
mymin=[]
for q in range(shape(submat)[1]):
mymax.append(max(submat[:,q]))
mymin.append(min(submat[:,q]))
else:
mymax=max(submat)
mymin=min(submat)
if len(shape(mymax))>0:
mymax=max(mymax)
mymin=min(mymin)
myspan=mymax-mymin
mymargin=margin*myspan
limout=[mymin-mymargin, mymax+mymargin]
setattr(self,myattr+"lim",limout)
return limout
def results(self):
""" This method computes the results as a dictionary """
result = {}
# here you can either use a perturbed fcc lattice or completely random positions
#positions=self.makeRandomPositions()
positions = self.makePerturbedLattice()
gradE = self.gradE(positions)
force = self.getForce(positions)
result['gradE'] = gradE
result['force'] = force
# what should the error tolerance be on this?
error = abs((gradE+force)/force)
max_error = error.max()
# this is to identify where the max error is
index1 = error.argmax()/scipy.shape(error)[1]
index2 = error.argmax()-scipy.shape(error)[1]*(index1)
if (error > 10**(-8)).any(): # expected error according to numerical recipes
result['Equal'] = False
else:
result['Equal'] = True
result['errors'] = error
result['max error'] = max_error
result['max error location']=scipy.array([index1,index2])
return result
def RREFscaled(mymat):
# Pdb().set_trace()
scalevect=scipy.amax(abs(mymat),1)
scaledrows=[]
for sf,row in zip(scalevect,mymat):
row=row/sf
scaledrows.append(row)
scaledmat=scipy.vstack(scaledrows)
# scaledmat=mymat
nc=scipy.shape(scaledmat)[1]
nr=scipy.shape(scaledmat)[0]
for j in range(nr-1):
# print('=====================')
# print('j='+str(j))
pivrow=scipy.argmax(abs(scaledmat[j:-1,j]))
pivrow=pivrow+j
# print('pivrow='+str(pivrow))
if pivrow!=j:
temprow=copy.copy(scaledmat[j,:])
scaledmat[j,:]=scaledmat[pivrow,:]
scaledmat[pivrow,:]=temprow
# Pdb().set_trace()
for i in range(j+1,nr):
# print('i='+str(i))
scaledmat[i,:]-=scaledmat[j,:]*(scaledmat[i,j]/scaledmat[j,j])
return scaledmat, scalevect
def GetMat(self,s,sym=False):
"""Return the element transfer matrix for the
TorsionalSpringDamper element. If sym=True, 's' must be a
symbolic string and a matrix of strings will be returned.
Otherwise, 's' is a numeric value (probably complex) and the
matrix returned will be complex."""
N=self.maxsize
if sym:
myparams=self.symparams
else:
myparams=self.params
k=myparams['k']
c=myparams['c']
springterm=1/(k[0]+c[0]*s)
if sym:
maxlen=len(springterm)+10
matout=eye(N,dtype='f')
matout=matout.astype('S%d'%maxlen)
else:
matout=eye(N,dtype='D')
matout[1,2]=springterm
if max(shape(k))>1 and self.maxsize>=8:
matout[5,6]=1/(k[1]+c[1]*s)
if max(shape(k))>2 and self.maxsize>=12:
matout[9,10]=1/(k[2]+c[2]*s)
return matout
def num_neighbors(self,pnums,labels=['all']):
r"""
Returns an ndarray containing the number of neigbhor pores for each
element in Pnums
Parameters
----------
pnums : array_like
Pores whose neighbors are to be counted
labels : list of string, optional
The pore labels that should be included in the count
Returns
-------
num_neighbors : 1D array with number of neighbors in each element,
useful for finding the number of neighbors of a certain type
Examples
--------
>>> pn = OpenPNM.Network.TestNet()
>>> Pnum = [0,1]
>>> pn.num_neighbors(Pnum,flatten=False)
array([3, 4], dtype=int8)
>>> pn.num_neighbors(Pnum)
7
"""
#Convert string to list, if necessary
if type(labels) == str: labels = [labels]
#Count number of neighbors
neighborPs = self.find_neighbor_pores(pnums,labels=labels,flatten=False)
num = sp.zeros(sp.shape(neighborPs),dtype=sp.int8)
for i in range(0,sp.shape(num)[0]):
num[i] = sp.size(neighborPs[i])
return num
def full_obs(sys,poles):
"""Full order observer of the system sys
Call:
obs=full_obs(sys,poles)
Parameters
----------
sys : System in State Space form
poles: desired observer poles
Returns
-------
obs: ss
Observer
"""
if isinstance(sys, TransferFunction):
"System must be in state space form"
return
a=mat(sys.A)
b=mat(sys.B)
c=mat(sys.C)
d=mat(sys.D)
poles=mat(poles)
L=place(a.T,c.T,poles)
L=mat(L).T
Ao=a-L*c
Bo=hstack((b-L*d,L))
n=shape(Ao)
m=shape(Bo)
Co=eye(n[0],n[1])
Do=zeros((n[0],m[1]))
obs=ss(Ao,Bo,Co,Do,sys.Tsamp)
return obs
def _update_network(network, net):
# Infer Np and Nt from length of given prop arrays in file
for element in ['pore', 'throat']:
N = [_sp.shape(net[i])[0] for i in net.keys() if i.startswith(element)]
if N:
N = _sp.array(N)
if _sp.all(N == N[0]):
if (network._count(element) == N[0]) \
or (network._count(element) == 0):
network.update({element+'.all': _sp.ones((N[0],),
dtype=bool)})
net.pop(element+'.all', None)
else:
raise Exception('Length of '+element+' data in file ' +
'does not match network')
else:
raise Exception(element+' data in file have inconsistent ' +
'lengths')
# Add data on dummy net to actual network
for item in net.keys():
# Try to infer array types and change if necessary
# Chcek for booleans disguised and 1's and 0's
num0s = _sp.sum(net[item] == 0)
num1s = _sp.sum(net[item] == 1)
if (num1s + num0s) == _sp.shape(net[item])[0]:
net[item] = net[item].astype(bool)
# Write data to network object
if item not in network:
network.update({item: net[item]})
else:
logger.warning('\''+item+'\' already present')
return network
def convertToTimeAndFrequencyData(self, grain, target):
d = self.sample_duration
length = max(sp.shape(sp.arange(1, sp.size(target) - sp.size(self.gabor[1]), d)))
scale = sp.zeros((88, length))
datacapsule = sp.zeros((sp.shape(self.gabor)[1], grain))
# 行列を束ねて処理
# 個々にgabor*datadataを計算すると時間がかかる
# 一気にdatadataを束ねるとメモリ消費量が半端ない
# よってdatadataに定義された数だけ束ねて処理
m = 0
datasize = sp.size(target) - sp.size(self.gabor[1])
for k in sp.arange(1, datasize+1, d*grain):
capsule_pointer = 0
endl = k+d*grain
if endl > datasize:
endl = k + datasize%(d*grain)
for l in sp.arange(k, endl, d):
datadata = target[l:l+sp.size(self.gabor[1])]
datacapsule[:, capsule_pointer] = datadata
capsule_pointer += 1
try:
scale[:, m:m+grain] = sp.absolute(
sp.dot(self.gabor,datacapsule[:, :capsule_pointer]))
except ValueError:
pass
m += grain
self.time_freq = scale
def dsimul(sys,u):
"""Simulate the discrete system sys
Only for discrete systems!!!
Call:
y=dsimul(sys,u)
Parameters
----------
sys : Discrete System in State Space form
u : input vector
Returns
-------
y: ndarray
Simulation results
"""
a=mat(sys.A)
b=mat(sys.B)
c=mat(sys.C)
d=mat(sys.D)
nx=shape(a)[0]
ns=shape(u)[1]
xk=zeros((nx,1))
for i in arange(0,ns):
uk=u[:,i]
xk_1=a*xk+b*uk
yk=c*xk+d*uk
xk=xk_1
if i==0:
y=yk
else:
y=hstack((y,yk))
y=array(y).T
return y
def _generate_pores(self):
r"""
Generate the pores (coordinates, numbering and types)
"""
self._logger.info("generate_pores: Create specified number of pores")
#Find non-zero elements in image
template = self._template
Np = np.sum(template > 0)
#Add pores to data and ifo
pind = np.arange(0, Np)
self.set_pore_info(label='all', locations=pind)
self.set_pore_data(prop='numbering', data=pind) # Remove eventually
img_ind = np.ravel_multi_index(sp.nonzero(template), dims=sp.shape(template), order='F')
self.set_pore_data(prop='voxel_index', data=img_ind)
#This voxel_to_pore map is messy but works
temp = sp.prod(sp.shape(template))*sp.ones(np.prod(sp.shape(template),),dtype=sp.int32)
temp[img_ind] = pind
self._voxel_to_pore_map = temp
coords = self._Lc*(0.5 + np.transpose(np.nonzero(template)))
self.set_pore_data(prop='coords', data=coords)
self._logger.debug("generate_pores: End of method")
def getHDF5Description(self):
u_shape = scipy.shape(self.u)
lambd_shape = scipy.shape(self.lambd)
class SystemSave(tables.IsDescription):
u = tables.FloatCol(shape = u_shape)
lambd = tables.FloatCol(shape = lambd_shape)
return SystemSave
def PhaseMassageFilter(phin, N=2, Wn=0.1, jump=250,freqvect=[],chkind=0, fig=None):
if fig is None:
from pylab import figure
fig = figure(fi)
phun=colwise(phin)
phout=zeros(shape(phun),'d')#+0.0j
(b,a)=scipy.signal.butter(N,Wn)
phfilt=scipy.signal.lfilter(b,a,phun,axis=0)
for i in range(shape(phout)[1]):
pherr=phun[:,i]-phfilt[:,i]
phcor=map(pherrcomp,pherr)
phout[:,i]=phun[:,i]+phcor
if freqvect and i==chkind:
fig.clear()
ax1 = fig.add_subplot(2, 1, 1)
ax1.semilogx(freqvect,phun[:,chkind])
ax1.semilogx(freqvect,phfilt[:,chkind])
ax1.semilogx(freqvect,phout[:,chkind])
ax1.legend(['un','filt','out'],3)
ax2 = fig.add_subplot(2, 1, 2)
ax2.semilogx(freqvect,pherr)
ax2.semilogx(freqvect,phcor)
ax2.legend(['err','cor'],3)
return phout
def __init__(self, params={}, **kwargs):
"""Initialize the AVSwThetaFB instance. params should have
the following keys:
'ks' - spring constant (required)
'c' - damper coeffiecent (defaults to 0)
'Ka' - actuator gain (defaults to 1)
'Gc' - proportional feedback gain (defaults to 1)
(Gc can be a transfer function modelled as a
ratio of polynomials when passed to FORTRAN.)
'axis' - axis about which the actuator rotates (defaults to 1)
'tau' - first order pole of actuator."""
if not params.has_key("Ka"):
params["Ka"] = 1
if not params.has_key("axis"):
params["axis"] = 1
if not params.has_key("c"):
params["c"] = 0
if not params.has_key("Gc"):
params["Gc"] = 1
if shape(params["Ka"]):
params["Ka"] = params["Ka"][0]
if params.has_key("tau"):
if shape(params["tau"]):
params["tau"] = params["tau"][0]
TMMElementIHT.__init__(self, "avsthfb", params, **kwargs)
def minreal(sys):
"""Minimal representation for state space systems
Usage
=====
[sysmin]=minreal[sys]
Inputs
------
sys: system in ss or tf form
Outputs
-------
sysfin: system in state space form
"""
a=mat(sys.A)
b=mat(sys.B)
c=mat(sys.C)
d=mat(sys.D)
nx=shape(a)[0]
ni=shape(b)[1]
no=shape(c)[0]
out=tb03ad(nx,no,ni,a,b,c,d,'R')
nr=out[3]
A=out[0][:nr,:nr]
B=out[1][:nr,:ni]
C=out[2][:no,:nr]
sysf=ss(A,B,C,sys.D,sys.Tsamp)
return sysf
def check_if_click_is_on_an_existing_point(mouse_x_coord,mouse_y_coord):
# First, figure out how many points we have.
# Each point is one row in the coords_array,
# so we count the number of rows, which is dimension-0 for Python
number_of_points = scipy.shape(coords_array)[0]
this_coord = scipy.array([[ mouse_x_coord, mouse_y_coord ]])
# The double square brackets above give the this_coord array
# an explicit structure of having rows and also columns
if number_of_points > 0:
# If there are some points, we want to calculate the distance
# of the new mouse-click location from every existing point.
# One way to do this is to make an array which is the same size
# as coords_array, and which contains the mouse x,y-coords on every row.
# Then we can subtract that xy_coord_matchng_matrix from coords_array
ones_vec = scipy.ones((number_of_points,1))
xy_coord_matching_matrix = scipy.dot(ones_vec,this_coord)
distances_from_existing_points = (coords_array - xy_coord_matching_matrix)
squared_distances_from_existing_points = distances_from_existing_points**2
sum_sq_dists = scipy.sum(squared_distances_from_existing_points,axis=1)
# The axis=1 means "sum over dimension 1", which is columns for Python
euclidean_dists = scipy.sqrt(sum_sq_dists)
distance_threshold = 0.5
within_threshold_points = scipy.nonzero(euclidean_dists < distance_threshold )
num_within_threshold_points = scipy.shape(within_threshold_points)[1]
if num_within_threshold_points > 0:
# We only want one matching point.
# It's possible that more than one might be within threshold.
# So, we take the unique smallest distance
point_to_be_deleted = scipy.argmin(euclidean_dists)
return point_to_be_deleted
else: # If there are zero points, then we are not deleting any
point_to_be_deleted = -1
return point_to_be_deleted
def nonna_lsq(target, aux, idx=(), names=(), order=2):
"""
This function returns the coefficients of the least square prediction of the target
signal, using the auxiliary signals and their powers, as specified by the order argument.
Input arguments:
target = target signal
aux = matrix of auxiliary signals
idx = boolean vector to select a subset of the data for the LSQ fit
order = order of the polynomial of aux signals to be used in the fit, default is 2
names = list of the auxiliary signal names
Output:
p = list of coefficients
X = matrix of the signals used in the reconstruction
cnames = list of the corresponding signals
Note that the mean will be removed from the auxiliary signals.
"""
# number of auxiliary channels
naux = scipy.shape(aux[1])
if len(names) == 0:
# since the user didn't provide signal names, let's build some
names = map(lambda x: 'S'+str(x), scipy.arange(naux)+1)
if len(idx) == 0:
# no index means use all
idx = numpy.array(target, dtype=bool)
idx[:] = True
##### PREPARE CHANNELS FOR LSQ PREDICTION
# prepare channels and their squared values
X = scipy.zeros((scipy.shape(aux)[0], order*scipy.shape(aux)[1]+1))
cnames = []
for i in range(scipy.shape(aux)[1]):
for j in range(order):
# add the (j+1)th power of the signal after removing the mean
X[:,order*i+j] = numpy.power((aux[:,i] - scipy.mean(aux[idx,i])), j+1)
# then remove the mean of the result
X[:,order*i+j] = X[:,order*i+j] - scipy.mean(X[idx,order*i+j])
# save the name, including the power
if j==0:
cnames.append(names[i])
else:
cnames.append(names[i]+'^'+str(j+1))
# add a constant at the end of the list
X[:,-1] = 1
cnames.append('1')
# convert to matrix object for simpler manipulation
X = scipy.mat(X)
##### best estimate of coefficients to minimize the squared error
p = scipy.linalg.inv(X[idx,:].T * X[idx,:]) * X[idx,:].T * scipy.mat(target[idx]).T
# return all the results
return p, X, cnames
def __init__(self, U, Y, statedim, reg=None):
if size(shape(U)) == 1:
U = reshape(U, (-1,1))
if size(shape(Y)) == 1:
Y = reshape(Y, (-1,1))
if reg is None:
reg = 0
yDim = size(Y,1)
uDim = size(U,1)
self.output_size = size(Y,1) # placeholder
# number of samples of past/future we'll mash together into a 'state'
width = 1
# total number of past/future pairings we get as a result
K = size(U,0) - 2 * width + 1
# build hankel matrices containing pasts and futures
U_p = array([ravel(U[t : t + width]) for t in range(K)]).T
U_f = array([ravel(U[t + width : t + 2 * width]) for t in range(K)]).T
Y_p = array([ravel(Y[t : t + width]) for t in range(K)]).T
Y_f = array([ravel(Y[t + width : t + 2 * width]) for t in range(K)]).T
# solve the eigenvalue problem
YfUfT = dot(Y_f, U_f.T)
YfUpT = dot(Y_f, U_p.T)
YfYpT = dot(Y_f, Y_p.T)
UfUpT = dot(U_f, U_p.T)
UfYpT = dot(U_f, Y_p.T)
UpYpT = dot(U_p, Y_p.T)
F = bmat([[None, YfUfT, YfUpT, YfYpT],
[YfUfT.T, None, UfUpT, UfYpT],
[YfUpT.T, UfUpT.T, None, UpYpT],
[YfYpT.T, UfYpT.T, UpYpT.T, None]])
Ginv = bmat([[pinv(dot(Y_f,Y_f.T)), None, None, None],
[None, pinv(dot(U_f,U_f.T)), None, None],
[None, None, pinv(dot(U_p,U_p.T)), None],
[None, None, None, pinv(dot(Y_p,Y_p.T))]])
F = F - eye(size(F, 0)) * reg
# Take smallest eigenvalues
_, W = eigs(Ginv.dot(F), k=statedim, which='SR')
# State sequence is a weighted combination of the past
W_U_p = W[ width * (yDim + uDim) : width * (yDim + uDim + uDim), :]
W_Y_p = W[ width * (yDim + uDim + uDim):, :]
X_hist = dot(W_U_p.T, U_p) + dot(W_Y_p.T, Y_p)
# Regress; trim inputs to match the states we retrieved
R = concatenate((X_hist[:, :-1], U[width:-width].T), 0)
L = concatenate((X_hist[:, 1: ], Y[width:-width].T), 0)
RRi = pinv(dot(R, R.T))
RL = dot(R, L.T)
Sys = dot(RRi, RL).T
self.A = Sys[:statedim, :statedim]
self.B = Sys[:statedim, statedim:]
self.C = Sys[statedim:, :statedim]
self.D = Sys[statedim:, statedim:]
def __init__(self, x, y, axis=-1, makecopy=0, bounds_error=1,
fill_value=None):
"""Initialize a piecewise-constant interpolation class
Description:
x and y are arrays of values used to approximate some function f:
y = f(x)
This class returns a function whose call method uses piecewise-
constant interpolation to find the value of new points.
Inputs:
x -- a 1d array of monotonically increasing real values.
x cannot include duplicate values. (otherwise f is
overspecified)
y -- an nd array of real values. y's length along the
interpolation axis must be equal to the length
of x.
axis -- specifies the axis of y along which to
interpolate. Interpolation defaults to the last
axis of y. (default: -1)
makecopy -- If 1, the class makes internal copies of x and y.
If 0, references to x and y are used. The default
is to copy. (default: 0)
bounds_error -- If 1, an error is thrown any time interpolation
is attempted on a value outside of the range
of x (where extrapolation is necessary).
If 0, out of bounds values are assigned the
NaN (#INF) value. By default, an error is
raised, although this is prone to change.
(default: 1)
"""
self.datapoints = (array(x, Float), array(y, Float)) # RHC -- for access from PyDSTool
self.type = Float # RHC -- for access from PyDSTool
self.axis = axis
self.makecopy = makecopy # RHC -- renamed from copy to avoid nameclash
self.bounds_error = bounds_error
if fill_value is None:
self.fill_value = NaN # RHC -- was: array(0.0) / array(0.0)
else:
self.fill_value = fill_value
# Check that both x and y are at least 1 dimensional.
if len(shape(x)) == 0 or len(shape(y)) == 0:
raise ValueError, "x and y arrays must have at least one dimension."
# make a "view" of the y array that is rotated to the
# interpolation axis.
oriented_x = x
oriented_y = swapaxes(y,self.interp_axis,axis)
interp_axis = self.interp_axis
len_x,len_y = shape(oriented_x)[interp_axis], \
shape(oriented_y)[interp_axis]
if len_x != len_y:
raise ValueError, "x and y arrays must be equal in length along "\
"interpolation axis."
if len_x < 2 or len_y < 2:
raise ValueError, "x and y arrays must have more than 1 entry"
self.x = array(oriented_x,copy=self.makecopy)
self.y = array(oriented_y,copy=self.makecopy)
def test_save_and_load_networkx_no_phases(self):
G = op.io.NetworkX.to_networkx(network=self.net)
project = op.io.NetworkX.from_networkx(G)
assert len(project) == 1
net = project.network
assert net.Np == 8
assert net.Nt == 12
assert sp.shape(net['pore.coords']) == (8, 3)
assert sp.shape(net['throat.conns']) == (12, 2)
def test_load_networkx(self):
fname = os.path.join(FIXTURE_DIR, 'test_load_yaml.yaml')
net = io.NetworkX.load(filename=fname)
assert net.Np == 9
assert net.Nt == 12
assert sp.shape(net['pore.coords']) == (9, 3)
assert sp.shape(net['throat.conns']) == (12, 2)
a = {'pore.area', 'pore.diameter', 'throat.length', 'throat.perimeter'}
assert a.issubset(net.props())
def test_save_and_load_csv_no_phases(self):
fname = os.path.join(TEMP_DIR, 'test_save_csv_1')
io.CSV.save(network=self.net, filename=fname)
assert os.path.isfile(fname+'.csv')
net = io.CSV.load(fname+'.csv')
assert net.Np == 27
assert net.Nt == 54
assert sp.shape(net['pore.coords']) == (27, 3)
assert sp.shape(net['throat.conns']) == (54, 2)
def augment_3_vector(v=array([0.0, 0.0, 0.0]), free=False):
if free:
freeval = 0.0
else:
freeval = 1.0
assert shape(v) == (3,), "v argument must be 3-vector -- found " + str(shape(v))
vaug = resize(v, (4,))
vaug[3] = freeval
return vaug
def update_graph(self):
"""Updates the graph with new X and Y"""
# TODO: rewrite this routine, to get better performance
# self.background = \
# self.ui.mpl.canvas.ax.figure.canvas.copy_from_bbox(self.ui.mpl.canvas.ax.bbox)
# save current plot variables
if self.autoscale:
self.Rescale()
if self.background != None:
# save initial x and y limits
self.xl = self.ui.mpl.canvas.ax.get_xlim()
self.yl = self.ui.mpl.canvas.ax.get_ylim()
# clear the axes
self.ui.mpl.canvas.ax.clear()
# plot graph
self.pltdata, = self.ui.mpl.canvas.ax.plot(
self.tdata[:, 0], self.tdata[:, 1], self.color + "o", markersize=self.ui.mplhorizontalSlider.value()
)
if not hasattr(self, "line"):
# creating line
self.line, = self.ui.mpl.canvas.ax.plot([0, 0], [0, 0], "r--", animated=True)
if not hasattr(self.ui, "rectab"):
# creating rectangle
self.rectab, = self.ui.mpl.canvas.ax.plot([0, 0], [0, 0], "r--", animated=True)
self.rectbc, = self.ui.mpl.canvas.ax.plot([0, 0], [0, 0], "r--", animated=True)
self.rectcd, = self.ui.mpl.canvas.ax.plot([0, 0], [0, 0], "r--", animated=True)
self.rectda, = self.ui.mpl.canvas.ax.plot([0, 0], [0, 0], "r--", animated=True)
# TODO: create a circle
# enable grid
self.ui.mpl.canvas.ax.grid(True)
if self.background != None:
# set x and y limits
self.ui.mpl.canvas.ax.set_xlim(self.xl)
self.ui.mpl.canvas.ax.set_ylim(self.yl)
self.set_x_log(self.ui.xLogScale.isChecked(), redraw=False)
self.set_y_log(self.ui.yLogScale.isChecked(), redraw=False)
# force an image redraw
self.ui.mpl.canvas.draw()
# copy background
self.background = self.ui.mpl.canvas.ax.figure.canvas.copy_from_bbox(self.ui.mpl.canvas.ax.bbox)
# make edit buttons enabled
self.ui.mplactionCut_by_line.setEnabled(self.background != None)
self.ui.mplactionCut_by_rect.setEnabled(self.background != None)
if np.shape(self.tdata) != self.tempShape:
self.tempShape = np.shape(self.tdata)
self.data_signal.emit()
def makeSquare(image): '''For images that aren't square, this funtion will identify the closest power of 2 to the smaller dimension and decide whether to crop or pad. If it needs to be padded, this is done in harris.hs''' dim = min(sp.shape(image)[0],sp.shape(image)[1]) potential_crop = int(2**math.floor(math.log(dim,2))) if potential_crop**2 >= 0.9*sp.shape(image)[0]*sp.shape(image)[1]: return sp.misc.imresize(image,(potential_crop,potential_crop)) return image
def generateScore(self, target, cut_num):
fs = self.time_freq_fs = sp.shape(target)[1] / self.duration
noise_length = 60. / self.wavetempo * fs
working = sp.copy(target)
score = []
while(sp.shape(working)[1] > noise_length):
cutted, working = self.cutOutToChangingPoint(working)
note = self.extractNote(cutted, cut_num)
score.append(note)
return score
def test_save_load_vtk_no_phases(self):
fname = os.path.join(TEMP_DIR, 'test_save_vtk_1')
io.VTK.save(network=self.net, filename=fname, legacy=True)
assert os.path.isfile(fname+'.vtp')
net = io.VTK.load(fname+'.vtp')
assert net.Np == 27
assert net.Nt == 54
assert sp.shape(net['pore.coords']) == (27, 3)
assert sp.shape(net['throat.conns']) == (54, 2)
assert 'pore.'+self.net.name+'_diameter' in net.keys()
def prob_opt(data):
k = sp.shape(data)[0]
n = sp.shape(data)[1]
max_arm = sp.argmax(data, axis=1)
prob = sp.zeros(n)
for i in xrange(0, n):
this_max = max_arm == i
prob[i] = this_max.sum() / float(k)
return prob
def RenormalizeFactor(excfile,gsfile,channel=None,Nsamp=1,O=None,q=None):
if not type(excfile)==list:
excfile=[excfile]
if not type(gsfile)==list:
gsfile=[gsfile]
exat=GetAttr(excfile[0])
gsat=GetAttr(gsfile[0])
L=exat['L']
if q==None:
q=sc.array([exat['qx'],exat['qy']])
if 'phasex' in exat.keys():
shift=sc.array([exat['phasex']/2.0,exat['phasey']/2.0])
else:
shift=sc.array([exat['phase_shift_x']/2.0,exat['phase_shift_y']/2.0])
phi=exat['phi']
neel=exat['neel']
qx,qy,Sq=GetSq(gsfile)
kx,ky=sf.fermisea(L,L,shift)
qidx=ml.find((qx==q[0])*(qy==q[1]))
if O==None:
_,O,_,_=GetEigSys(excfile,Nsamp)
pk=None
sqq=None
if channel==None:
channel=exat['channel']
if channel=='trans':
pk=sc.squeeze(sf.phiktrans(kx,ky,q[0]/L,q[1]/L,[phi,neel]))
sqq=sc.real(0.5*(Sq[0,1,qidx]+Sq[0,2,qidx]))
elif channel=='long':
pkup=sc.squeeze(sf.phiklong(kx,ky,q[0]/L,q[1]/L,1,[phi,neel]))
pkdo=sc.squeeze(sf.phiklong(kx,ky,q[0]/L,q[1]/L,-1,[phi,neel]))
if (q[0]/L==0.5 and q[1]/L==0.5) or (q[0]/L==0 and q[1]/L==0):
pk=sc.zeros(2*sc.shape(pkup)[0]+1,complex)
else:
pk=sc.zeros(2*sc.shape(pkup)[0],complex)
pk[0:2*sc.shape(pkup)[0]:2]=pkup
pk[1:2*sc.shape(pkdo)[0]:2]=pkdo
if (qx[0]/L==0.5 and q[1]/L==0.5) or (q[0]/L==0 and q[1]/L==0):
if neel==0:
pk[-1]=0
else:
pk[-1]=sum(neel/sf.omega(kx,ky,[phi,neel]))
sqq=Sq[0,0,qidx]
else:
raise(InputFileError('In file \''+excfile+'\', channel=\''+str(channel)+'\'. Should be \'trans\' or \'long\''))
sqe=sc.einsum('i,jik,k->j',sc.conj(pk),O,pk)
out=sc.zeros(Nsamp)
for n in range(Nsamp):
if abs(sqq)<1e-6 or abs(sqe[n])<1e-6:
warnings.warn('Probably ill-defined renormalization, returns 1 for sample {0} out of {1}'.format(n,Nsamp),UserWarning)
out[n]=1
else:
out[n]=sc.real(sqq/sqe[n])
return out
def test_save_and_load_csv_w_phases(self):
fname = os.path.join(TEMP_DIR, 'test_save_csv_2')
io.CSV.save(network=self.net, filename=fname, phases=self.phase)
assert os.path.isfile(fname+'.csv')
net = io.CSV.load(fname+'.csv')
assert net.Np == 27
assert net.Nt == 54
assert sp.shape(net['pore.coords']) == (27, 3)
assert sp.shape(net['throat.conns']) == (54, 2)
assert [True for item in net.keys() if 'temperature' in item]
assert [True for item in net.keys() if 'diffusive_conductance' in item]
def add_periodic_connections(self, pores1, pores2, apply_label='periodic'):
r"""
Accepts two sets of pores and connects them with new throats. The
connections are determined by pairing each pore in ``pores1`` with its
nearest pore in ``pores2``. For cubic Networks this will create
pairings with pores directly across the domain from each other,
assuming the input pores are 2D co-planar sets of pores.
Parameters
----------
pores_1 and pores_2 : array_like
Lists of pores on the opposing faces which are to be linked to
create periodicity.
apply_label = string
The label to apply to the newly created throats. The default is
'periodic'.
Notes
-----
This method will raise an exception if the input pores do not create
fully unique pairs. Specifically, the length of pore_1 and pores_2
must be the same AND each pore in pores_1 must pair up with one and
only one pore in pores_2, and vice versa. If these conditions are
not met then periodicity cannot be acheived, and an exception is
raised.
"""
logger.debug('Creating periodic pores')
if sp.shape(pores1)[0] != sp.shape(pores2)[0]:
raise Exception('Unequal length inputs, periodicity not possible')
p1 = self['pore.coords'][pores1]
p2 = self['pore.coords'][pores2]
dist_mat = sptl.distance_matrix(p1, p2)
dist_min = sp.amin(dist_mat, axis=1, keepdims=True)
[a, b] = sp.where(dist_mat == dist_min)
pairs = sp.vstack([pores1[a], pores2[b]]).T
# Confirm that each pore in each list is only paired up once
temp_1 = sp.unique(pairs[:, 0])
if sp.shape(temp_1) < sp.shape(pores1):
raise Exception('Non-unique pairs found, periodicity not met')
temp_2 = sp.unique(pairs[:, 1])
if sp.shape(temp_2) < sp.shape(pores2):
raise Exception('Non-unique pairs found, periodicity not met')
# Add throats to the network for the periodic connections
self.extend(throat_conns=pairs, labels=apply_label)
# Create a list which pores are connected which
self['pore.periodic_neighbor'] = sp.nan
self['pore.periodic_neighbor'][pairs[:, 0]] = pairs[:, 1]
self['pore.periodic_neighbor'][pairs[:, 1]] = pairs[:, 0]
logger.info('Periodic boundary pores added successfully')
def gaussians(x, x0, A, sig):
#if sc.amax(abs(sc.imag(A)))/sc.amax(abs(sc.real(A)))>0.01:
# warnings.warn(\
#'Gaussian amplitude has a sizable imaginary part\(max(|Im|)/max(|Re|)={0}, mean(abs(A))={1}).'\
# .format(sc.amax(abs(sc.imag(A)))/sc.amax(abs(sc.real(A))), sc.mean(abs(A))))
x0 = sc.atleast_1d(x0)
A = sc.atleast_1d(A)
sig = sc.atleast_1d(sig)
amp = A * sc.sqrt(1 / 2.0 / sc.pi) / sig
[X, X0] = sc.meshgrid(x, x0)
gg = None
#if len(sc.shape(amp))==1:
# gg=sc.einsum('i,ij',amp,sc.exp(-0.5*(X-X0)**2/sc.tile(sig**2,(sc.shape(x)[0],1)).T))
#elif len(sc.shape(amp))==2:
# gg=sc.einsum('ij,jk',amp,sc.exp(-0.5*(X-X0)**2/sc.tile(sig**2,(sc.shape(x)[0],1)).T))
gg = sc.einsum(
'...i,...ij->...j', amp,
sc.exp(-0.5 * (X - X0)**2 / sc.tile(sig**2, (sc.shape(x)[0], 1)).T))
return gg
def __init__(self,
edgelist_fname,
directed,
write_label_file=True,
columns=(0, 1, 2),
firsttime=None,
lasttime=None):
list.__init__(self)
self.first_day = firsttime
self.last_day = lasttime
self.fname = edgelist_fname
self.cols = columns
self.label_file = write_label_file
self.is_directed = directed
self.matricesCreation()
if not self.is_directed:
self.as_undirected()
self.number_of_nodes = scipy.shape(self[0])[0]
def find_connected_pores(self, throats=[], flatten=False):
r"""
Return a list of pores connected to the given list of throats
Parameters
----------
throats : array_like
List of throats numbers
flatten : boolean, optional
If flatten is True (default) a 1D array of unique pore numbers
is returned. If flatten is False each location in the the returned
array contains a sub-arras of neighboring pores for each input
throat, in the order they were sent.
Returns
-------
1D array (if flatten is True) or ndarray of arrays (if flatten is False)
Examples
--------
>>> import OpenPNM
>>> pn = OpenPNM.Network.TestNet()
>>> pn.find_connected_pores(throats=[0,1])
array([[0, 1],
[0, 5]])
>>> pn.find_connected_pores(throats=[0,1], flatten=True)
array([0, 1, 5])
Notes
-----
This method basically just looks into the pn['throat.conns'] array and
retrieves the pores for each input throat. The flatten option merely
stacks the two columns and eliminate non-unique values.
"""
Ts = self._parse_locations(throats)
Ps = self['throat.conns'][Ts]
if flatten:
if sp.shape(Ps) == (0, 2):
Ps = sp.array([], ndmin=1, dtype=int)
else:
Ps = sp.unique(sp.hstack(Ps))
return Ps
def calculate_W_out(self, Y_target, N_x, beta, train_start_timestep,
train_end_timestep):
# see Lukosevicius Practical ESN eqtn 11
# Using ridge regression
N_u = sp.shape(Y_target)[0]
X = sp.vstack(
(sp.ones((1, train_end_timestep - train_start_timestep)),
Y_target[:, train_start_timestep:train_end_timestep],
self.x[train_start_timestep:train_end_timestep].transpose()))
# Ridge Regression
W_out = sp.matmul(
sp.array(Y_target[:, train_start_timestep + 1:train_end_timestep +
1]),
sp.matmul(
X.transpose(),
sp.linalg.inv(
sp.matmul(X, X.transpose()) +
beta * sp.identity(1 + N_x + N_u))))
self.W_out = W_out
def __setitem__(self, prop, value):
if prop == 'throat.conns':
if sp.shape(value)[1] != 2:
logger.error('Wrong size for throat conns!')
else:
mask = value[:, 0] > value[:, 1]
if mask.any():
logger.debug('The first column in (throat.conns) should be \
smaller than the second one.')
v1 = sp.copy(value[:, 0][mask])
v2 = sp.copy(value[:, 1][mask])
value[:, 0][mask] = v2
value[:, 1][mask] = v1
for geom in self._geometries:
if (prop in list(geom.keys())) and ('all' not in prop.split('.')):
logger.error(prop + ' is already defined in at least one associated \
Geometry object')
return
super().__setitem__(prop, value)
def populations_plot(times, density_m, location):
"""
Plot the populations of each state versus time in separate files.
:param times: The times over which to plot the populations in microseconds.
:param density_m: The density matrix at each time step.
:param location: Directory where plots will be saved.
:return: None.
"""
for i in range(sp.shape(density_m)[1]):
fig, ax = plt.subplots(nrows=1, ncols=1)
ax.plot(times, abs(density_m[:, i, i]))
ax.set_title(r"Population of State " + str(i + 1) + " v. Time")
ax.set_xlabel(r"Time ($\mu$s)")
ax.set_ylabel(r"$|\rho_{" + str(i + 1) + str(i + 1) + "}|$")
ax.axhline(0, color='black')
plt.savefig(location + "/State " + str(i + 1) + " population.png")
plt.close()
return None
def laplacian(self):
"""Computes hypergraph laplacian
Delta=I-Theta,
Theta=Dv^-1/2 H W De^-1 H^T Dv^-1/2
Returns
-------
Delta: sparse matrix
hypergraph laplacian
"""
with Timer() as t_l:
Theta = self.theta_matrix()
Delta = spsp.eye(*sp.shape(Theta)) - Theta
self.laplacian_timer = t_l.secs
return Delta
def _func(self,x,y):
if shape(x)==():
x=array([x])
if self._log_log_interp is True:
x=np.log10(x)
y=np.log10(y)
model = self.interp_func(x,y)
#print('-->',x,y,model)
model[model<self._zero]=self._zero
if self._log_log_interp is True:
return np.power(10., model)
else:
pass
return model
def log_func(self,nu_log):
x_shift=getattr(self,self.x_scale)
y_shift=getattr(self,self.y_scale)
if shape(nu_log)==():
nu=array([nu_log])
x_log=nu_log-x_shift
model=ones(x_log.size)*-20.0
msk = x_log >self.nu_template.min()
msk*= x_log <self.nu_template.max()
model[msk] = self.interp_func(x_log[msk])+y_shift
return model
def genEdgeCompMat(connComp, rows):
numComps = sp.shape(connComp)[0]
edgeCompMat = sp.zeros((numComps, 16))
for i in xrange(numComps):
comp = connComp[i].astype(sp.int32)
r = comp % rows
c = comp / rows + 1
r[r == 0] = rows
subs = sp.concatenate((r, c), axis=1) - 1
r_cmin, cmin = subs[sp.argmin(c), :]
rmin, c_rmin = subs[sp.argmin(r), :]
r_cmax, cmax = subs[sp.argmax(c), :]
rmax, c_rmax = subs[sp.argmax(r), :]
edgeCompMat[i, :] = [
r_cmin, -r_cmin, rmin, -rmin, r_cmax, -r_cmax, rmax, -rmax, cmin,
-cmin, c_rmin, -c_rmin, cmax, -cmax, c_rmax, -c_rmax
]
return edgeCompMat
def LU(A):
# throw warning flag when the number is too small
# (close to 0)
ok = 1
small = 1e-12
n = scipy.shape(A)[0]
U = copy.copy(A)
L = scipy.identity(n)
for j in range(1, n):
for i in range(j + 1, n + 1):
if abs(U[j - 1, j - 1]) < small:
print("Near-zero pivot!")
ok = 0
break
L[i - 1, j - 1] = U[i - 1, j - 1] / U[j - 1, j - 1]
for k in range(j, n + 1):
U[i - 1,
k - 1] = U[i - 1, k - 1] - L[i - 1, j - 1] * U[j - 1, k - 1]
return L, U, ok
def neighbor(network, geometry, throat_prop='', mode='min', **kwargs):
r"""
Adopt the minimum seed value from the neighboring throats
"""
Ps = geometry.pores()
data = geometry[throat_prop]
neighborTs = network.find_neighbor_throats(pores=Ps,
flatten=False,
mode='intersection')
values = _sp.ones((_sp.shape(Ps)[0], )) * _sp.nan
if mode == 'min':
for pore in Ps:
values[pore] = _sp.amin(data[neighborTs[pore]])
if mode == 'max':
for pore in Ps:
values[pore] = _sp.amax(data[neighborTs[pore]])
if mode == 'mean':
for pore in Ps:
values[pore] = _sp.mean(data[neighborTs[pore]])
return values
def PlotSqw(filename,gsen,Nsamp=1,channel=None,\
fig=None,width=0.1,shift=0,\
V=None,O=None,E=None,S=None,w=None,
gsspinfile=None, wavefile=None):
if type(filename) == str:
filename = [filename]
attrs = GetAttr(filename[0])
L = attrs['L']
q = [float(attrs['qx'] / L), float(attrs['qy']) / L]
if E == None:
H, O, E, V = GetEigSys(filename,
Nsamp=Nsamp,
channel=channel,
gsfile=gsspinfile,
wavefile=wavefile)
if S == None:
S = GetSqAmpl(filename, Nsamp=Nsamp, channel=channel, V=V, O=O)
if len(sc.shape(S)) == 4:
S = S[:, 0, 0, :]
if w == None:
w = sc.arange(-0.5, 6, 0.01)
sqw = sc.zeros((sc.shape(E)[0], sc.shape(w)[0]), dtype=S.dtype)
ax = None
for s in range(sc.shape(sqw)[0]):
idx = ~sc.isnan(E[s, :])
sqw[s] = sf.gaussians(w,
sc.squeeze(E[s, idx]) - gsen * L * L,
sc.squeeze(S[s, idx]),
sc.ones(sc.shape(E[s, idx])) * width)
sqw += shift
if fig is None:
fig = pl.figure()
ax = fig.gca()
else:
ax = fig.gca()
#ax.hold(True)
for s in range(sc.shape(sqw)[0]):
ax.plot(w, sc.real(sqw[s, :]))
ax.plot(E[s, :] - gsen * L * L,
sc.squeeze(S[s, :]) * sc.sqrt(1 / 2.0 / sc.pi) / width, 'o')
if Nsamp != 1:
ax.plot(w, sc.sum(sqw, 0) / sc.shape(sqw)[0], 'k--', linewidth=3)
ax.set_xlim((sc.amin(w), sc.amax(w)))
return fig
def trainLM(dW, W0, E):
"""
Params : ``dW`` means ``dE/dW``, or ``J``\n
``W = Wt`` at current iteration\n
``E = Error`` at current iteration
"""
J = np.reshape(dW, (1, np.size(dW)))
# J = dW.T
W = np.reshape(W0, (np.size(W0), 1))
# W = W0
mu = 1.0
# dW1 = la.pinv(J.T.dot(J) + mu*np.eye(np.size(J.T.dot(J), 0)))
dW1 = la.pinv(J.dot(J.T) + mu)
temp1 = J.T.dot(E)
temp2 = dW1 * temp1
temp3 = W - temp2
W1 = np.reshape(temp3, np.shape(W0))
# W1 = temp3
return W1
def draw_rviz_points(self,
points,
frame='narrow_stereo_optical_frame',
size=.005,
ns='points',
id=0,
duration=20.,
color=[0, 0, 1],
opaque=1.0,
pose_mat=None,
frame_locked=False):
if pose_mat != None:
(pos, quat) = mat_to_pos_and_quat(pose_mat)
marker = self.create_marker(Marker.POINTS, [size, size, size],
frame,
ns,
id,
duration,
color,
opaque,
pos,
quat,
frame_locked=frame_locked)
else:
marker = self.create_marker(Marker.POINTS, [size, size, size],
frame,
ns,
id,
duration,
color,
opaque,
frame_locked=frame_locked)
for point_ind in range(scipy.shape(points)[1]):
new_point = Point()
new_point.x = points[0, point_ind]
new_point.y = points[1, point_ind]
new_point.z = points[2, point_ind]
marker.points.append(new_point)
self.marker_pub.publish(marker)
def normalize2D(data, start=None, end=None, byRow=True):
"""
normalize2D: normalize 2D data
"""
from scipy import mean, std, shape
row, col = shape(data)
if byRow: # normalize by row
if not start:
start = 0
if not end:
end = row
ndata = data[:start]
for d in data[start:end]:
m = mean(d)
scale = std(d)
ndata.append([(i-m)/scale for i in d])
ndata.extend(data[end:])
else: # normalize by column
if not start:
start = 0
if not end:
end = col
ndata = []
m = [0 for i in range(col)]
scale = [1 for i in range(col)]
for i in range(start, end):
tmp = [d[i] for d in data]
m[i] = mean(tmp)
scale[i] = std(tmp)
for d in data:
nd = []
for i in range(col):
nd.append((d[i]-m[i])/scale[i])
ndata.append(nd)
return ndata
def remove_outliers(self, points):
points_filtered = points[:]
empty_space_width = .02
check_percent = .02
edge_width = .005
#remove outliers in each dimension (x,y,z)
for dim in range(3):
#sort the points by their values in that dimension
num_points = scipy.shape(points_filtered)[1]
points_sorted = points_filtered[:, points_filtered[dim, :].argsort().tolist()[0]]
#chop off the top points if they are more than empty_space_width away from the bounding box edge
ind = int(math.floor(num_points*(1-check_percent)))
if points_sorted[dim, -1] - points_sorted[dim, ind] > empty_space_width:
#find the first point that isn't within edge_width of the point at ind, and lop off all points after
searcharr = scipy.array(points_sorted[dim, :]).flatten()
searchval = points_sorted[dim, ind] + edge_width
thres_ind = scipy.searchsorted(searcharr, searchval)
if thres_ind != 0 and thres_ind != len(searcharr):
points_filtered = points_sorted[:, 0:thres_ind]
rospy.loginfo("chopped points off of dim %d, highest val = %5.3f, searchval = %5.3f"%(dim, points_sorted[dim, -1], searchval))
else:
points_filtered = points_sorted
#do both sides for x and y
if dim != 2:
ind = int(math.floor(num_points*check_percent))
if points_filtered[dim, ind] - points_filtered[dim, 0] > empty_space_width:
#find the first point that isn't within edge_width of the point at ind, and lop off all points before
searcharr = scipy.array(points_sorted[dim, :]).flatten()
searchval = points_sorted[dim, ind] - edge_width
thres_ind = scipy.searchsorted(searcharr, searchval)
if thres_ind != 0 and thres_ind != len(searcharr):
points_filtered = points_filtered[:, thres_ind:-1]
rospy.loginfo("chopped points off of dim -%d, lowest val = %5.3f, searchval = %5.3f"%(dim, points_sorted[dim, 0], searchval))
return points_filtered
def setBoundaries(u, room):
[i, j] = sc.shape(u)
if room == 2:
u[0, :] = 40
u[-1, :] = 5
#u[0:int(i/2) + 1,0] = 15
#u[int(i/2):,-1] = 15
u[:, 0] = 15 #endast rum 2
u[:, -1] = 15
#hörn
u[0, 0] = (40 + 15) / 2
u[-1, 0] = (5 + 15) / 2
u[-1, -1] = (5 + 15) / 2
u[0, -1] = (40 + 15) / 2
if room == 1:
u[:, 0] = 40
u[0, :] = 15
u[-1, :] = 15
#hörn
u[0, 0] = (40 + 15) / 2
u[-1, 0] = (40 + 15) / 2
def draw_rviz_points(self,
points,
frame='kinect_link',
size=.005,
ns='points',
id=0,
duration=20.,
color=[0, 0, 1],
opaque=1.0):
marker = self.create_marker(Marker.POINTS, [size, size, size], frame,
ns, id, duration, color, opaque)
for point_ind in range(scipy.shape(points)[1]):
new_point = Point()
new_point.x = points[0, point_ind]
new_point.y = points[1, point_ind]
new_point.z = points[2, point_ind]
marker.points.append(new_point)
self.marker_pub.publish(marker)
rospy.loginfo("published points")
def benchmark_rect(n_pts=1000, sz=(1000, 1000)):
"Draws a number of randomly-placed renctangles."
width, height = sz
pts = stats.norm.rvs(size=(n_pts, 2)) * array(sz) / 8. + array(sz) / 2.
print(pts[5, :])
print(shape(pts))
gc = agg.GraphicsContextArray(sz)
gc.set_fill_color((1.0, 0.0, 0.0, 0.1))
gc.set_stroke_color((0.0, 1.0, 0.0, 0.6))
t1 = time.clock()
for x, y in pts:
with gc:
gc.translate_ctm(x, y)
gc.rect(-2.5, -2.5, 5, 5)
gc.draw_path()
t2 = time.clock()
gc.save("benchmark_rect.bmp")
tot_time = t2 - t1
print('rect count, tot,per shape:', n_pts, tot_time, tot_time / n_pts)
return
def plot_porosity_profile(self, fig=None):
r"""
Return a porosity profile in all orthogonal directions by summing
the voxel volumes in consectutive slices.
"""
if hasattr(self, '_fibre_image') is False:
logger.warning(
'This method only works when a fibre image exists, ' +
'please run make_fibre_image')
return
if self._fibre_image is None:
self.make_fibre_image()
l = sp.asarray(sp.shape(self._fibre_image))
px = sp.zeros(l[0])
py = sp.zeros(l[1])
pz = sp.zeros(l[2])
for x in sp.arange(l[0]):
px[x] = sp.sum(self._fibre_image[x, :, :])
px[x] /= sp.size(self._fibre_image[x, :, :])
for y in sp.arange(l[1]):
py[y] = sp.sum(self._fibre_image[:, y, :])
py[y] /= sp.size(self._fibre_image[:, y, :])
for z in sp.arange(l[2]):
pz[z] = sp.sum(self._fibre_image[:, :, z])
pz[z] /= sp.size(self._fibre_image[:, :, z])
if fig is None:
fig = plt.figure()
ax = fig.gca()
plots = []
plots.append(plt.plot(sp.arange(l[0]) / l[0], px, 'r', label='x'))
plots.append(plt.plot(sp.arange(l[1]) / l[1], py, 'g', label='y'))
plots.append(plt.plot(sp.arange(l[2]) / l[2], pz, 'b', label='z'))
plt.xlabel('Normalized Distance')
plt.ylabel('Porosity')
handles, labels = ax.get_legend_handles_labels()
ax.legend(handles, labels, loc=1)
plt.legend(bbox_to_anchor=(1, 1), loc=2, borderaxespad=0.)
return fig
def asarray(self, values):
r'''
Retreive values as a rectangular array, rather than the OpenPNM list format
Parameters
----------
values : array_like
The values from the network (in a list) to insert into the array
Notes
-----
This method can break on networks that have had boundaries added. It
will usually work IF the list of values came only from 'internal' pores.
'''
if sp.shape(values)[0] > self.num_pores('internal'):
raise Exception(
'The received values are bigger than the original network')
Ps = sp.array(self['pore.index'][self.pores('internal')], dtype=int)
arr = sp.ones(self._shape) * sp.nan
ind = sp.unravel_index(Ps, self._shape)
arr[ind[0], ind[1], ind[2]] = values
return arr
def unique_list(input_list):
r"""
For a given list (of points) remove any duplicates
"""
output_list = []
if len(input_list) > 0:
dim = _sp.shape(input_list)[1]
for i in input_list:
match = False
for j in output_list:
if dim == 3:
if i[0] == j[0] and i[1] == j[1] and i[2] == j[2]:
match = True
elif dim == 2:
if i[0] == j[0] and i[1] == j[1]:
match = True
elif dim == 1:
if i[0] == j[0]:
match = True
if match is False:
output_list.append(i)
return output_list
def find_connecting_throat(self,P1,P2):
r"""
Return the throat number connecting pairs of pores
Parameters
----------
P1 , P2 : array_like
The pore numbers whose throats are sought. These can be vectors
of pore numbers, but must be the same length
Returns
-------
Tnum : list of list of int
Returns throat number(s), or empty array if pores are not connected
Examples
--------
>>> import OpenPNM
>>> pn = OpenPNM.Network.TestNet()
>>> pn.find_connecting_throat([0,1,2],[2,2,2])
[[], [3], []]
TODO: This now works on 'vector' inputs, but is not actually vectorized
in the Numpy sense, so could be slow with large P1,P2 inputs
"""
Ts1 = self.find_neighbor_throats(P1,flatten=False)
Ts2 = self.find_neighbor_throats(P2,flatten=False)
Ts = []
if sp.shape(P1) == ():
P1 = [P1]
P2 = [P2]
for row in range(0,len(P1)):
if P1[row] == P2[row]:
throat = []
else:
throat = sp.intersect1d(Ts1[row],Ts2[row]).tolist()
Ts.insert(0,throat)
Ts.reverse()
return Ts
def __init__(self,
shape=None,
spacing=[1, 1, 1],
perturbation=0.1,
arrangement='SC',
**kwargs):
if shape is not None:
self._arr = np.atleast_3d(np.empty(shape))
else:
self._arr = np.atleast_3d(np.empty([3, 3, 3]))
# Store original network shape
self._shape = sp.shape(self._arr)
# Store network spacing instead of calculating it
self._spacing = sp.asarray(spacing)
self._num_pores = np.prod(np.asarray(self._shape))
self._domain_size = np.asarray(self._shape) * self._spacing
self._perturbation = perturbation
self._arrangement = arrangement
super().__init__(num_pores=self._num_pores,
domain_size=self._domain_size,
**kwargs)
def get_subscripts(network, shape, **kwargs):
r'''
Return the 3D subscripts (i,j,k) into the cubic network
Parameters
----------
shape : list
The (i,j,k) shape of the network in number of pores in each direction
'''
if network.num_pores('internal') != _sp.prod(shape):
print('Supplied shape does not match Network size, cannot proceed')
else:
template = _sp.atleast_3d(_sp.empty(shape))
a = _sp.indices(_sp.shape(template))
i = a[0].flatten()
j = a[1].flatten()
k = a[2].flatten()
ind = _sp.vstack((i, j, k)).T
vals = _sp.ones((network.Np, 3)) * _sp.nan
vals[network.pores('internal')] = ind
return vals
def predict(self, data):
""" Predict samples on actual data.
The result of this function is used for calculating the residuals.
Parameters
----------
data : array-like
shape = [n_samples, n_channels, n_trials] or
[n_samples, n_channels]
Continuous or segmented data set.
Returns
-------
predicted : shape = `data`.shape
Data as predicted by the VAR model.
Notes
-----
Residuals are obtained by r = x - var.predict(x)
"""
data = sp.atleast_3d(data)
(l, m, t) = data.shape
p = int(sp.shape(self.coef)[1] / m)
y = sp.zeros(data.shape)
if t > l-p: # which takes less loop iterations
for k in range(1, p + 1):
bp = self.coef[:, (k - 1)::p]
for n in range(p, l):
y[n, :, :] += bp.dot(data[n - k, :, :])
else:
for k in range(1, p + 1):
bp = self.coef[:, (k - 1)::p]
for s in range(t):
y[p:, :, s] += data[(p - k):(l - k), :, s].dot(bp.T)
return y
def broadened_time_evolution(self):
"""
Calculate the state of all the atoms in the inhomogeneous line at each of nt time steps of size dt.
:return: The state of the system at each timestep averaged over the inhomogeneous line.
"""
dim1, dim2 = sp.shape(self.sing_sim.system.initial_state)
times = sp.linspace(0,
self.sing_sim.duration,
self.sing_sim.nt,
endpoint=False)
time_dep_state = sp.zeros((self.sing_sim.nt, dim1, dim2),
dtype=complex)
for index_i, i in enumerate(self.detunings):
self.sing_sim.reset_state()
self.detune(i)
t1 = time.time()
time_dep_state = time_dep_state + self.sing_sim.time_evolution()
print("Atom number =", index_i, "Detuning =",
round(i / 1e6, 4), "MHz", "Time elapsed =",
str(round(time.time() - t1, 4)), "seconds")
return time_dep_state / self.n_atoms
def benchmark_individual_symbols(n_pts=1000, sz=(1000, 1000)):
"Draws some stars"
width, height = sz
pts = stats.norm.rvs(size=(n_pts, 2)) * array(sz) / 8.0 + array(sz) / 2.0
print(pts[5, :])
print(shape(pts))
star_path = star_path_gen()
gc = agg.GraphicsContextArray(sz)
gc.set_fill_color((1.0, 0.0, 0.0, 0.1))
gc.set_stroke_color((0.0, 1.0, 0.0, 0.6))
t1 = time.clock()
for x, y in pts:
with gc:
gc.translate_ctm(x, y)
gc.add_path(star_path)
gc.draw_path()
t2 = time.clock()
gc.save("benchmark_symbols1.bmp")
tot_time = t2 - t1
print('star count, tot,per shape:', n_pts, tot_time, tot_time / n_pts)
return
