def test_jet_extend_basis1(self):
x1, x2, x3 = xx = st.symb_vector("x1, x2, x3")
xx_tmp, ddx = pc.setup_objects(xx)
self.assertTrue(xx is xx_tmp)
# get the individual forms
dx1, dx2, dx3 = ddx
dx1.jet_extend_basis()
xdot1, xdot2, xdot3 = xxd = pc.st.time_deriv(xx, xx)
xddot1, xddot2, xddot3 = xxdd = pc.st.time_deriv(xx, xx, order=2)
full_basis = st.row_stack(xx, xxd, xxdd)
foo, ddX = pc.setup_objects(full_basis)
dx1.jet_extend_basis()
self.assertEqual(ddX[0].basis, dx1.basis)
self.assertEqual(ddX[0].coeff, dx1.coeff)
half_basis = st.row_stack(xx, xxd)
foo, ddY = pc.setup_objects(half_basis)
dx2.jet_extend_basis()
self.assertEqual(ddY[1].basis, dx2.basis)
self.assertEqual(ddY[1].coeff, dx2.coeff)
def test_get_baseform_from_plain_index(self):
x1, x2, x3 = xx = st.symb_vector("x1, x2, x3")
xx, dxx = pc.setup_objects(xx)
dx1, dx2, dx3 = dxx
W = 7 * (dx1 ^ dx2) + 3 * x2 * (dx1 ^ dx3)
res = W.get_baseform_from_plain_index(0)
self.assertEqual(res, dx1 ^ dx2)
res = W.get_baseform_from_plain_index(2)
self.assertEqual(res, dx2 ^ dx3)
res = W.get_baseform_from_plain_index(-1)
self.assertEqual(res, dx2 ^ dx3)
res = W.get_baseform_from_plain_index(-2)
self.assertEqual(res, dx1 ^ dx3)
res = W.get_baseform_from_plain_index(-3)
self.assertEqual(res, dx1 ^ dx2)
with self.assertRaises(ValueError) as cm:
res = W.get_baseform_from_plain_index(3)
with self.assertRaises(ValueError) as cm:
res = W.get_baseform_from_plain_index(-4)
def test_get_baseform(self):
x1, x2, x3 = xx = st.symb_vector("x1, x2, x3")
xx, dxx = pc.setup_objects(xx)
dx1, dx2, dx3 = dxx
W = 7 * (dx1 ^ dx2) + 3 * x2 * (dx1 ^ dx3)
res1 = W.get_baseform_from_idcs((0, 1))
self.assertEqual(res1, dx1 ^ dx2)
idcs_matrix = sp.Matrix([0, 2])
res2 = W.get_baseform_from_idcs(idcs_matrix)
self.assertEqual(res2, dx1 ^ dx3)
idcs_array = st.np.array([0, 2])
res2b = W.get_baseform_from_idcs(idcs_array)
self.assertEqual(res2b, dx1 ^ dx3)
res3 = W.get_baseform_from_idcs((1, 2))
self.assertEqual(res3, dx2 ^ dx3)
Z = dx1 + x3**2 * dx2
res4 = Z.get_baseform_from_idcs((1, ))
self.assertEqual(res4, dx2)
res5 = Z.get_baseform_from_idcs(2)
self.assertEqual(res5, dx3)
with self.assertRaises(TypeError) as cm:
res = W.get_baseform_from_idcs(dx1)
with self.assertRaises(ValueError) as cm:
res = W.get_baseform_from_idcs((0, 0))
def test_ord(self):
x1, x2, x3 = xx = st.symb_vector("x1, x2, x3")
xdot1, xdot2, xdot3 = xxd = pc.st.time_deriv(xx, xx)
xxdd = pc.st.time_deriv(xx, xx, order=2)
XX = st.concat_rows(xx, xxd, xxdd)
XX, dXX = pc.setup_objects(XX)
dx1, dx2, dx3, dxdot1, dxdot2, dxdot3, dxddot1, dxddot2, dxddot3 = dXX
w0 = 0 * dx1
w1 = dx1 + dxdot3
w2 = 4 * x2 * dx1 - sp.sin(x3) * xdot1 * dx2
self.assertEqual(w0.ord, 0)
self.assertEqual(dx1.ord, 0)
self.assertEqual(dxdot1.ord, 1)
self.assertEqual(dxddot3.ord, 2)
self.assertEqual(w1.ord, 1)
self.assertEqual(w2.ord, 0)
self.assertEqual(w2.d.ord, 1)
w3 = w1 ^ w2
self.assertEqual(w3.ord, 1)
self.assertEqual(w3.dot().ord, 2)
def test_jet_extend_basis1(self):
x1, x2, x3 = xx = sp.Matrix(sp.symbols("x1, x2, x3"))
xx_tmp, ddx = pc.setup_objects(xx)
self.assertTrue(xx is xx_tmp)
# get the individual forms
dx1, dx2, dx3 = ddx
dx1.jet_extend_basis()
self.assertTrue(len(dx1.basis) == 2 * len(xx))
self.assertTrue(dx1.coeff[0] == 1)
self.assertFalse(any(dx1.coeff[1:]))
# derivative coordinates
xdot1, xdot2, xdot3 = xxd = pc.st.time_deriv(xx, xx)
ext_basis = pc.st.row_stack(xx, xxd)
w1 = xdot1 * dx2
w1.jet_extend_basis()
self.assertEqual(w1.basis[3], w1.coeff[1])
dw1 = w1.d
res1 = pc.d(xdot1, ext_basis) ^ pc.d(x2, ext_basis)
self.assertEqual(dw1, res1)
w2 = x3 * dx2
self.assertEqual(w2.dim_basis, len(xx))
w2.jet_extend_basis()
self.assertEqual(w2.dim_basis, len(ext_basis))
dw2 = w2.d
res2 = -dx2 ^ dx3
res2.jet_extend_basis()
self.assertEqual(dw2, res2)
def test_get_coeff(self):
xx = st.symb_vector("x, y, z")
(x, y, z), (dx, dy, dz) = pc.setup_objects(xx)
w = 7 * dx - x**2 * dy
c1 = w.get_coeff(dx)
c2 = w.get_coeff(dy)
self.assertEqual(c1, 7)
self.assertEqual(c2, -x**2)
def test_hodge_star_3d(self):
x1, x2, x3 = xx = sp.Matrix(sp.symbols("x1, x2, x3"))
foo, ddx = pc.setup_objects(xx)
dx1, dx2, dx3 = ddx
# cross product is hodge dual of wedge product
self.assertEqual((dx1 ^ dx2).hodge_star(), dx3)
self.assertEqual((dx1 ^ dx3).hodge_star(), -dx2)
self.assertEqual((dx2 ^ dx3).hodge_star(), dx1)
# https://en.wikipedia.org/wiki/Hodge_isomorphism#Three_dimensions
self.assertEqual(dx1.hodge_star(), dx2 ^ dx3)
self.assertEqual(dx2.hodge_star(),
dx3 ^ dx1) # note the non canonical order
self.assertEqual(dx3.hodge_star(), dx1 ^ dx2)
def test_dot3(self):
xx = sp.Matrix(sp.symbols("x1, x2, x3"))
xxd = pc.st.time_deriv(xx, xx)
xxdd = pc.st.time_deriv(xx, xx, order=2)
full_basis = pc.st.row_stack(xx, xxd, xxdd)
foo, ddx = pc.setup_objects(full_basis)
dx1, dx2, dx3, dxdot1, dxdot2, dxdot3, dxddot1, dxddot2, dxddot3 = ddx
aa = sp.Matrix(sp.symbols("a1:3"))
a1, a2 = aa
mu1 = a1 * dxdot1 + 3 * a2 * dx2
mu1.dot()
# this once was a bug:
self.assertEqual(xxdd[0].difforder, 2)
def test_hodge_star_4d(self):
# noinspection PyPep8Naming
x1, x2, x3, x4 = xx = sp.Matrix(sp.symbols("x1, x2, x3, x4"))
foo, ddx = pc.setup_objects(xx)
dt, dx, dy, dz = ddx
# see https://en.wikipedia.org/wiki/Hodge_isomorphism#Four_dimensions
# Minkowski spacetime with metric signature (+ − − −)
# Currently not supported (non-standard scalar product not yet implemented)
self.assertEqual(dt.hodge_star(), dx ^ dy ^ dz)
self.assertEqual(dx.hodge_star(), dt ^ dy ^ dz)
self.assertEqual(dy.hodge_star(), -dt ^ dx ^ dz)
self.assertEqual(dz.hodge_star(), dt ^ dx ^ dy)
self.assertEqual((dt ^ dx).hodge_star(), -dy ^ dz)
def test_dot(self):
x1, x2, x3 = xx = sp.Matrix(sp.symbols("x1, x2, x3"))
xdot1, xdot2, xdot3 = xxd = pc.st.time_deriv(xx, xx)
xx_tmp, ddx = pc.setup_objects(xx)
dx1, dx2, dx3 = ddx
full_basis = list(xx) + list(xxd)
dxdot2 = pc.DifferentialForm(1, full_basis, [0, 0, 0, 0, 1, 0])
w1 = x3 * dx2
with self.assertRaises(ValueError) as cm:
w1.dot()
w1.jet_extend_basis()
dx2.jet_extend_basis()
wdot1 = w1.dot()
self.assertEqual(wdot1, xdot3 * dx2 + x3 * dxdot2)
def test_coeff_ido_do2(self):
x1, x2, x3 = xx = sp.Matrix(sp.symbols("x1, x2, x3"))
xxd = pc.st.time_deriv(xx, xx)
full_basis = pc.st.row_stack(xx, xxd)
foo, ddx = pc.setup_objects(full_basis)
dx1, dx2, dx3, dxdot1, dxdot2, dxdot3 = ddx
aa = sp.Matrix(sp.symbols("a1:10"))
a1, a2, a3, a4, a5, a6, a7, a8, a9 = aa
mu1 = a1 * dxdot1 + 3 * a2 * dx2
mu2 = a3 * dxdot2 - a4 * dx1 + 6 * a5 * dx2
mu3 = 7 * a6 * x1 * dxdot3 + a7 * dx3
sigma1 = (6, 7, 8)
sigma1b = (6 + 3, 7 + 3, 8 + 3)
sigma3 = (5, 6, 7)
with self.assertRaises(ValueError) as cm:
# the indices are too high
pc.coeff_ido_derivorder(sigma1b, mu1, mu2, mu3)
# important to call this before mu_i.jet_extend_basis()
res2, dos = pc.coeff_ido_derivorder(sigma1, mu1, mu2, mu3, tds=aa)
res3, dos = pc.coeff_ido_derivorder(sigma3, mu1, mu2, mu3, tds=aa)
mu1.jet_extend_basis()
mu2.jet_extend_basis()
mu3.jet_extend_basis()
Mu_0 = mu1 ^ mu2 ^ mu3
Mu_1 = mu1.dot(aa) ^ mu2.dot(aa) ^ mu3.dot(aa)
res1, dos = pc.coeff_ido_derivorder(sigma1, mu1, mu2, mu3)
self.assertEqual(Mu_1.get_coeff_from_idcs(sigma1), res2)
self.assertEqual(Mu_1.get_coeff_from_idcs(sigma1), res1)
self.assertEqual(Mu_1.get_coeff_from_idcs(sigma3), res3.subs(dos, 1))
def test_dot_2form(self):
xx = sp.Matrix(sp.symbols("x1, x2, x3"))
xxd = pc.st.time_deriv(xx, xx)
xxdd = pc.st.time_deriv(xx, xx, order=2)
XX = pc.st.row_stack(xx, xxd, xxdd)
foo, ddx = pc.setup_objects(XX)
dx1, dx2, dx3, dxdot1, dxdot2, dxdot3, dxddot1, dxddot2, dxddot3 = ddx
a1, a2 = aa = sp.Matrix(sp.symbols("a1:3"))
adot1, adot2 = aadot = st.time_deriv(aa, aa)
b1, b2 = bb = sp.Matrix(sp.symbols("b1:3"))
z = dx1 ^ dx2
res = z.dot()
# Caution: using * instead of ^ because of pythons operator precedence (+ before ^)
self.assertEqual(res, dxdot1 * dx2 + dx1 * dxdot2)
z = 0 * dx1 ^ dx2
res = z.dot()
self.assertEqual(res, z)
z = a1 * dx1 ^ dx2
res = z.dot(additional_symbols=aa)
self.assertEqual(
res, adot1 * dx1 * dx2 + a1 * dxdot1 * dx2 + a1 * dx1 * dxdot2)
z = a1 * dxdot1 ^ dx2
res = z.dot(additional_symbols=aa)
self.assertEqual(
res,
adot1 * dxdot1 * dx2 + a1 * dxddot1 * dx2 + a1 * dxdot1 * dxdot2)
z = a1 * dx1 * dx2 + a2 * dxdot1 * dx2
res = z.dot(additional_symbols=aa)
exp_res = adot1*dx1*dx2 + (a1 + adot2)*dxdot1*dx2 + a1*dx1*dxdot2 + a2*dxdot1*dxdot2 +\
a2*dxddot1*dx2
self.assertEqual(res, exp_res)
def test_get_multiplied_baseform(self):
x1, x2, x3 = xx = st.symb_vector("x1, x2, x3")
xx, dxx = pc.setup_objects(xx)
dx1, dx2, dx3 = dxx
W = 7 * (dx1 ^ dx2) + 3 * x2 * (dx1 ^ dx3)
res1 = W.get_multiplied_baseform(dx1 ^ dx2)
self.assertEqual(res1, 7 * dx1 ^ dx2)
res2 = W.get_multiplied_baseform(dx2 ^ dx3)
self.assertEqual(res2, 0 * dx1 ^ dx2)
res3 = W.get_multiplied_baseform(dx1 ^ dx3)
self.assertEqual(res3, 3 * x2 * dx1 ^ dx3)
res4 = W.get_multiplied_baseform((0, 1))
self.assertEqual(res4, 7 * dx1 ^ dx2)
res5 = W.get_multiplied_baseform((0, 2))
self.assertEqual(res5, 3 * x2 * dx1 ^ dx3)
res6 = W.get_multiplied_baseform((1, 2))
self.assertEqual(res6, 0 * dx1 ^ dx3)
with self.assertRaises(ValueError) as cm:
res = W.get_multiplied_baseform(dx1)
with self.assertRaises(ValueError) as cm:
res = W.get_multiplied_baseform(x2 * dx1 ^ dx2)
with self.assertRaises(ValueError) as cm:
res = W.get_multiplied_baseform(dx2 ^ dx1)
with self.assertRaises(ValueError) as cm:
res = W.get_multiplied_baseform((1, 0))
def test_dot2(self):
a1, a2, a3 = aa = sp.Matrix(sp.symbols("a1:4"))
adot1, adot2, adot3 = aad = pc.st.time_deriv(aa, aa)
xx = sp.Matrix(sp.symbols("x1, x2, x3"))
xxd = pc.st.time_deriv(xx, xx)
xxdd = pc.st.time_deriv(xx, xx, order=2)
full_basis = pc.st.row_stack(xx, xxd, xxdd)
xx_tmp, ddx = pc.setup_objects(full_basis)
dx1, dx2, dx3, dxdot1, dxdot2, dxdot3, dxddot1, dxddot2, dxddot3 = ddx
w1 = a1 * dx2
wdot1_1 = w1.dot()
self.assertEqual(wdot1_1, a1 * dxdot2)
wdot1_2 = w1.dot(aa)
self.assertEqual(wdot1_2, adot1 * dx2 + a1 * dxdot2)
w2 = a1 * dx2 + a2 * dxdot2
wdot2_expected = adot1 * dx2 + (a1 + adot2) * dxdot2 + a2 * dxddot2
self.assertEqual(wdot2_expected.coeff, w2.dot(aa).coeff)
def test_coeff_ido_do(self):
x1, x2, x3 = xx = sp.Matrix(sp.symbols("x1, x2, x3"))
xxd = pc.st.time_deriv(xx, xx)
xxdd = pc.st.time_deriv(xx, xx, order=2)
full_basis = pc.st.row_stack(xx, xxd, xxdd)
foo, ddx = pc.setup_objects(full_basis)
dx1, dx2, dx3, dxdot1, dxdot2, dxdot3, dxddot1, dxddot2, dxddot3 = ddx
aa = sp.Matrix(sp.symbols("a1:10"))
a1, a2, a3, a4, a5, a6, a7, a8, a9 = aa
aad = pc.st.time_deriv(aa, aa)
#adot1, adot2, adot3 =\
mu1 = a1 * dxdot1 + 3 * a2 * dx2
mu2 = a3 * dxdot2 - a4 * dx1 + 6 * a5 * dx2
mu3 = 7 * a6 * x1 * dxdot3 + a7 * dx3
Mu_0 = mu1 ^ mu2 ^ mu3
Mu_1 = mu1.dot(aa) ^ mu2.dot(aa) ^ mu3.dot(aa)
# this once was a bug:
self.assertEqual(xxdd[0].difforder, 2)
sigma1 = (6, 7, 8)
c_star = a1 * a3 * a6 * x1 * 7
# consistency check for local calculations
self.assertEqual(Mu_1.get_coeff_from_idcs(sigma1), c_star)
# in the following dos means difforder symbol
res1, dos = pc.coeff_ido_derivorder(sigma1, mu1, mu2, mu3, tds=aa)
self.assertEqual(Mu_1.get_coeff_from_idcs(sigma1), res1)
# test array type for sigma
sigma_arr = pc.np.array([6.0, 7.0, 8.0])
res1b, dos = pc.coeff_ido_derivorder(sigma_arr, mu1, mu2, mu3, tds=aa)
self.assertEqual(Mu_1.get_coeff_from_idcs(sigma1), res1b)
sigma2 = (5, 7, 8)
res2, dos = pc.coeff_ido_derivorder(sigma2, mu1, mu2, mu3, tds=aa)
self.assertEqual(res2, 0)
sigma3 = (5, 6, 7)
res3, dos = pc.coeff_ido_derivorder(sigma3, mu1, mu2, mu3, tds=aa)
assert res3.has(dos)
self.assertEqual(Mu_1.get_coeff_from_idcs(sigma3), res3.subs(dos, 1))
mu1.jet_extend_basis()
mu2.jet_extend_basis()
mu3.jet_extend_basis()
Mu_2 = mu1.dot(aa).dot(aa) ^ mu2.dot(aa).dot(aa) ^ mu3.dot(aa).dot(aa)
sigma4 = (5 + 3, 6 + 3, 7 + 3)
res4 = Mu_2.get_coeff_from_idcs(sigma4)
self.assertEqual(res4, res3.subs(dos, 2))
with self.assertRaises(ValueError) as cm:
sigma5 = (1, 6, 7)
pc.coeff_ido_derivorder(sigma5, mu1, mu2, mu3, tds=aa)
def setUp(self):
self.xx, self.dx = pc.setup_objects("x1, x2, x3, x4, x5")
