Calculate Riemann curvature and Ricci tensor from the metric

import sympy as sym
class Riemann:
    """
    Used for defining a Riemann curvature tensor or Ricci tensor
    for a given metric between cartesian coordinates and another
    orthognal coordinate system.
    """
    def __init__(self,g,coords_sys="coordinate_system2",dim=3):
        """
        Contructor __init__ initializes the object for a given
        metric g (symbolic matrix). The metric must be defined
        with sympy variables u and v for the orthoganl basis in
        the Cartesian coordinate system.

        g          : metric defined as nxn Sympy.Matrix object
        coords_sys : descriptive information about the coordinate system
                     besides Cartesian coordinates
        dim        : only in R^2 or R^3
        """
        from sympy.diffgeom import Manifold, Patch
        self.dim = dim
        self.g = g
        self.manifold = Manifold("M",dim)
        self.patch = Patch("P",self.manifold)
        self._set_coordinates(coords_sys)
        self.metric = self._metric_to_twoform(g)
        print self.metric


    def _set_coordinates(self,coord_sys):
        from sympy.diffgeom import CoordSystem
        patch = self.patch
        if self.dim==4:
            cartesian = CoordSystem("cartesian",patch, ["x", "y", "z", "t"])
            x, y, z, t = cartesian.coord_functions()
            system2 = CoordSystem(coord_sys, patch, ["u", "v", "w","t"])
            u, v, w, t = system2.coord_functions()
            self.w = w
            self.t = t


        if self.dim==3:
            cartesian = CoordSystem("cartesian",patch, ["x", "y", "z"])
            x, y, z = cartesian.coord_functions()
            system2 = CoordSystem(coord_sys, patch, ["u", "v", "w"])
            u, v, w = system2.coord_functions()
            self.w = w

        if self.dim==2:
            cartesian = CoordSystem("cartesian",patch, ["x", "y"])
            x, y = cartesian.coord_functions()
            system2 = CoordSystem(coord_sys, patch, ["u", "v"])
            u, v = system2.coord_functions()

        self.u, self.v = u, v
        self.system2 = system2

    def _metric_to_twoform(self,g_):
        dim = self.dim
        system2 = self.system2
        diff_forms = system2.base_oneforms()
        u, v = self.u, self.v
        if dim >= 3:
            w = self.w
        if dim == 4:
            t = self.t

        from sympy import cos, log, exp, cosh, sin, sinh, Matrix
        from sympy.abc import *
        g = Matrix(dim*[dim*[0]])
        # re-evaluate the metric for (u,v,w,t if 4D) which are Basescalar objects
        for i in range(dim):
            for j in range(dim):
                expr = str(g_[i,j])
                g[i,j] = eval(expr)

        from sympy.diffgeom import TensorProduct
        metric_diff_form = sum([TensorProduct(di, dj)*g[i, j]
                               for i, di in enumerate(diff_forms)
                               for j, dj in enumerate(diff_forms)])

        return metric_diff_form

    def _tuple_to_list(self,t):
        return list(map(self._tuple_to_list, t)) if isinstance(t, (list, tuple)) else t

    def _symplify_expr(self,expr): # this is a costly stage for complex expressions
            expr = sym.trigsimp(expr)
            expr = sym.simplify(expr)
            return expr

    def Christoffel_tensor(self,form="simplified"):
        """
        Method determines the Riemann-Christoffel tensor
        for a given metric(which must be in two-form).

        form : default value - "simplified"
        If desired, a simplified form is returned.

        The returned value is a SymPy Matrix.
        """
        from sympy.diffgeom import metric_to_Riemann_components
        metric = self.metric
        R = metric_to_Riemann_components(metric)
        simpR = self._tuple_to_list(R)
        dim = self.dim
        if form=="simplified":
            print 'Performing simplifications on each component....'
            for m in range(dim):
                for i in range(dim):
                    for j in range(dim):
                        for k in range(dim):
                            expr = str(R[m][i][j][k])
                            expr = self._symplify_expr(expr)
                            simpR[m][i][j][k] = expr
        return sym.Matrix(simpR)

    def Ricci_tensor(self,form="simplified"):
        """
        Method determines the Ricci curvature tensor for
        a given metric(which must be in two-form).

        form : default value - "simplified"
        If desired, a simplified form is returned.

        The returned value is a SymPy Matrix.
        """
        from sympy.diffgeom import metric_to_Ricci_components
        metric = self.metric
        RR = metric_to_Ricci_components(metric)
        simpRR = self._tuple_to_list(RR)
        dim = self.dim
        if form=="simplified":
            print 'Performing simplifications on each component....'
            for m in range(dim):
                for i in range(dim):
                    expr = str(RR[m][i])
                    expr = self._symplify_expr(expr)
                    simpRR[m][i] = expr
        simpRR = sym.Matrix(simpRR)
        self.Ricci = simpRR
        return sym.Matrix(simpRR)

    def scalar_curvature(self):
        """
        Method performs scalar contraction on the Ricci tensor.
        """
        try:
            Ricci = self.Ricci
            g = self.g
            scalar_curv = sym.simplify((g**-1)*Ricci)
            scalar_curv = sym.trace(scalar_curv)
        except AttributeError:
            print "Ricci tensor must be determined first."
            return None
        return scalar_curv