def get_inverse_metric_tensor(self, input_vectors=None): G = self.get_metric_tensor().tensor() G_ = MetricTensor(sympy.Matrix(G).inv().as_immutable(), self.model.input_vars) if input_vectors is not None: G_ = self.model.apply(G_.tensor(), input_vectors) return G_
def get_metric_tensor(self, input_vectors=None): J = self.get_jacobian() me = (J.T*J) me.simplify() me = MetricTensor(me.as_immutable(), self.model.input_vars) if input_vectors is not None: me = self.model.apply(me.tensor(), input_vectors) return me
def test_weyl_dim3(): list_metric = np.ones((3, 3), dtype=int).tolist() symbolstr = "t r theta" syms = sympy.symbols(symbolstr) metric = MetricTensor(list_metric, syms) obj = WeylTensor.from_metric(metric).arr assert obj == sympy.Array(np.zeros((3, 3), dtype=int))
def test_check_ValueError_on_incorrect_config_length(): sch = schwarzschild_metric() try: sch_new = MetricTensor(sch.tensor(), sch.syms, config="lll") assert False except ValueError: assert True
def test_TypeError(): list2d = np.zeros((4, 4), dtype=int).tolist() syms = 100 try: obj = MetricTensor(list2d, syms) assert False except TypeError: assert True
def spherical_metric(): symbolstr = "r theta phi" syms = sympy.symbols(symbolstr) list2d = (np.zeros(shape=(3, 3), dtype=int)).tolist() list2d[0][0] = 1 list2d[1][1] = syms[0]**2 list2d[2][2] = (syms[0]**2) * (sympy.sin(syms[1])**2) metric = MetricTensor(list2d, syms) return metric
def euclidean_space_metric(): symbolstr = "e1 e2" # let angle between e1 & e2 be theta syms = symbols(symbolstr) th = symbols("theta") list2d = np.zeros((2, 2), dtype=int).tolist() # defining the metric tensor when axis are not orthogonal list2d[0][0] = list2d[1][1] = 1 list2d[1][0] = list2d[0][1] = cos(th) metric = MetricTensor(list2d, syms, config="ll") return metric
def test_Schouten_dim2(): list_metric = np.zeros((2, 2), dtype=int).tolist() symbolstr = "t r" syms = sympy.symbols(symbolstr) metric = MetricTensor(list_metric, syms) try: obj = SchoutenTensor.from_metric(metric) assert False except ValueError: assert True
def anti_de_sitter_metric(): coords = sympy.symbols("t chi theta phi") t, ch, th, ph = coords m = sympy.diag( -1, cos(t) ** 2, cos(t) ** 2 * sinh(ch) ** 2, cos(t) ** 2 * sinh(ch) ** 2 * sin(th) ** 2, ).tolist() metric = MetricTensor(m, coords) return metric
def test_weyl_conformal_rescaling(): # https://en.wikipedia.org/wiki/Weyl_tensor#Conformal_rescaling a = sympy.symbols("a") mw1 = anti_de_sitter_metric() mw2 = MetricTensor(a * mw1.tensor(), mw1.symbols(), mw1.config) w1 = WeylTensor.from_metric(mw1).change_config("ulll") w2 = WeylTensor.from_metric(mw2).change_config("ulll") cmp_arr = sympy.Array(np.zeros(shape=w1.tensor().shape, dtype=int)) assert simplify_sympy_array(w1.tensor() - w2.tensor()) == cmp_arr assert w1.syms == w1.symbols() assert w1.parent_metric == w1._parent_metric
def schwarzschild_metric(): symbolstr = "t r theta phi" syms = sympy.symbols(symbolstr) G, M, c, a = sympy.symbols("G M c a") # using metric values of schwarschild space-time # a is schwarzschild radius list2d = np.zeros((4, 4), dtype=int).tolist() list2d[0][0] = 1 - (a / syms[1]) list2d[1][1] = -1 / ((1 - (a / syms[1])) * (c ** 2)) list2d[2][2] = -1 * (syms[1] ** 2) / (c ** 2) list2d[3][3] = -1 * (syms[1] ** 2) * (sympy.sin(syms[2]) ** 2) / (c ** 2) sch = MetricTensor(list2d, syms) return sch
def test_change_config(): x, y, z = sympy.symbols("x y z") list3d = np.zeros((3, 3, 3), dtype=int).tolist() for i in range(3): list3d[i][i][i] = (x**i) * (y * (2 - i)) + i * z list3d[1][2][0] = list3d[1][0][2] = x * y * z list3d[2][1][0] = list3d[2][0][1] = 4 * y metriclist = np.identity(3).tolist() metric = MetricTensor(metriclist, (x, y, z), "uu") ch = ChristoffelSymbols(list3d, (x, y, z), "ull", parent_metric=metric) chr_new = ch.change_config("llu") for t in range(3): i, j, k = t % 3, (int(t / 3)) % 3, (int(t / (3**2))) % 3 assert sympy.simplify(ch[i, j, k] - chr_new[i, j, k]) == 0
def metric_tensor(self): from einsteinpy.symbolic import MetricTensor E, F, G = self.E_F_G return MetricTensor([[E, F], [F, G]], self.syms, config='ll')
print(s + latex(Tel) + '\\\\') #Define as coordenadas t, r, theta, phi = symbols('t r theta phi') nu = Function('nu', real=True)(t, r) lamb = Function('lambda', real=True)(t, r) #Define a métrica metric = [[0 for i in range(4)] for i in range(4)] metric[0][0] = exp(nu) metric[1][1] = -exp(lamb) metric[2][2] = -r**2 metric[3][3] = -r**2 * sin(theta)**2 g = MetricTensor(metric, (t, r, theta, phi)) gup = g.change_config('uu') #Calcula o tensor de Riemann, tensor Ricci, escalar de Ricci #e tensor de einstein rm = RiemannCurvatureTensor.from_metric(g) rm = rm.change_config('llll') #Deixa covariante ric = RicciTensor.from_metric(g) #---------------Escrevendo os termos não nulos independentes de Riemann----- non_zero = [] for i, el in enumerate(rm.tensor()): if el != 0: #Salva só os termos não nulos e = simplify(el) a = str(int(i / 64)) b = str(int((i % 64) / 16))