def update_E_PM(self,particles,just_return_dont_update=False):
global counter
try:
counter==None
except:
counter=0
counter+=1
self.V_point_sources=0
for particle in particles:
i = int(round(particle.pos[0]*10**6))
j = int(round(particle.pos[1]*10**6))
"""to do: still a bug with particles being outside the period...
if not self.contains([particle]):
print(self.particles_left.nnz,
self.particles_right.nnz,
self.particles_top.nnz,
self.particles_bottom.nnz)"""
"""the dielectric constant and minus sign are already done in Fenics"""
self.V_point_sources += particle.charge*e*self.point_sources[i,j]
tci = LinearTriInterpolator(self.triang_V,self.V_point_sources) # faster interpolator, but not as accurate
(Ex, Ey) = tci.gradient(self.triang_V.x,self.triang_V.y)
#V = tci(self.triang_V.x,self.triang_V.y)
if just_return_dont_update:
return -np.array([Ex,Ey])#*3e5
#return np.array([V,V*0]) #for debugging
else:
self.E_point_sources = -np.array([Ex,Ey])#*3e5
def plot_solution(self, phi, ax=None, **kwargs):
"""Given the solution vector phi of values at the vertices, plot the solution"""
intp = LinearTriInterpolator(self.triang, phi)
x, y = self.tri['vertices'].T
u, v = intp.gradient(x, y)
ax = ax or plt.gca()
ax.tripcolor(self.triang, phi)
ax.quiver(x, y, u, v, **kwargs)
def gradient(
solution,
variable,
*,
gradient_norm=True,
plot=True,
color_style: COLOR_STYLE_TYPE = "equal",
mask=None,
**kwargs
) -> Union[np.ndarray, Tuple[np.ndarray, np.ndarray]]:
"""Compute and plot the gradient of a scalar field.
:param solution: The solution structure
:param variable: Name of the variable
:param gradient_norm: Should the norm be computed
:param plot: Should the data be plotted
:param color_style: How to symmetrize the colormap (False/None, 'full', 'equal')
:param mask: Valid matplotlib mask see generate_mask
:param kwargs:
:return: Computed field as a scalar or vector field
"""
mpl_kwargs, fish2fem_kwargs = split_mpl_kwargs(kwargs)
triangles, data = generate_triangles_for_2d(
solution, variable, mask=mask, **fish2fem_kwargs
)
topology = triangles.triangles
geometry = list(zip(triangles.x, triangles.y))
interpolator = LinearTriInterpolator(triangles, -data)
(e_x, e_y) = interpolator.gradient(triangles.x, triangles.y)
if gradient_norm:
norm = field_norm(e_x, e_y)
if plot:
mesh_plot_2d(
None,
None,
color_style=color_style,
mask=mask,
topology=topology,
geometry=geometry,
data=data,
**kwargs
)
return norm
else:
plt.quiver(triangles.x, triangles.y, e_x, e_y, **mpl_kwargs)
return e_x, e_y
def velocity_from_phi(self, phi, x=None, y=None):
"""Interpolate velocity solution in vertex positions
Velocity solution is: u = \grad(\phi) + \Gamma u_pf
where \phi is the solution of phi at the vertices, and u_pf
the standard point vortex, with magnitude Gamma stored in the
(N+1)-th entry of the solution vector."""
assert (x is None) == (
y is None), "Provide either both or neither x and y arguments"
if x is None:
x, y = self.tri['vertices'].T
N = len(phi) - 1
# first normal interpolation phi gradient
intp = LinearTriInterpolator(self.triang, phi[:N])
u, v = intp.gradient(x, y)
# then add point vortex solution
Gamma = phi[-1]
r2 = (x - self.x_c)**2 + y**2
u += -y / r2 * Gamma / 2 / np.pi
v += (x - self.x_c) / r2 * Gamma / 2 / np.pi
return u, v
point_sources = pickle.load(f)
with open('smartwindows/Variables/voltages_with_glass.pkl', 'rb') as f:
V1, V2, V3, V4 = pickle.load(f)
trifinder = triang.get_trifinder()
y_b = 0.0e-5
y_t = 5.0e-5
t = 1.5e-5
x_1 = 0.0
x_2 = 20e-5
b = 5e-5
tci = LinearTriInterpolator(triang, V1)
(Ex, Ey) = tci.gradient(triang.x, triang.y)
E = -np.array([Ex, Ey])
x = np.linspace(0, 20e-5, 200 / 4)
y = np.linspace(0 - 1.5e-5, 5e-5 + 1.5e-5, (50 + 2 * 15) / 4)
X, Y = np.meshgrid(x, y)
def get_field_here(field, pos: np.ndarray) -> np.ndarray:
tr = trifinder(*pos)
i = triang.triangles[tr]
v0 = np.array([triang.x[i[0]], triang.y[i[0]]])
v1 = np.array([triang.x[i[1]], triang.y[i[1]]])
v2 = np.array([triang.x[i[2]], triang.y[i[2]]])
norm = np.array([
np.linalg.norm(v0 - pos),
def update_E_electrodes(self, x=[0,0,0,0]):
self.V_electrodes = x[0]*self.V1 + x[1]*self.V2 + x[2]*self.V3 + x[3]*self.V4
tci = LinearTriInterpolator(self.triang_V,self.V_electrodes) # faster interpolator, but not as accurate
(Ex, Ey) = tci.gradient(self.triang_V.x,self.triang_V.y)
self.E_electrodes = -np.array([Ex,Ey])
#####################
nitr = 5
for itr in range(nitr):
nfname = 'dep_smooth_itr_' + str(100 + itr) + '.nc'
os.system('cp -f ' + fname + ' ' + nfname)
os.system('echo Log smoothing &> log.txt ')
for itr in range(nitr):
print ' > Calculate gradient ..', itr, nitr
os.system('echo ' + str(itr) + ' from ' + str(nitr) + ' >> log.txt ')
os.system('echo "************************************" >> log.txt ')
tci = LinearTriInterpolator(tri, dep)
(ddep_dx, ddep_dy) = tci.gradient(UTMx, UTMy)
grad_dep = np.sqrt(ddep_dx**2 + ddep_dy**2)
grad_lim = 0.35
[ind] = np.where(grad_dep > grad_dep.max() * grad_lim)
#######
if vv:
fig, ax = adcp.make_map(res='m')
vmin = 0
vmax = 0.5
dv = (vmax - vmin) / 50.0
levels = np.arange(vmin, vmax + dv, dv)
cf1 = ax.tricontourf(
trip, grad_dep, levels=levels, cmap=cmaps.jetMinWi,
extend='both') #,alpha=0.8)#extend='max' ) #,extend='both'
