def test_doit(self):
v1, v2, zero, one, nabla, C, vn1, vn2, x, y, z = self._get_vars()
assert VecCross(vn1, vn2).doit() - vn1.cross(vn2) == Vector.zero
assert VecCross(nabla, vn2).doit() - curl(vn2) == Vector.zero
vn3 = C.x * C.y * C.z * C.i + C.x * C.y * C.z * C.j + C.x * C.y * C.z * C.k
assert VecCross(nabla, vn3).doit() - curl(vn3) == Vector.zero
expr = VecCross(v2 * VecDot(vn1, vn2), v1).doit()
assert isinstance(expr.args[0].args[0], Add)
expr = VecCross(v2 * VecDot(vn1, vn2), v1).doit(deep=False)
assert isinstance(expr.args[0], VecMul)
def makeMatrix(U,B,p,order,dic,vort =True):
# if order !=0:
buoy = Ri*(rho*g)
# else:
# r1 = rho0
# buoy = Ri*r1*g
Cor=((2+chi*y)*qRo*C.k).cross(U)
BgradB = (AgradB.xreplace({Ax:B&C.i,Ay:B&C.j,Az:B&C.k,Bx:B&C.i,By:B&C.j,Bz:B&C.k})).doit()
UgradU = (AgradB.xreplace({Ax:U&C.i,Ay:U&C.j,Az:U&C.k,Bx:U&C.i,By:U&C.j,Bz:U&C.k})).doit()
Eq_NS = diff(U,t)+Cor+UgradU-(-gradient(p)+qRe*laplacian(U)+buoy+BgradB)
Eq_vort=diff((Eq_NS&C.j),x)-diff((Eq_NS&C.i),y)
Eq_m=divergence(U)
Eq_b=diff(B,t)- (qRm*laplacian(B) + curl(U.cross(B)))
if vort == True:
eq = zeros(7,1)
for i,j in enumerate([Eq_NS&C.i,Eq_vort,Eq_NS&C.k,Eq_b&C.i,Eq_b&C.j,Eq_b&C.k,Eq_m]):
eq[i] = taylor(j,order,dic)
var = [Symbol('u'+str(order)+'x'),Symbol('u'+str(order)+'y'),Symbol('u'+str(order)+'z'),Symbol('p'+str(order)),Symbol('b'+str(order)+'x'),Symbol('b'+str(order)+'y'),Symbol('b'+str(order)+'z')]
M, rme = linear_eq_to_matrix(eq, var)
M = simplify((M/ansatz)).xreplace(dic)
print("Matrix OK")
return(M,rme,r1)
def doit(self, **kwargs):
deep = kwargs.get('deep', True)
args = self.args
if deep:
args = [arg.doit(**kwargs) for arg in args]
if isinstance(args[0], Vector) and \
isinstance(args[1], Vector):
return args[0].cross(args[1])
if isinstance(args[0], Vector) and \
isinstance(args[1], Nabla):
return -curl(args[0])
if isinstance(args[1], Vector) and \
isinstance(args[0], Nabla):
return curl(args[1])
return self.func(*args)
def curl(self, expr):
expr_len = len(expr)
if expr_len == 1:
expr = ['0'] + ['0'] + expr
elif expr_len == 2:
expr = expr + ['0']
expr_ijk = self.list_to_ijk(expr)
curl_expr = spv.curl(eval(expr_ijk))
curl_expr_list = self.ijk_to_list(curl_expr)
if expr_len == 1:
a, b, *_ = curl_expr_list
return [a, b]
elif expr_len == 2:
*_, a = curl_expr_list
return [a]
else:
return curl_expr_list
c = CoordSys3D('c')
nabla = Del()
gradient_field = nabla(c.x * c.y * c.z)
gradient_field.doit()
#C.y*C.z*C.i + C.x*C.z*C.j + C.x*C.y*C.k
#rotatation
#1ers methode
nabla.cross(c.x * c.y * c.z * c.i).doit()
(nabla ^ c.x * c.y * c.z * c.i).doit()
#2eme methode
curl(C.x * C.y * C.z * C.i)
#C.x*C.y*C.j + (-C.x*C.z)*C.k
#divergence
#1ere methode
nabla.dot(c.x * c.y * c.z * (c.i + c.j + c.k)).doit()
#C.x*C.y + C.x*C.z + C.y*C.z
(nabla & c.x * c.y * c.z * (c.i + c.j + c.k)).doit()
#C.x*C.y + C.x*C.z + C.y*C.z
#2eme methode:
divergence(c.x * c.y * c.z * (c.i + c.j + c.k))
#c.x*C.y + C.x*C.z + C.y*C.z
#Gradient
#1ere methode
init_printing()
global R
global transformation
u1, u2, u3 = symbols('u1:4', type='Function')
f1 = symbols('f_0', type='Function')
omega1 = symbols(r'\Omega', type='Function')
nabla = Del()
R.i = getattr(R, vec_names[0])
R.j = getattr(R, vec_names[1])
R.k = getattr(R, vec_names[2])
R.x = getattr(R, var_names[0])
R.y = getattr(R, var_names[1])
R.z = getattr(R, var_names[2])
u = u1(R.x, R.y, R.z) * R.i + u2(R.x, R.y, R.z) * R.j + u3(R.x, R.y, R.z) * R.k
e = eta(R.x, R.y, R.z)
if transformation == 'spherical':
u_h = u2(R.x, R.y, R.z) * R.j + u3(R.x, R.y, R.z) * R.k
stream = psi(R.y, R.z)
pot = chi(R.y, R.z)
u_r = -curl(R.i * stream).doit()
elif transformation == 'cartesian':
u_h = u1(R.x, R.y, R.z) * R.i + u2(R.x, R.y, R.z) * R.j
stream = psi(R.x, R.y)
pot = chi(R.x, R.y)
u_r = -curl(R.k * stream).doit()
u_d = gradient(pot).doit()
u_helm = u_r + u_d
def Bound(U,B,sol,eig,dic,order,condB = "harm pot",condU = 'Inviscid'):
lso = len(sol)
for s in range(len(sol)):
globals() ['C'+str(s)] = Symbol('C'+str(s))
#################################
### Inviscid solution : ###
### lso=3 --> 1 boundary ###
### lso=6 --> 2 boundaries ###
#################################
nn = n.xreplace(dic).doit()
U = (U.xreplace(makedic(veigen(eig,sol),order))).xreplace({U0:1})
B = (B.xreplace(makedic(veigen(eig,sol),order)))
if (condB == "harm pot"):
bchx,bchy,bchz = symbols("bchx,bchy,bchz")
bcc =surfcond((bchx*C.i +bchy*C.j + bchz*C.k)*ansatz - gradient(psi),dic).doit()
sob = list(linsolve([bcc&C.i,bcc&C.j,bcc&C.k],(bchx,bchy,bchz)))[0]
bbc = sob[0]*C.i + sob[1]*C.j + sob[2]*C.k
bb = B.xreplace(makedic(veigen(eig,sol),order)) - (bbc*ansatz)
Eq_b= surfcond(bb,dic)
Eq_bx = Eq_b&C.i; Eq_by = Eq_b&C.j; Eq_bz = Eq_b&C.k
if params.Bound_nb ==2:
bchx2,bchy2,bchz2 = symbols("bchx2,bchy2,bchz2")
bcc2 =surfcond_2((bchx2*C.i +bchy2*C.j +bchz2*C.k)*ansatz - gradient(psi_2b),dic)
sob2 = list(linsolve([bcc2&C.i,bcc2&C.j,bcc2&C.k],(bchx2,bchy2,bchz2)))[0]
bbc2 = sob2[0]*C.i + sob2[1]*C.j + sob2[2]*C.k
bb2 = B.xreplace(makedic(veigen(eig,sol),order)) - (bbc2*ansatz)
Eq_b2= surfcond_2(bb2,dic)
Eq_b2x = Eq_b2&C.i; Eq_b2y = Eq_b2&C.j; Eq_b2z = Eq_b2&C.k
if (condB == "thick"):
bchx,bchy,bchz,eta = symbols("bchx,bchy,bchz,eta")
kz_t = -sqrt(-kxl**2-kyl**2-I*omega/qRmm)
# kz_t = I*1e12
B_mant = (bchx*C.i +bchy*C.j + bchz*C.k)*ansatz.xreplace({kz:kz_t})
eq_ind = (surfcond((diff(B_mant,t)-qRmm*laplacian(B_mant)-diff(B,t) +qRm*laplacian(B) - curl(U.cross(B))).xreplace({kz:kz_t}),dic).xreplace(dic))
eq_E = (qRm*curl(B)-U.cross(B)-qRmm*curl(B_mant))
eq_Et = surfcond(((nn).cross(eq_E)).xreplace({kz:kz_t}),dic)
eq_B = surfcond(((B_mant.dot(nn)-B.dot(nn))).xreplace({kz:kz_t}),dic)
un = (U.dot(nn))
Eq_n1= surfcond((un).xreplace({kz:kz_t}),dic).xreplace(dic)
TEq = [(taylor(eq,order,dic)).xreplace({x:0,y:0,t:0}) for eq in [Eq_n1,eq_ind&C.i,eq_ind&C.j,eq_ind&C.k,eq_Et.dot(tx),eq_Et.dot(ty)]]
Mat, res = linear_eq_to_matrix(TEq,(C0,C1,C2,bchx,bchy,bchz))
U = (U.xreplace(makedic(veigen(eig,sol),order))).xreplace({U0:1})
un = U.dot(nn)
Eq_n1= surfcond(un,dic).xreplace(dic)
if condU == "Inviscid":
if params.Bound_nb ==2:
nn2 = n2.xreplace(dic).doit()
un2 = U.dot(nn2)
Eq_n2= surfcond_2(un2,dic)
TEq = [(taylor(eq,order,dic)).xreplace({x:0,y:0,t:0}) for eq in [Eq_n1,Eq_n2,Eq_bx,Eq_by,Eq_bz,Eq_b2x,Eq_b2y,Eq_b2z]]
Mat, res = linear_eq_to_matrix(TEq,(C0,C1,C2,C3,C4,C5,Symbol("psi"+str(order)),Symbol("psi"+str(order)+"_2b")))
elif params.Bound_nb ==1:
TEq = [(taylor(eq,order,dic)).xreplace({x:0,y:0,t:0}) for eq in [Eq_n1,Eq_bx,Eq_by,Eq_bz]]
Mat, res = linear_eq_to_matrix(TEq,(C0,C1,C2,Symbol("psi"+str(order))))
elif condU == 'noslip':
if params.Bound_nb ==1:
U = (U.xreplace(makedic(veigen(eig,sol),order)))
ut1 = U.dot(tx)
ut2 = U.dot(ty)
Eq_BU1= surfcond(ut1,dic)
Eq_BU2 = surfcond(ut2,dic)
TEq = [(taylor(eq,order,dic)).xreplace({x:0,y:0,t:0}) for eq in [Eq_n1,Eq_BU1,Eq_BU2,Eq_bx,Eq_by,Eq_bz]]
Mat, res = linear_eq_to_matrix(TEq,(C0,C1,C2,C3,C4,Symbol("psi"+str(order))))
elif params.Bound_nb ==2:
un1 = U.dot(tx2)
un2 = U.dot(ty2)
Eq2_BU1= surfcond_2(un1,dic)
Eq2_BU2 = surfcond_2(un2,dic)
TEq = [(taylor(eq,order,dic)).xreplace({x:0,y:0,t:0}) for eq in [Eq_n1,Eq_n2,Eq_BU1,Eq_BU2,Eq2_BU1,Eq2_BU2,Eq_bx,Eq_by,Eq_bz,Eq_b2x,Eq_b2y,Eq_b2z]]
Mat, res = linear_eq_to_matrix(TEq,(C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,Symbol("psi"+str(order)),Symbol("psi"+str(order)+"_2b")))
elif condU == 'stressfree':
if params.Bound_nb ==1:
eu = strain(U)*nn
eu1 = eu*tx
eu2 = eu*ty
Eq_BU1 = surfcond(eu1,dic,realtopo =False)
Eq_BU2 = surfcond(eu2,dic,realtopo =False)
TEq = [(taylor(eq,order,dic)).xreplace({x:0,y:0,t:0}) for eq in [Eq_n1,Eq_BU1,Eq_BU2,Eq_bx,Eq_by,Eq_bz]]
Mat, res = linear_eq_to_matrix(TEq,(C0,C1,C2,C3,C4,Symbol("psi"+str(order))))
elif params.Bound_nb ==2:
eu = strain(U)*nn2
eu1 = eu*tx2
eu2 = eu*ty2
Eq2_BU1 = surfcond2(eu1,dic,realtopo =False)
Eq2_BU2 = surfcond2(eu2,dic,realtopo =False)
TEq = [(taylor(eq,order,dic)).xreplace({x:0,y:0,t:0}) for eq in [Eq_n1,Eq_n2,Eq_BU1,Eq_BU2,Eq2_BU1,Eq2_BU2,Eq_bx,Eq_by,Eq_bz,Eq_b2x,Eq_b2y,Eq_b2z]]
Mat, res = linear_eq_to_matrix(TEq,(C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,Symbol("psi"+str(order)),Symbol("psi"+str(order)+"_2b")))
Mat = Mat.evalf(mp.mp.dps)
res = res.evalf(mp.mp.dps)
Mat = mpmathM(Mat)
res = mpmathM(res)
try:
abc = mp.qr_solve(Mat,res)[0]
except:
abc = mp.lu_solve(Mat,res)
mantle =0 #In progress ...
solans = zeros(7,1)
for l in range(lso):
solans = solans + abc[l]*Matrix(eig[l])*(ansatz).xreplace({kz:sol[l]})
solans = solans.xreplace(dic)
return(abc,solans,mantle)