def test_tensordot(a_shape, b_shape, axes):
sa = sparse.random(a_shape, density=0.5)
sb = sparse.random(b_shape, density=0.5)
a = sa.todense()
b = sb.todense()
assert_eq(np.tensordot(a, b, axes), sparse.tensordot(sa, sb, axes))
assert_eq(np.tensordot(a, b, axes), sparse.tensordot(sa, b, axes))
# assert isinstance(sparse.tensordot(sa, b, axes), COO)
assert_eq(np.tensordot(a, b, axes), sparse.tensordot(a, sb, axes))
def get_boundary_matrices(self, global_index):
if not os.path.exists(self.cache + '/Am_' + str(global_index) + '.p'):
kdir = self.kappa_directional[global_index]
k_angle = sparse.COO([0, 1, 2],
self.kappa_directional[global_index],
shape=(3))
tmp = sparse.tensordot(self.mesh.CP, k_angle, axes=1)
AP = tmp.clip(min=0) #.to_scipy_sparse().todok()
AM = (tmp - AP) #.tocsc().todok() #preserve the sign of AM
#if self.argv.setdefault('antialiasing',False):
# self.get_antialiasing(self.mesh.CP,self.kappa_directional_not_int[global_index],AM,AP)
AP = AP.todense()
AM = -AM.todense()
if self.save_data:
AM.dump(
open(self.cache + '/Am_' + str(global_index) + '.p', 'wb'))
AP.dump(
open(self.cache + '/Ap_' + str(global_index) + '.p', 'wb'))
else:
AM = np.load(open(self.cache + '/Am_' + str(global_index) + '.p',
'rb'),
allow_pickle=True)
AP = np.load(open(self.cache + '/Ap_' + str(global_index) + '.p',
'rb'),
allow_pickle=True)
return AM, AP
def test_tensordot_empty():
x1 = np.empty((0, 0, 0))
x2 = np.empty((0, 0, 0))
s1 = sparse.COO.from_numpy(x1)
s2 = sparse.COO.from_numpy(x2)
assert_eq(np.tensordot(x1, x2), sparse.tensordot(s1, s2))
def test_tensordot(a_shape, b_shape, axes):
a = random_x(a_shape)
b = random_x(b_shape)
sa = COO.from_numpy(a)
sb = COO.from_numpy(b)
assert_eq(np.tensordot(a, b, axes), sparse.tensordot(sa, sb, axes))
assert_eq(np.tensordot(a, b, axes), sparse.tensordot(sa, b, axes))
assert isinstance(sparse.tensordot(sa, b, axes), COO)
assert_eq(np.tensordot(a, b, axes), sparse.tensordot(a, sb, axes))
assert isinstance(sparse.tensordot(a, sb, axes), COO)
def get_bulk_data(self,global_index,TB,TL):
index_irr = self.mat['temp_vec'][global_index]
aa = sparse.COO([0,1,2],self.control_angle[global_index],shape=(3))
mfp = self.mat['mfp'][global_index]
irr_angle = self.mat['angle_map'][global_index]
if not irr_angle == self.old_index:
self.old_index = irr_angle
if not os.path.exists(self.cache + '/A_' + str(irr_angle) + '.npz'):
test2 = sparse.tensordot(self.mesh.N,aa,axes=1)
AP = test2.clip(min=0)
AM = (test2 - AP)
AP = spdiags(np.sum(AP,axis=1).todense(),0,self.n_elems,self.n_elems,format='csc')
self.mesh.B = self.mesh.B.tocsc()
self.P = np.sum(np.multiply(AM,self.mesh.B),axis=1).todense()
tmp = sparse.tensordot(self.mesh.CM,aa,axes=1)
HW_PLUS = tmp.clip(min=0)
self.HW_MINUS = (HW_PLUS-tmp)
BP = spdiags(np.sum(HW_PLUS,axis=1).todense(),0,self.n_elems,self.n_elems,format='csc')
self.A = AP + AM + BP
self.P.dump(self.cache + '/P_' + str(irr_angle) + '.p')
sparse.io.save_npz(self.cache + '/A_' + str(irr_angle) + '.npz',self.A)
sparse.io.save_npz(self.cache + '/HW_MINUS_' + str(irr_angle) + '.npz',self.HW_MINUS)
else:
self.P = np.load(open(self.cache +'/P_' + str(irr_angle) +'.p','rb'),allow_pickle=True)
self.A = sparse.load_npz(self.cache + '/A_' + str(irr_angle) + '.npz')
self.HW_MINUS = sparse.load_npz(self.cache + '/HW_MINUS_' + str(irr_angle) + '.npz')
boundary = np.sum(np.multiply(TB,self.HW_MINUS),axis=1).todense()
RHS = mfp * (self.P + boundary) + TL[index_irr]
#Add connection-----
#RHS += self.TL_old[global_index] - self.temp_old[global_index] - self.delta_old[global_index]
#-------------------
#else:
# RHS = mfp * (boundary) + TL[index_irr]
F = scipy.sparse.eye(self.n_elems,format='csc') + self.A * mfp
lu = splu(F.tocsc())
return lu.solve(RHS)
def get_multiscale_diffusive(self,index,n,SDIFF,TDIFF,TDIFFGrad):
angle = self.control_angle[index]
aa = sparse.COO([0,1,2],angle,shape=(3))
HW_PLUS = sparse.tensordot(self.mesh.CP,aa,axes=1).clip(min=0)
s = SDIFF[n] * self.mat['mfp'][n]
temp = TDIFF[n] - self.mat['mfp'][n]*np.dot(self.control_angle[index],TDIFFGrad[n].T)
t = temp*self.mat['domega'][index]
j = np.multiply(temp,HW_PLUS)*self.mat['domega'][index]
return t,s,j
def test_tensordot(a_shape, b_shape, axes, a_format, b_format):
sa = sparse.random(a_shape, density=0.5, format=a_format)
sb = sparse.random(b_shape, density=0.5, format=b_format)
a = sa.todense()
b = sb.todense()
a_b = np.tensordot(a, b, axes)
# tests for return_type=None
sa_sb = sparse.tensordot(sa, sb, axes)
sa_b = sparse.tensordot(sa, b, axes)
a_sb = sparse.tensordot(a, sb, axes)
assert_eq(a_b, sa_sb)
assert_eq(a_b, sa_b)
assert_eq(a_b, a_sb)
if all(isinstance(arr, COO) for arr in [sa, sb]):
assert isinstance(sa_sb, COO)
else:
assert isinstance(sa_sb, GCXS)
assert isinstance(sa_b, np.ndarray)
assert isinstance(a_sb, np.ndarray)
# tests for return_type=COO
sa_b = sparse.tensordot(sa, b, axes, return_type=COO)
a_sb = sparse.tensordot(a, sb, axes, return_type=COO)
assert_eq(a_b, sa_b)
assert_eq(a_b, a_sb)
assert isinstance(sa_b, COO)
assert isinstance(a_sb, COO)
# tests form return_type=GCXS
sa_b = sparse.tensordot(sa, b, axes, return_type=GCXS)
a_sb = sparse.tensordot(a, sb, axes, return_type=GCXS)
assert_eq(a_b, sa_b)
assert_eq(a_b, a_sb)
assert isinstance(sa_b, GCXS)
assert isinstance(a_sb, GCXS)
# tests for return_type=np.ndarray
sa_sb = sparse.tensordot(sa, sb, axes, return_type=np.ndarray)
assert_eq(a_b, sa_sb)
assert isinstance(sa_sb, np.ndarray)
def get_bulk_data(self, global_index, TB, TL, Tnew):
index_irr = self.mat['temp_vec'][global_index]
aa = sparse.COO([0, 1, 2], self.control_angle[global_index], shape=(3))
mfp = self.mat['mfp'][global_index]
irr_angle = self.mat['angle_map'][global_index]
if (self.keep_lu) and (global_index in self.lu.keys()):
lu = self.lu[irr_angle]
else:
if not irr_angle == self.old_index:
self.old_index = irr_angle
if not os.path.exists(self.cache + '/A_' + str(irr_angle) +
'.npz'):
test2 = sparse.tensordot(self.mesh.N, aa, axes=1)
AP = test2.clip(min=0)
AM = (test2 - AP)
AP = spdiags(np.sum(AP, axis=1).todense(),
0,
self.mesh.nle,
self.mesh.nle,
format='csc')
self.mesh.B = self.mesh.B.tocsc()
self.P = np.sum(np.multiply(AM, self.mesh.B),
axis=1).todense()
tmp = sparse.tensordot(self.mesh.CM, aa, axes=1).todense()
HW_PLUS = tmp.clip(min=0)
self.HW_MINUS = (HW_PLUS - tmp)
BP = spdiags(np.sum(HW_PLUS, axis=1),
0,
self.mesh.nle,
self.mesh.nle,
format='csc')
self.A = AP + AM + BP
if self.save_data:
self.P.dump(self.cache + '/P_' + str(irr_angle) + '.p')
sio.save_npz(
self.cache + '/A_' + str(irr_angle) + '.npz',
self.A)
self.HW_MINUS.dump(
open(
self.cache + '/HW_MINUS_' + str(irr_angle) +
'.npz', 'wb'))
else:
self.P = np.load(open(
self.cache + '/P_' + str(irr_angle) + '.p', 'rb'),
allow_pickle=True)
self.A = sparse.load_npz(self.cache + '/A_' +
str(irr_angle) + '.npz')
self.HW_MINUS = np.load(open(
self.cache + '/HW_MINUS_' + str(irr_angle) + '.npz',
'rb'),
allow_pickle=True)
F = scipy.sparse.eye(self.mesh.nle, format='csc') + self.A * mfp
lu = splu(F.tocsc())
if (self.keep_lu): self.lu[irr_angle] = lu
boundary = np.sum(np.multiply(TB, self.HW_MINUS), axis=1)
#RHS = mfp * (self.P + boundary) + Tnew + TL[index_irr]
#RHS = mfp * boundary + np.ones(self.mesh.nle)
RHS = mfp * np.ones(self.mesh.nle) + np.ones(self.mesh.nle)
temp = lu.solve(RHS)
return temp
