Repository: einsteinpy/einsteinpy

Issue:
Organize and reorder utils for Kerr, Kerr-Newman and Schwarzschild metrics
🐞 **Problem**
As of now, various useful functions used by `metric/schwarzschild.py` are in `utils/schwarzschild_utils.py`. Same goes for `metric/kerr.py` and `metric/kerrnewman.py`. We need to move these functions out of `utils` and make them a core part of library as they are quite-useful even when used stand-alone.

🎯 **Goal**

  - Migrate them somewhere, so as to make them look like a core part of library.
  - Reorder the parameters inside the functions, so as parameters like `c`, `G` etc are made to be optional with default values can be taken in SI units from `constant.py`.
  - Many functions take `Rs` as parameters which is Schwarzschild Radius. However, there is no sense to keep parameters `Rs` as it can be calculated from more fundamental things like mass, speed of light(`c`), gravitational constant(`G`). `Rs = 2*M*G/square(c)`.
  - These changes would break the API, and therefore requires updation of tests and example notebooks.

⏫ **Progress**

The tasks to be taken up in separate PRs
  - [x] Reorder parameters within functions
  - [ ] Move the functions somewhere more suitable

💡 **Possible solutions**

  - Firstly, wherever the functions take `Rs`, i.e schwarzschild radius as an input, replace them with `M`,`G`, and `c` and calculate `Rs = 2*G*M/(c**2)` inside the function itself. We can't expect the user to supply schwarzschild radius. While implementing it, leave out function `delta()` in both `kerr_utils.py` and `kerrnewman_utils.py`.

  - Currently functions are like `func(c, G, Cc, r, theta.....)`. Here the fundamental constants need to be optional arguments and therefore, should be last few parameters like `func(r, theta, ..... , c=default_value, G=default_value, Cc=default_value)`. Leave out `G` and `Cc` whenever not required.
    - `c` is Speed of light. Default value : `einsteinpy.constant.c.value`
    - `G` is gravitational constant. Default value : `einsteinpy.constant.G.value`
    - `Cc` is coulomb's  constant. Default value : `einsteinpy.constant.coulombs_const.value`
  - After the changes, the API would break, therefore, update the example notebooks.
  - Update the user guide
  - Update the tests

📋  **Steps to solve the problem**

 * Comment below about what you've started working on.
 * Add, commit, push your changes
 * Submit a pull request and add this in comments - `Addresses #141`
 * Ask for a review in comments section of pull request
 * Celebrate your contribution to this project 🎉


Discussion:
codecov[bot]: # [Codecov](https://codecov.io/gh/einsteinpy/einsteinpy/pull/196?src=pr&el=h1) Report
> Merging [#196](https://codecov.io/gh/einsteinpy/einsteinpy/pull/196?src=pr&el=desc) into [master](https://codecov.io/gh/einsteinpy/einsteinpy/commit/076219e57f0e572cadca8cae406e3d652239cb94?src=pr&el=desc) will **increase** coverage by `0.06%`.
> The diff coverage is `100%`.

[![Impacted file tree graph](https://codecov.io/gh/einsteinpy/einsteinpy/pull/196/graphs/tree.svg?width=650&token=H3oDVYA11f&height=150&src=pr)](https://codecov.io/gh/einsteinpy/einsteinpy/pull/196?src=pr&el=tree)

```diff
@@            Coverage Diff            @@
##           master    #196      +/-   ##
=========================================
+ Coverage   92.53%   92.6%   +0.06%     
=========================================
  Files          22      22              
  Lines        1005    1014       +9     
=========================================
+ Hits          930     939       +9     
  Misses         75      75
```


| [Impacted Files](https://codecov.io/gh/einsteinpy/einsteinpy/pull/196?src=pr&el=tree) | Coverage Δ | |
|---|---|---|
| [src/einsteinpy/utils/kerr\_utils.py](https://codecov.io/gh/einsteinpy/einsteinpy/pull/196/diff?src=pr&el=tree#diff-c3JjL2VpbnN0ZWlucHkvdXRpbHMva2Vycl91dGlscy5weQ==) | `100% <100%> (ø)` | :arrow_up: |
| [src/einsteinpy/metric/schwarzschild.py](https://codecov.io/gh/einsteinpy/einsteinpy/pull/196/diff?src=pr&el=tree#diff-c3JjL2VpbnN0ZWlucHkvbWV0cmljL3NjaHdhcnpzY2hpbGQucHk=) | `95.34% <100%> (ø)` | :arrow_up: |
| [src/einsteinpy/utils/kerrnewman\_utils.py](https://codecov.io/gh/einsteinpy/einsteinpy/pull/196/diff?src=pr&el=tree#diff-c3JjL2VpbnN0ZWlucHkvdXRpbHMva2Vycm5ld21hbl91dGlscy5weQ==) | `100% <100%> (ø)` | :arrow_up: |
| [src/einsteinpy/metric/kerrnewman.py](https://codecov.io/gh/einsteinpy/einsteinpy/pull/196/diff?src=pr&el=tree#diff-c3JjL2VpbnN0ZWlucHkvbWV0cmljL2tlcnJuZXdtYW4ucHk=) | `91.57% <100%> (ø)` | :arrow_up: |
| [src/einsteinpy/metric/kerr.py](https://codecov.io/gh/einsteinpy/einsteinpy/pull/196/diff?src=pr&el=tree#diff-c3JjL2VpbnN0ZWlucHkvbWV0cmljL2tlcnIucHk=) | `91.11% <100%> (ø)` | :arrow_up: |
| [src/einsteinpy/utils/schwarzschild\_utils.py](https://codecov.io/gh/einsteinpy/einsteinpy/pull/196/diff?src=pr&el=tree#diff-c3JjL2VpbnN0ZWlucHkvdXRpbHMvc2Nod2FyenNjaGlsZF91dGlscy5weQ==) | `100% <100%> (ø)` | :arrow_up: |

------

[Continue to review full report at Codecov](https://codecov.io/gh/einsteinpy/einsteinpy/pull/196?src=pr&el=continue).
> **Legend** - [Click here to learn more](https://docs.codecov.io/docs/codecov-delta)
> `Δ = absolute <relative> (impact)`, `ø = not affected`, `? = missing data`
> Powered by [Codecov](https://codecov.io/gh/einsteinpy/einsteinpy/pull/196?src=pr&el=footer). Last update [076219e...ed5ed26](https://codecov.io/gh/einsteinpy/einsteinpy/pull/196?src=pr&el=lastupdated). Read the [comment docs](https://docs.codecov.io/docs/pull-request-comments).

alpeshjamgade: Duplicate of #194 
ritzvik: Great. I wasn't implying that you immediately change branch from master. I was just suggesting something to follow in future.

Again, I'll be reviewing it within a day or two.

Thanks @alpeshjamgade 🙂 
pep8speaks: Hello @alpeshjamgade! Thanks for updating this PR. We checked the lines you've touched for [PEP 8](https://www.python.org/dev/peps/pep-0008) issues, and found:

















* In the file [`src/einsteinpy/utils/kerr_utils.py`](https://github.com/einsteinpy/einsteinpy/blob/bb509fd47034e730b81eaaff5b750110c8b75cf1/src/einsteinpy/utils/kerr_utils.py):

> [Line 127:1](https://github.com/einsteinpy/einsteinpy/blob/bb509fd47034e730b81eaaff5b750110c8b75cf1/src/einsteinpy/utils/kerr_utils.py#L127): [W293](https://duckduckgo.com/?q=pep8%20W293) blank line contains whitespace
> [Line 167:1](https://github.com/einsteinpy/einsteinpy/blob/bb509fd47034e730b81eaaff5b750110c8b75cf1/src/einsteinpy/utils/kerr_utils.py#L167): [W293](https://duckduckgo.com/?q=pep8%20W293) blank line contains whitespace
> [Line 194:1](https://github.com/einsteinpy/einsteinpy/blob/bb509fd47034e730b81eaaff5b750110c8b75cf1/src/einsteinpy/utils/kerr_utils.py#L194): [W293](https://duckduckgo.com/?q=pep8%20W293) blank line contains whitespace
> [Line 262:1](https://github.com/einsteinpy/einsteinpy/blob/bb509fd47034e730b81eaaff5b750110c8b75cf1/src/einsteinpy/utils/kerr_utils.py#L262): [W293](https://duckduckgo.com/?q=pep8%20W293) blank line contains whitespace

* In the file [`src/einsteinpy/utils/kerrnewman_utils.py`](https://github.com/einsteinpy/einsteinpy/blob/bb509fd47034e730b81eaaff5b750110c8b75cf1/src/einsteinpy/utils/kerrnewman_utils.py):

> [Line 140:1](https://github.com/einsteinpy/einsteinpy/blob/bb509fd47034e730b81eaaff5b750110c8b75cf1/src/einsteinpy/utils/kerrnewman_utils.py#L140): [W293](https://duckduckgo.com/?q=pep8%20W293) blank line contains whitespace
> [Line 196:1](https://github.com/einsteinpy/einsteinpy/blob/bb509fd47034e730b81eaaff5b750110c8b75cf1/src/einsteinpy/utils/kerrnewman_utils.py#L196): [W293](https://duckduckgo.com/?q=pep8%20W293) blank line contains whitespace
> [Line 237:1](https://github.com/einsteinpy/einsteinpy/blob/bb509fd47034e730b81eaaff5b750110c8b75cf1/src/einsteinpy/utils/kerrnewman_utils.py#L237): [W293](https://duckduckgo.com/?q=pep8%20W293) blank line contains whitespace
> [Line 254:1](https://github.com/einsteinpy/einsteinpy/blob/bb509fd47034e730b81eaaff5b750110c8b75cf1/src/einsteinpy/utils/kerrnewman_utils.py#L254): [W293](https://duckduckgo.com/?q=pep8%20W293) blank line contains whitespace
> [Line 338:1](https://github.com/einsteinpy/einsteinpy/blob/bb509fd47034e730b81eaaff5b750110c8b75cf1/src/einsteinpy/utils/kerrnewman_utils.py#L338): [W293](https://duckduckgo.com/?q=pep8%20W293) blank line contains whitespace
> [Line 395:1](https://github.com/einsteinpy/einsteinpy/blob/bb509fd47034e730b81eaaff5b750110c8b75cf1/src/einsteinpy/utils/kerrnewman_utils.py#L395): [W293](https://duckduckgo.com/?q=pep8%20W293) blank line contains whitespace
> [Line 440:1](https://github.com/einsteinpy/einsteinpy/blob/bb509fd47034e730b81eaaff5b750110c8b75cf1/src/einsteinpy/utils/kerrnewman_utils.py#L440): [W293](https://duckduckgo.com/?q=pep8%20W293) blank line contains whitespace
> [Line 496:1](https://github.com/einsteinpy/einsteinpy/blob/bb509fd47034e730b81eaaff5b750110c8b75cf1/src/einsteinpy/utils/kerrnewman_utils.py#L496): [W293](https://duckduckgo.com/?q=pep8%20W293) blank line contains whitespace

* In the file [`src/einsteinpy/utils/schwarzschild_utils.py`](https://github.com/einsteinpy/einsteinpy/blob/bb509fd47034e730b81eaaff5b750110c8b75cf1/src/einsteinpy/utils/schwarzschild_utils.py):

> [Line 72:1](https://github.com/einsteinpy/einsteinpy/blob/bb509fd47034e730b81eaaff5b750110c8b75cf1/src/einsteinpy/utils/schwarzschild_utils.py#L72): [W293](https://duckduckgo.com/?q=pep8%20W293) blank line contains whitespace
> [Line 103:1](https://github.com/einsteinpy/einsteinpy/blob/bb509fd47034e730b81eaaff5b750110c8b75cf1/src/einsteinpy/utils/schwarzschild_utils.py#L103): [W293](https://duckduckgo.com/?q=pep8%20W293) blank line contains whitespace


ritzvik: I have submitted a review @alpeshjamgade . The crux is add `G=constant.G` as non-default parameter wherever required as user might want to give different values of `G`.
Really great efforts!! 
Thanks @alpeshjamgade 
ritzvik: It would be great if you could update the Jupyter notebook `Visualizing event horizon and ergosphere of Kerr black hole.rst` in `docs/source` as the change in API would break it!
ritzvik: In `schwarzschild_radius()` function could you use parameters `mass, c=constant.c, G=constant.G` and then handle them internally as you did with `mass` variable using `isinstance()`.
alpeshjamgade: > 
> 
> In `schwarzschild_radius()` function could you use parameters `mass, c=constant.c, G=constant.G` and then handle them internally as you did with `mass` variable using `isinstance()`.

ok

ritzvik: Only on test case is failing. I'll look at the issue! 😃 
alpeshjamgade: 

i dont understand i did isort and black but it is still showing failed.

ritzvik: @alpeshjamgade Somehow your dev environment got messed up I guess and so isort is not working properly. However I created a pull request to your `experimental` branch. Merge that, and it may get fixed. 

After this you might wanna reset your dev environment.

![26](https://user-images.githubusercontent.com/24695764/56377866-06df7600-6229-11e9-952f-8fff7fa7d7dd.PNG)

ritzvik: > @alpeshjamgade Somehow your dev environment got messed up I guess and so isort is not working properly. However I created a pull request to your `experimental` branch. Merge that, and it may get fixed.
> 
> After this you might wanna reset your dev environment.
> 
> ![26](https://user-images.githubusercontent.com/24695764/56377866-06df7600-6229-11e9-952f-8fff7fa7d7dd.PNG)

I've updated my PR as you force-pushed in between 🤣 
ritzvik: Finally the PR is complete AFAIK. @alpeshjamgade Really tremendous efforts from your side and thanks for your patience.
alpeshjamgade: > 
> 
> Finally the PR is complete AFAIK. @alpeshjamgade Really tremendous efforts from your side and thanks for your patience.

thank you for your help.
ritzvik: @shreyasbapat I've reviewed the PR from my side thoroughly. See to it and I believe this is ready to be MERGED !
shreyasbapat: > @shreyasbapat I've reviewed the PR from my side thoroughly. See to it and I believe this is ready to be MERGED !

On it !

> Really tremendous efforts from your side and thanks for your patience.

Thanks @alpeshjamgade  :) . I will review it once. This might be the last time you are making any changes to it. 

shreyasbapat: This will need a rebase

Patch:
diff --git a/docs/source/examples/Visualizing_event_horizon_and_ergosphere_of_Kerr_black_hole.ipynb b/docs/source/examples/Visualizing_event_horizon_and_ergosphere_of_Kerr_black_hole.ipynb
index 14e5766..81d69d4 100644
--- a/docs/source/examples/Visualizing_event_horizon_and_ergosphere_of_Kerr_black_hole.ipynb
+++ b/docs/source/examples/Visualizing_event_horizon_and_ergosphere_of_Kerr_black_hole.ipynb
@@ -58,10 +58,10 @@
     "ergo1, ergo2, hori1, hori2 = list(), list(), list(), list()\n",
     "thetas = np.linspace(0, np.pi, 720)\n",
     "for t in thetas:\n",
-    "    ergo1.append(kerr_utils.radius_ergosphere(scr, a1, t, \"Spherical\"))\n",
-    "    ergo2.append(kerr_utils.radius_ergosphere(scr, a2, t, \"Spherical\"))\n",
-    "    hori1.append(kerr_utils.event_horizon(scr, a1, t, \"Spherical\"))\n",
-    "    hori2.append(kerr_utils.event_horizon(scr, a2, t, \"Spherical\"))\n",
+    "    ergo1.append(kerr_utils.radius_ergosphere(M, a1, t, \"Spherical\"))\n",
+    "    ergo2.append(kerr_utils.radius_ergosphere(M, a2, t, \"Spherical\"))\n",
+    "    hori1.append(kerr_utils.event_horizon(M, a1, t, \"Spherical\"))\n",
+    "    hori2.append(kerr_utils.event_horizon(M, a2, t, \"Spherical\"))\n",
     "ergo1, ergo2, hori1, hori2 = np.array(ergo1), np.array(ergo2), np.array(hori1), np.array(hori2)"
    ]
   },
diff --git a/src/einsteinpy/metric/kerr.py b/src/einsteinpy/metric/kerr.py
index 0cba6ed..6a81b84 100644
--- a/src/einsteinpy/metric/kerr.py
+++ b/src/einsteinpy/metric/kerr.py
@@ -115,9 +115,7 @@ class Kerr:
         return cls._classmethod_handler(bl_pos_vec, bl_vel_vec, time, M, a)
 
     def f_vec(self, ld, vec):
-        chl = kerr_utils.christoffels(
-            _c, vec[1], vec[2], self.schwarzschild_r.value, self.a
-        )
+        chl = kerr_utils.christoffels(vec[1], vec[2], self.M.value, self.a)
         vals = np.zeros(shape=(8,), dtype=float)
         for i in range(4):
             vals[i] = vec[i + 4]
@@ -193,9 +191,7 @@ class Kerr:
             **OdeMethodKwargs
         )
         _scr = self.schwarzschild_r.value * 1.001
-        _event_hor = (
-            kerr_utils.event_horizon(self.schwarzschild_r.value, self.a)[0] * 1.001
-        )
+        _event_hor = kerr_utils.event_horizon(self.M.value, self.a)[0] * 1.001
         while ODE.t < end_lambda:
             vec_list.append(ODE.y)
             lambda_list.append(ODE.t)
@@ -267,9 +263,7 @@ class Kerr:
             **OdeMethodKwargs
         )
         _scr = self.schwarzschild_r.value * 1.001
-        _event_hor = (
-            kerr_utils.event_horizon(self.schwarzschild_r.value, self.a)[0] * 1.001
-        )
+        _event_hor = kerr_utils.event_horizon(self.M.value, self.a)[0] * 1.001
 
         def yielder_func():
             nonlocal singularity_reached
diff --git a/src/einsteinpy/metric/kerrnewman.py b/src/einsteinpy/metric/kerrnewman.py
index 74fe733..2e041b9 100644
--- a/src/einsteinpy/metric/kerrnewman.py
+++ b/src/einsteinpy/metric/kerrnewman.py
@@ -136,13 +136,13 @@ class KerrNewman:
     def f_vec(self, ld, vec):
         _scr = self.schwarzschild_r.value
         chl = kerrnewman_utils.christoffels(
-            _c, _G, _Cc, vec[1], vec[2], _scr, self.a, self.Q.value
+            vec[1], vec[2], self.M.value, self.a, self.Q.value
         )
         maxwell = kerrnewman_utils.maxwell_tensor_contravariant(
-            _c, _G, _Cc, vec[1], vec[2], self.a, self.Q.value, self.M.value
+            vec[1], vec[2], self.a, self.Q.value, self.M.value
         )
         metric = kerrnewman_utils.metric(
-            _c, _G, _Cc, vec[1], vec[2], _scr, self.a, self.Q.value
+            vec[1], vec[2], self.M.value, self.a, self.Q.value
         )
         vals = np.zeros(shape=(8,), dtype=float)
         for i in range(4):
diff --git a/src/einsteinpy/metric/schwarzschild.py b/src/einsteinpy/metric/schwarzschild.py
index cc520c4..7bac69b 100644
--- a/src/einsteinpy/metric/schwarzschild.py
+++ b/src/einsteinpy/metric/schwarzschild.py
@@ -108,9 +108,7 @@ class Schwarzschild:
 
     def f_vec(self, ld, vec):
         vals = np.zeros(shape=vec.shape, dtype=vec.dtype)
-        chl = schwarzschild_utils.christoffels(
-            _c, vec[1], vec[2], self.schwarzschild_r.value
-        )
+        chl = schwarzschild_utils.christoffels(vec[1], vec[2], self.M.value)
         vals[:4] = vec[4:8]
         vals[4] = -2 * chl[0, 0, 1] * vec[4] * vec[5]
         vals[5] = -1 * (
diff --git a/src/einsteinpy/plotting/geodesics_static.py b/src/einsteinpy/plotting/geodesics_static.py
index 7e3b469..cb8b7f0 100644
--- a/src/einsteinpy/plotting/geodesics_static.py
+++ b/src/einsteinpy/plotting/geodesics_static.py
@@ -46,7 +46,7 @@ class StaticGeodesicPlotter:
             self._draw_attractor()
 
     def _draw_attractor(self, min_radius=10 * u.km):
-        radius = max(schwarzschild_radius(self.mass) * 10000, min_radius.to(u.km))
+        radius = max((schwarzschild_radius(self.mass) * 10000), min_radius.to(u.km))
         color = "#ffcc00"
         self.ax.add_patch(mpl.patches.Circle((0, 0), radius.value, lw=0, color=color))
 
diff --git a/src/einsteinpy/utils/__init__.py b/src/einsteinpy/utils/__init__.py
index 57d3f1b..43e4fb5 100644
--- a/src/einsteinpy/utils/__init__.py
+++ b/src/einsteinpy/utils/__init__.py
@@ -1,4 +1,8 @@
 from .bl_coord_transforms import *
 from .coord_transforms import *
 from .scalar_factor import scalar_factor, scalar_factor_derivative
-from .schwarzschild_utils import schwarzschild_radius, time_velocity
+from .schwarzschild_utils import (
+    schwarzschild_radius,
+    schwarzschild_radius_dimensionless,
+    time_velocity,
+)
diff --git a/src/einsteinpy/utils/kerr_utils.py b/src/einsteinpy/utils/kerr_utils.py
index 2dc5053..5943fbb 100644
--- a/src/einsteinpy/utils/kerr_utils.py
+++ b/src/einsteinpy/utils/kerr_utils.py
@@ -2,6 +2,7 @@ import astropy.units as u
 import numpy as np
 
 from einsteinpy import constant, utils
+from einsteinpy.utils import schwarzschild_radius_dimensionless
 
 nonzero_christoffels_list = [
     (0, 0, 1),
@@ -65,7 +66,7 @@ def scaled_spin_factor(a, M, c=constant.c.value, G=constant.G.value):
         If a not between 0 & 1
 
     """
-    half_scr = G * M / (c ** 2)
+    half_scr = (schwarzschild_radius_dimensionless(M, c, G)) / 2
     if a < 0 or a > 1:
         raise ValueError("a to be supplied between 0 and 1")
     return a * half_scr
@@ -94,7 +95,7 @@ def sigma(r, theta, a):
     return (r ** 2) + ((a * np.cos(theta)) ** 2)
 
 
-def delta(r, Rs, a):
+def delta(r, M, a, c=constant.c.value, G=constant.G.value):
     """
     Returns the value r^2 - Rs * r + a^2
     Specific to Boyer-Lindquist coordinates
@@ -103,8 +104,8 @@ def delta(r, Rs, a):
     ----------
     r : float
         Component r in vector
-    Rs : float
-        Schwarzschild radius
+    M : float
+        Mass of massive body
     a : float
         Any constant
 
@@ -114,34 +115,36 @@ def delta(r, Rs, a):
         The value r^2 - Rs * r + a^2
     
     """
+    Rs = schwarzschild_radius_dimensionless(M, c, G)
     return (r ** 2) - (Rs * r) + (a ** 2)
 
 
-def metric(c, r, theta, Rs, a):
+def metric(r, theta, M, a, c=constant.c.value, G=constant.G.value):
     """
     Returns the Kerr Metric
 
     Parameters
     ----------
-    c : float
-        Speed of light
+    
     r : float
         Distance from the centre
     theta : float
         Angle from z-axis
-    Rs : float
-        Schwarzschild Radius
+    M : float
+        Mass of massive body
     a : float
         Black Hole spin factor
-
+    c : float
+        Speed of light
     Returns
     -------
     ~numpy.array
         Numpy array of shape (4,4)
 
     """
+    Rs = schwarzschild_radius_dimensionless(M, c, G)
     m = np.zeros(shape=(4, 4), dtype=float)
-    sg, dl = sigma(r, theta, a), delta(r, Rs, a)
+    sg, dl = sigma(r, theta, a), delta(r, M, a, c, G)
     c2 = c ** 2
     # set the diagonal/off-diagonal terms of metric
     m[0, 0] = 1 - (Rs * r / sg)
@@ -156,50 +159,50 @@ def metric(c, r, theta, Rs, a):
     return m
 
 
-def metric_inv(c, r, theta, Rs, a):
+def metric_inv(r, theta, M, a, c=constant.c.value, G=constant.G.value):
     """
     Returns the inverse of Kerr Metric
 
     Parameters
     ----------
-    c : float
-        Speed of light
+    
     r : float
         Distance from the centre
     theta : float
         Angle from z-axis
-    Rs : float
-        Schwarzschild Radius
+    M : float
+        Mass of massive body
     a : float
         Black Hole spin factor
-
+    c : float
+        Speed of light
     Returns
     -------
     ~numpy.array
         Numpy array of shape (4,4)
 
     """
-    m = metric(c, r, theta, Rs, a)
+    m = metric(r, theta, M, a, c, G)
     return np.linalg.inv(m)
 
 
-def dmetric_dx(c, r, theta, Rs, a):
+def dmetric_dx(r, theta, M, a, c=constant.c.value, G=constant.G.value):
     """
     Returns differentiation of each component of Kerr metric tensor w.r.t. t, r, theta, phi
 
     Parameters
     ----------
-    c : float
-        Speed of light
+    
     r : float
         Distance from the centre
     theta : float
         Angle from z-axis
-    Rs : float
-        Schwarzschild Radius
+    M : float
+        Mass of massive body
     a : float
         Black Hole spin factor
-
+    c : float
+        Speed of light
     Returns
     -------
     dmdx : ~numpy.array
@@ -207,8 +210,9 @@ def dmetric_dx(c, r, theta, Rs, a):
         dmdx[0], dmdx[1], dmdx[2] & dmdx[3] is differentiation of metric w.r.t. t, r, theta & phi respectively
 
     """
+    Rs = schwarzschild_radius_dimensionless(M, c, G)
     dmdx = np.zeros(shape=(4, 4, 4), dtype=float)
-    sg, dl = sigma(r, theta, a), delta(r, Rs, a)
+    sg, dl = sigma(r, theta, a), delta(r, M, a, c, G)
     c2 = c ** 2
     # metric is invariant on t & phi
     # differentiation of metric wrt r
@@ -250,31 +254,31 @@ def dmetric_dx(c, r, theta, Rs, a):
     return dmdx
 
 
-def christoffels(c, r, theta, Rs, a):
+def christoffels(r, theta, M, a, c=constant.c.value, G=constant.G.value):
     """
     Returns the 3rd rank Tensor containing Christoffel Symbols for Kerr Metric
 
     Parameters
     ----------
-    c : float
-        Speed of light
+    
     r : float
         Distance from the centre
     theta : float
         Angle from z-axis
-    Rs : float
-        Schwarzschild Radius
+    M : float
+        Mass of massive body
     a : float
         Black Hole spin factor
-
+    c : float
+        Speed of light
     Returns
     -------
     ~numpy.array
         Numpy array of shape (4,4,4)
 
     """
-    invg = metric_inv(c, r, theta, Rs, a)
-    dmdx = dmetric_dx(c, r, theta, Rs, a)
+    invg = metric_inv(r, theta, M, a, c, G)
+    dmdx = dmetric_dx(r, theta, M, a, c, G)
     chl = np.zeros(shape=(4, 4, 4), dtype=float)
     for _, k, l in nonzero_christoffels_list[0:4]:
         val1 = dmdx[l, 0, k] + dmdx[k, 0, l]
@@ -314,8 +318,7 @@ def kerr_time_velocity(pos_vec, vel_vec, mass, a):
         Velocity of time
 
     """
-    _scr = utils.schwarzschild_radius(mass).value
-    g = metric(constant.c.value, pos_vec[0], pos_vec[1], _scr, a)
+    g = metric(pos_vec[0], pos_vec[1], mass.value, a)
     A = g[0, 0]
     B = 2 * g[0, 3]
     C = (
@@ -386,14 +389,16 @@ def spin_factor(J, M, c):
     return J / (M * c)
 
 
-def event_horizon(Rs, a, theta=np.pi / 2, coord="BL"):
+def event_horizon(
+    M, a, theta=np.pi / 2, coord="BL", c=constant.c.value, G=constant.G.value
+):
     """
     Calculate the radius of event horizon of Kerr black hole
 
     Parameters
     ----------
-    Rs : float
-        Schwarzschild Radius
+    M : float
+        Mass of massive body
     a : float
         Black hole spin factor
     theta : float
@@ -407,6 +412,7 @@ def event_horizon(Rs, a, theta=np.pi / 2, coord="BL"):
         [Radius of event horizon(R), angle from z axis(theta)] in BL/Spherical coordinates
     
     """
+    Rs = schwarzschild_radius_dimensionless(M, c, G)
     Rh = 0.5 * (Rs + np.sqrt((Rs ** 2) - 4 * (a ** 2)))
     if coord == "BL":
         ans = np.array([Rh, theta], dtype=float)
@@ -417,14 +423,16 @@ def event_horizon(Rs, a, theta=np.pi / 2, coord="BL"):
     return ans
 
 
-def radius_ergosphere(Rs, a, theta=np.pi / 2, coord="BL"):
+def radius_ergosphere(
+    M, a, theta=np.pi / 2, coord="BL", c=constant.c.value, G=constant.G.value
+):
     """
     Calculate the radius of ergospere of Kerr black hole at a specific azimuthal angle
 
     Parameters
     ----------
-    Rs : float
-        Schwarzschild Radius
+    M : float
+        Mass of massive body
     a : float
         Black hole spin factor
     theta : float
@@ -438,6 +446,7 @@ def radius_ergosphere(Rs, a, theta=np.pi / 2, coord="BL"):
         [Radius of ergosphere(R), angle from z axis(theta)] in BL/Spherical coordinates
     
     """
+    Rs = schwarzschild_radius_dimensionless(M, c, G)
     Re = 0.5 * (Rs + np.sqrt((Rs ** 2) - 4 * (a ** 2) * (np.cos(theta) ** 2)))
     if coord == "BL":
         ans = np.array([Re, theta], dtype=float)
diff --git a/src/einsteinpy/utils/kerrnewman_utils.py b/src/einsteinpy/utils/kerrnewman_utils.py
index 6233617..288e97a 100644
--- a/src/einsteinpy/utils/kerrnewman_utils.py
+++ b/src/einsteinpy/utils/kerrnewman_utils.py
@@ -88,7 +88,9 @@ def rho(r, theta, a):
     return np.sqrt((r ** 2) + ((a * np.cos(theta)) ** 2))
 
 
-def delta(r, Rs, a, Q, c, G, Cc):
+def delta(
+    r, M, a, Q, c=constant.c.value, G=constant.G.value, Cc=constant.coulombs_const.value
+):
     """
     Returns the value r^2 - Rs * r + a^2
     Specific to Boyer-Lindquist coordinates
@@ -97,8 +99,8 @@ def delta(r, Rs, a, Q, c, G, Cc):
     ----------
     r : float
         Component r in vector
-    Rs : float
-        Schwarzschild radius
+    M : float
+        Mass of the massive body
     a : float
         Any constant
     Q : float
@@ -116,32 +118,42 @@ def delta(r, Rs, a, Q, c, G, Cc):
         The value r^2 - Rs * r + a^2 + Rq^2
     
     """
+    Rs = utils.schwarzschild_radius_dimensionless(M, c, G)
     return (r ** 2) - (Rs * r) + (a ** 2) + (charge_length_scale(Q, c, G, Cc) ** 2)
 
 
-def metric(c, G, Cc, r, theta, Rs, a, Q):
+def metric(
+    r,
+    theta,
+    M,
+    a,
+    Q,
+    c=constant.c.value,
+    G=constant.G.value,
+    Cc=constant.coulombs_const.value,
+):
     """
     Returns the Kerr-Newman Metric
 
     Parameters
     ----------
-    c : float
-        Speed of light
-    G : float
-        Gravitational constant
-    Cc : float
-        Coulomb's constant
+    
     r : float
         Distance from the centre
     theta : float
         Angle from z-axis
-    Rs : float
-        Schwarzschild Radius
+    M : float
+        Mass of the massive body
     a : float
         Black Hole spin factor
     Q : float
         Charge on the massive body
-
+    c : float
+        Speed of light
+    G : float
+        Gravitational constant
+    Cc : float
+        Coulomb's constant
     Returns
     -------
     ~numpy.array
@@ -149,7 +161,7 @@ def metric(c, G, Cc, r, theta, Rs, a, Q):
 
     """
     m = np.zeros((4, 4), dtype=float)
-    rh2, dl = rho(r, theta, a) ** 2, delta(r, Rs, a, Q, c, G, Cc)
+    rh2, dl = rho(r, theta, a) ** 2, delta(r, M, a, Q, c, G, Cc)
     c2 = c ** 2
     # set the diagonal/off-diagonal terms of metric
     m[0, 0] = (dl - ((a * np.sin(theta)) ** 2)) / (rh2)
@@ -166,61 +178,80 @@ def metric(c, G, Cc, r, theta, Rs, a, Q):
     return m
 
 
-def metric_inv(c, G, Cc, r, theta, Rs, a, Q):
+def metric_inv(
+    r,
+    theta,
+    M,
+    a,
+    Q,
+    c=constant.c.value,
+    G=constant.G.value,
+    Cc=constant.coulombs_const.value,
+):
     """
     Returns the inverse of Kerr-Newman Metric
 
     Parameters
     ----------
-    c : float
-        Speed of light
-    G : float
-        Gravitational constant
-    Cc : float
-        Coulomb's constant
+    
     r : float
         Distance from the centre
     theta : float
         Angle from z-axis
-    Rs : float
-        Schwarzschild Radius
+    M : float
+        Mass of the massive body
     a : float
         Black Hole spin factor
     Q : float
         Charge on the massive body
-
+    c : float
+        Speed of light
+    G : float
+        Gravitational constant
+    Cc : float
+        Coulomb's constant
     Returns
     -------
     ~numpy.array
         Numpy array of shape (4,4)
 
     """
-    return np.linalg.inv(metric(c, G, Cc, r, theta, Rs, a, Q))
-
-
-def dmetric_dx(c, G, Cc, r, theta, Rs, a, Q):
+    return np.linalg.inv(metric(r, theta, M, a, Q, c, G, Cc))
+
+
+def dmetric_dx(
+    r,
+    theta,
+    M,
+    a,
+    Q,
+    c=constant.c.value,
+    G=constant.G.value,
+    Cc=constant.coulombs_const.value,
+):
     """
     Returns differentiation of each component of Kerr-Newman metric tensor w.r.t. t, r, theta, phi
 
     Parameters
     ----------
-    c : float
-        Speed of light
-    G : float
-        Gravitational constant
-    Cc : float
-        Coulomb's constant
+    
     r : float
         Distance from the centre
     theta : float
         Angle from z-axis
-    Rs : float
-        Schwarzschild Radius
+    M : float
+        Mass of the massive body
     a : float
         Black Hole spin factor
     Q : float
         Charge on the massive body
-
+    c : float
+        Speed of light
+    G : float
+        Gravitational constant
+    Cc : float
+        Coulomb's constant
+    
     Returns
     -------
     dmdx : ~numpy.array
@@ -228,8 +259,9 @@ def dmetric_dx(c, G, Cc, r, theta, Rs, a, Q):
         dmdx[0], dmdx[1], dmdx[2] & dmdx[3] is differentiation of metric w.r.t. t, r, theta & phi respectively
 
     """
+    Rs = utils.schwarzschild_radius_dimensionless(M, c, G)
     dmdx = np.zeros((4, 4, 4), dtype=float)
-    rh2, dl = rho(r, theta, a) ** 2, delta(r, Rs, a, Q, c, G, Cc)
+    rh2, dl = rho(r, theta, a) ** 2, delta(r, M, a, Q, c, G, Cc)
     c2 = c ** 2
     # metric is invariant on t & phi
     # differentiation of metric wrt r
@@ -288,37 +320,46 @@ def dmetric_dx(c, G, Cc, r, theta, Rs, a, Q):
     return dmdx
 
 
-def christoffels(c, G, Cc, r, theta, Rs, a, Q):
+def christoffels(
+    r,
+    theta,
+    M,
+    a,
+    Q,
+    c=constant.c.value,
+    G=constant.G.value,
+    Cc=constant.coulombs_const.value,
+):
     """
     Returns the 3rd rank Tensor containing Christoffel Symbols for Kerr-Newman Metric
 
     Parameters
     ----------
-    c : float
-        Speed of light
-    G : float
-        Gravitational constant
-    Cc : float
-        Coulomb's constant
+    
     r : float
         Distance from the centre
     theta : float
         Angle from z-axis
-    Rs : float
-        Schwarzschild Radius
+    M : float
+        Mass of the massive body
     a : float
         Black Hole spin factor
     Q : float
         Charge on the massive body
-
+    c : float
+        Speed of light
+    G : float
+        Gravitational constant
+    Cc : float
+        Coulomb's constant
     Returns
     -------
     ~numpy.array
         Numpy array of shape (4,4,4)
 
     """
-    invg = metric_inv(c, G, Cc, r, theta, Rs, a, Q)
-    dmdx = dmetric_dx(c, G, Cc, r, theta, Rs, a, Q)
+    invg = metric_inv(r, theta, M, a, Q, c, G, Cc)
+    dmdx = dmetric_dx(r, theta, M, a, Q, c, G, Cc)
     chl = np.zeros(shape=(4, 4, 4), dtype=float)
     for _, k, l in nonzero_christoffels_list[0:4]:
         val1 = dmdx[l, 0, k] + dmdx[k, 0, l]
@@ -336,18 +377,22 @@ def christoffels(c, G, Cc, r, theta, Rs, a, Q):
     return chl
 
 
-def em_potential(c, G, Cc, r, theta, a, Q, M):
+def em_potential(
+    r,
+    theta,
+    a,
+    Q,
+    M,
+    c=constant.c.value,
+    G=constant.G.value,
+    Cc=constant.coulombs_const.value,
+):
     """
     Returns a 4-d vector(for each component of 4-d space-time) containing the electromagnetic potential around a Kerr-Newman body
 
     Parameters
     ----------
-    c : float
-        Speed of light
-    G : float
-        Gravitational constant
-    Cc : float
-        Coulomb's constant
+    
     r : float
         Distance from the centre
     theta : float
@@ -358,7 +403,12 @@ def em_potential(c, G, Cc, r, theta, a, Q, M):
         Charge on the massive body
     M : float
         Mass of the massive body
-
+    c : float
+        Speed of light
+    G : float
+        Gravitational constant
+    Cc : float
+        Coulomb's constant
     Returns
     -------
     ~numpy.array
@@ -372,18 +422,22 @@ def em_potential(c, G, Cc, r, theta, a, Q, M):
     return vec
 
 
-def maxwell_tensor_covariant(c, G, Cc, r, theta, a, Q, M):
+def maxwell_tensor_covariant(
+    r,
+    theta,
+    a,
+    Q,
+    M,
+    c=constant.c.value,
+    G=constant.G.value,
+    Cc=constant.coulombs_const.value,
+):
     """
     Returns a 2nd rank Tensor containing Maxwell Tensor with lower indices for Kerr-Newman Metric
 
     Parameters
     ----------
-    c : float
-        Speed of light
-    G : float
-        Gravitational constant
-    Cc : float
-        Coulomb's constant
+    
     r : float
         Distance from the centre
     theta : float
@@ -394,7 +448,12 @@ def maxwell_tensor_covariant(c, G, Cc, r, theta, a, Q, M):
         Charge on the massive body
     M : float
         Mass of the massive body
-
+    c : float
+        Speed of light
+    G : float
+        Gravitational constant
+    Cc : float
+        Coulomb's constant
     Returns
     -------
     ~numpy.array
@@ -419,18 +478,22 @@ def maxwell_tensor_covariant(c, G, Cc, r, theta, a, Q, M):
     return m
 
 
-def maxwell_tensor_contravariant(c, G, Cc, r, theta, a, Q, M):
+def maxwell_tensor_contravariant(
+    r,
+    theta,
+    a,
+    Q,
+    M,
+    c=constant.c.value,
+    G=constant.G.value,
+    Cc=constant.coulombs_const.value,
+):
     """
     Returns a 2nd rank Tensor containing Maxwell Tensor with upper indices for Kerr-Newman Metric
 
     Parameters
     ----------
-    c : float
-        Speed of light
-    G : float
-        Gravitational constant
-    Cc : float
-        Coulomb's constant
+    
     r : float
         Distance from the centre
     theta : float
@@ -441,16 +504,20 @@ def maxwell_tensor_contravariant(c, G, Cc, r, theta, a, Q, M):
         Charge on the massive body
     M : float
         Mass of the massive body
-
+    c : float
+        Speed of light
+    G : float
+        Gravitational constant
+    Cc : float
+        Coulomb's constant
     Returns
     -------
     ~numpy.array
         Numpy array of shape (4,4)
 
     """
-    Rs = 2 * G * M / (c ** 2)
-    mcov = maxwell_tensor_covariant(c, G, Cc, r, theta, a, Q, M)
-    ginv = metric_inv(c, G, Cc, r, theta, Rs, a, Q)
+    mcov = maxwell_tensor_covariant(r, theta, a, Q, M, c, G, Cc)
+    ginv = metric_inv(r, theta, M, a, Q, c, G, Cc)
     # contravariant F = contravariant g X covariant F X transpose(contravariant g)
     # but g is symettric
     return np.matmul(np.matmul(ginv, mcov), ginv)
@@ -482,16 +549,7 @@ def kerrnewman_time_velocity(pos_vec, vel_vec, mass, a, Q):
     """
     _scr = utils.schwarzschild_radius(mass).value
     Qc = Q.to(u.C)
-    g = metric(
-        constant.c.value,
-        constant.G.value,
-        constant.coulombs_const.value,
-        pos_vec[0],
-        pos_vec[1],
-        _scr,
-        a,
-        Qc.value,
-    )
+    g = metric(pos_vec[0], pos_vec[1], mass.value, a, Qc.value)
     A = g[0, 0]
     B = 2 * g[0, 3]
     C = (
diff --git a/src/einsteinpy/utils/schwarzschild_utils.py b/src/einsteinpy/utils/schwarzschild_utils.py
index 62ad48a..7e0f23c 100644
--- a/src/einsteinpy/utils/schwarzschild_utils.py
+++ b/src/einsteinpy/utils/schwarzschild_utils.py
@@ -4,8 +4,7 @@ import numpy as np
 from einsteinpy import constant
 
 
-@u.quantity_input(mass=u.kg)
-def schwarzschild_radius(mass):
+def schwarzschild_radius(mass, c=constant.c, G=constant.G):
     """
     Schwarzschild radius is the radius defining the event horizon of a
     Schwarzschild black hole. It is characteristic radius associated with every
@@ -21,12 +20,37 @@ def schwarzschild_radius(mass):
         Schwarzschild radius for a given mass
 
     """
+    if not isinstance(mass, u.quantity.Quantity):
+        mass = mass * u.kg
+    if not isinstance(c, u.quantity.Quantity):
+        c = c * u.m / u.s
+    if not isinstance(G, u.quantity.Quantity):
+        G = G * constant.G.unit
     M = mass.to(u.kg)
-    num = 2 * constant.G * M
-    deno = constant.c ** 2
+    num = 2 * G * M
+    deno = c ** 2
     return num / deno
 
 
+def schwarzschild_radius_dimensionless(M, c=constant.c.value, G=constant.G.value):
+    """
+    Parameters
+    ------------
+    M : float
+        Mass of massive body
+    c : float
+        Speed of light, defaults to value of speed of light in SI units.
+    G : float
+        Gravitational Constant, defaults to its value in SI units
+    Returns
+    -------
+    Rs : float
+        Schwarzschild radius for a given mass
+    """
+    Rs = 2 * M * G / c ** 2
+    return Rs
+
+
 @u.quantity_input(mass=u.kg)
 def time_velocity(pos_vec, vel_vec, mass):
     """
@@ -62,27 +86,28 @@ def time_velocity(pos_vec, vel_vec, mass):
     return time_vel * u.one
 
 
-def metric(c, r, theta, Rs):
+def metric(r, theta, M, c=constant.c.value, G=constant.G.value):
     """
     Returns the Schwarzschild Metric
 
     Parameters
     ----------
-    c : float
-        Speed of light
+    
     r : float
         Distance from the centre
     theta : float
         Angle from z-axis
-    Rs : float
-        Schwarzschild Radius
-
+    M : float
+        Mass of the massive body
+    c : float
+        Speed of light
     Returns
     -------
     ~numpy.array
         Numpy array of shape (4,4)
 
     """
+    Rs = schwarzschild_radius_dimensionless(M, c, G)
     m = np.zeros(shape=(4, 4), dtype=float)
     tmp, c2 = 1.0 - (Rs / r), c ** 2
     m[0, 0] = tmp
@@ -92,20 +117,21 @@ def metric(c, r, theta, Rs):
     return m
 
 
-def christoffels(c, r, theta, Rs):
+def christoffels(r, theta, M, c=constant.c.value, G=constant.G.value):
     """
     Returns the 3rd rank Tensor containing Christoffel Symbols for Schwarzschild Metric
 
     Parameters
     ----------
-    c : float
-        Speed of light
+    
     r : float
         Distance from the centre
     theta : float
         Angle from z-axis
-    Rs : float
-        Schwarzschild Radius
+    M : float
+        Mass of the massive body
+    c : float
+        Speed of light
 
     Returns
     -------
@@ -113,6 +139,7 @@ def christoffels(c, r, theta, Rs):
         Numpy array of shape (4,4,4)
 
     """
+    Rs = schwarzschild_radius_dimensionless(M, c, G)
     chl = np.zeros(shape=(4, 4, 4), dtype=float)
     c2 = c ** 2
     chl[1, 0, 0] = 0.5 * Rs * (r - Rs) * c2 / (r ** 3)


Test patch:
diff --git a/src/einsteinpy/tests/test_metric/test_kerr.py b/src/einsteinpy/tests/test_metric/test_kerr.py
index 5cb459e..4c0b755 100644
--- a/src/einsteinpy/tests/test_metric/test_kerr.py
+++ b/src/einsteinpy/tests/test_metric/test_kerr.py
@@ -7,7 +7,7 @@ from numpy.testing import assert_allclose
 
 from einsteinpy import constant
 from einsteinpy.metric import Kerr
-from einsteinpy.utils import kerr_utils, schwarzschild_radius
+from einsteinpy.utils import kerr_utils, schwarzschild_radius_dimensionless
 
 _c = constant.c.value
 
@@ -54,7 +54,7 @@ _c = constant.c.value
 def test_calculate_trajectory(
     pos_vec, vel_vec, time, M, a, start_lambda, end_lambda, OdeMethodKwargs
 ):
-    _scr = schwarzschild_radius(M).value
+    _scr = schwarzschild_radius_dimensionless(M)
     obj = Kerr.from_BL(pos_vec, vel_vec, time, M, a)
     ans = obj.calculate_trajectory(
         start_lambda=start_lambda,
@@ -64,7 +64,7 @@ def test_calculate_trajectory(
     ans = ans[1]
     testarray = list()
     for i in ans:
-        g = kerr_utils.metric(_c, i[1], i[2], _scr, a)
+        g = kerr_utils.metric(i[1], i[2], M.value, a)
         testarray.append(
             g[0][0] * (i[4] ** 2)
             + g[1][1] * (i[5] ** 2)
diff --git a/src/einsteinpy/tests/test_metric/test_schwarzschild.py b/src/einsteinpy/tests/test_metric/test_schwarzschild.py
index c07da52..06acdcf 100644
--- a/src/einsteinpy/tests/test_metric/test_schwarzschild.py
+++ b/src/einsteinpy/tests/test_metric/test_schwarzschild.py
@@ -57,11 +57,10 @@ def test_calculate_trajectory(
         end_lambda=end_lambda,
         OdeMethodKwargs=OdeMethodKwargs,
     )
-    _c, _scr = constant.c.value, schwarzschild_radius(M).value
     ans = ans[1]
     testarray = list()
     for i in ans:
-        g = schwarzschild_utils.metric(_c, i[1], i[2], _scr)
+        g = schwarzschild_utils.metric(i[1], i[2], M.value)
         testarray.append(
             g[0][0] * (i[4] ** 2)
             + g[1][1] * (i[5] ** 2)
diff --git a/src/einsteinpy/tests/test_utils/test_kerr_utils.py b/src/einsteinpy/tests/test_utils/test_kerr_utils.py
index c7dea63..bec812a 100644
--- a/src/einsteinpy/tests/test_utils/test_kerr_utils.py
+++ b/src/einsteinpy/tests/test_utils/test_kerr_utils.py
@@ -5,8 +5,8 @@ import pytest
 from astropy import units as u
 from numpy.testing import assert_allclose
 
-from einsteinpy import constant, utils
-from einsteinpy.utils import kerr_utils
+from einsteinpy import constant
+from einsteinpy.utils import kerr_utils, schwarzschild_radius_dimensionless
 
 
 def test_nonzero_christoffels():
@@ -23,9 +23,9 @@ def test_spin_factor():
 def test_event_horizon_for_nonrotating_case():
     M = 5e27
     a = 0.0
-    _scr = utils.schwarzschild_radius(M * u.kg).value
-    a1 = kerr_utils.event_horizon(_scr, a, np.pi / 4)
-    a2 = kerr_utils.event_horizon(_scr, a, np.pi / 4, "Spherical")
+    _scr = schwarzschild_radius_dimensionless(M)
+    a1 = kerr_utils.event_horizon(M, a, np.pi / 4)
+    a2 = kerr_utils.event_horizon(M, a, np.pi / 4, "Spherical")
     assert_allclose(a1, a2, rtol=0.0, atol=1e-5)
     assert_allclose(a1[0], _scr, rtol=0.0, atol=1e-5)
 
@@ -33,9 +33,9 @@ def test_event_horizon_for_nonrotating_case():
 def test_radius_ergosphere_for_nonrotating_case():
     M = 5e27
     a = 0.0
-    _scr = utils.schwarzschild_radius(M * u.kg).value
-    a1 = kerr_utils.radius_ergosphere(_scr, a, np.pi / 5)
-    a2 = kerr_utils.radius_ergosphere(_scr, a, np.pi / 5, "Spherical")
+    _scr = schwarzschild_radius_dimensionless(M)
+    a1 = kerr_utils.radius_ergosphere(M, a, np.pi / 5)
+    a2 = kerr_utils.radius_ergosphere(M, a, np.pi / 5, "Spherical")
     assert_allclose(a1, a2, rtol=0.0, atol=1e-5)
     assert_allclose(a1[0], _scr, rtol=0.0, atol=1e-5)
 
@@ -45,12 +45,12 @@ def test_christoffels():
     c = 3e8
     r = 100.0
     theta = np.pi / 5
-    Rs = 1.0
+    M = 6.73317655e26
     a = 0.2
-    chl1 = kerr_utils.christoffels(c, r, theta, Rs, a)
+    chl1 = kerr_utils.christoffels(r, theta, M, a, c)
     # calculate by formula
-    invg = kerr_utils.metric_inv(c, r, theta, Rs, a)
-    dmdx = kerr_utils.dmetric_dx(c, r, theta, Rs, a)
+    invg = kerr_utils.metric_inv(r, theta, M, a, c)
+    dmdx = kerr_utils.dmetric_dx(r, theta, M, a, c)
     chl2 = np.zeros(shape=(4, 4, 4), dtype=float)
     tmp = np.array([i for i in range(4 ** 3)])
     for t in tmp:
@@ -76,7 +76,7 @@ def test_scaled_spin_factor_raises_error(a):
 
 def test_scaled_spin_factor():
     a = 0.8
-    M = 5e24 * u.kg
-    a1 = kerr_utils.scaled_spin_factor(a, M.value)
-    a2 = utils.schwarzschild_radius(M).value * a * 0.5
+    M = 5e24
+    a1 = kerr_utils.scaled_spin_factor(a, M)
+    a2 = schwarzschild_radius_dimensionless(M) * a * 0.5
     assert_allclose(a2, a1, rtol=1e-9)
diff --git a/src/einsteinpy/tests/test_utils/test_kerrnewman_utils.py b/src/einsteinpy/tests/test_utils/test_kerrnewman_utils.py
index 520eae0..a6d5c92 100644
--- a/src/einsteinpy/tests/test_utils/test_kerrnewman_utils.py
+++ b/src/einsteinpy/tests/test_utils/test_kerrnewman_utils.py
@@ -26,20 +26,20 @@ def test_input():
 def test_compare_kerr_kerrnewman_metric_inv(test_input):
     c, G, Cc, r, theta, M, a = test_input
     # inverse of metric for kerr and kerr-newman metric should be equal when Q=0
-    scr = M * G / (c ** 2)
-    a_scaled = kerr_utils.scaled_spin_factor(a, M, c, G)
-    m1 = kerr_utils.metric_inv(c, r, theta, scr, a_scaled)
-    m2 = kerrnewman_utils.metric_inv(c, G, Cc, r, theta, scr, a_scaled, 0.0)
+    scr = 2 * M * G / (c ** 2)
+    a_scaled = kerr_utils.scaled_spin_factor(a, M)
+    m1 = kerr_utils.metric_inv(r, theta, M, a_scaled)
+    m2 = kerrnewman_utils.metric_inv(r, theta, M, a_scaled, 0.0)
     assert_allclose(m1, m2, rtol=1e-10)
 
 
 def test_compare_kerr_kerrnewman_dmetric_dx(test_input):
     c, G, Cc, r, theta, M, a = test_input
     # differentiation of metric for kerr and kerr-newman metric should be equal when Q=0
-    scr = M * G / (c ** 2)
-    a_scaled = kerr_utils.scaled_spin_factor(a, M, c, G)
-    m1 = kerr_utils.dmetric_dx(c, r, theta, scr, a_scaled)
-    m2 = kerrnewman_utils.dmetric_dx(c, G, Cc, r, theta, scr, a_scaled, 0.0)
+    scr = 2 * M * G / (c ** 2)
+    a_scaled = kerr_utils.scaled_spin_factor(a, M)
+    m1 = kerr_utils.dmetric_dx(r, theta, M, a_scaled)
+    m2 = kerrnewman_utils.dmetric_dx(r, theta, M, a_scaled, 0.0)
     assert_allclose(m1, m2, rtol=1e-10)
 
 
@@ -47,12 +47,12 @@ def test_christoffels1(test_input):
     # compare christoffel symbols output by optimized function and by brute force
     c, G, Cc, r, theta, M, a = test_input
     Q = 1.0
-    scr = M * G / (c ** 2)
-    a_scaled = kerr_utils.scaled_spin_factor(a, M, c, G)
-    chl1 = kerrnewman_utils.christoffels(c, G, Cc, r, theta, scr, a_scaled, Q)
+    scr = 2 * M * G / (c ** 2)
+    a_scaled = kerr_utils.scaled_spin_factor(a, M)
+    chl1 = kerrnewman_utils.christoffels(r, theta, M, a_scaled, Q)
     # calculate by formula
-    invg = kerrnewman_utils.metric_inv(c, G, Cc, r, theta, scr, a_scaled, Q)
-    dmdx = kerrnewman_utils.dmetric_dx(c, G, Cc, r, theta, scr, a_scaled, Q)
+    invg = kerrnewman_utils.metric_inv(r, theta, M, a_scaled, Q)
+    dmdx = kerrnewman_utils.dmetric_dx(r, theta, M, a_scaled, Q)
     chl2 = np.zeros(shape=(4, 4, 4), dtype=float)
     tmp = np.array([i for i in range(4 ** 3)])
     for t in tmp:
@@ -70,17 +70,17 @@ def test_christoffels1(test_input):
 def test_compare_kerr_kerrnewman_christoffels(test_input):
     # christoffel symbols for kerr and kerr-newman metric should be equal when Q=0
     c, G, Cc, r, theta, M, a = test_input
-    scr = M * G / (c ** 2)
-    a_scaled = kerr_utils.scaled_spin_factor(a, M, c, G)
-    c1 = kerr_utils.christoffels(c, r, theta, scr, a_scaled)
-    c2 = kerrnewman_utils.christoffels(c, G, Cc, r, theta, scr, a_scaled, 0.0)
+    scr = 2 * M * G / (c ** 2)
+    a_scaled = kerr_utils.scaled_spin_factor(a, M)
+    c1 = kerr_utils.christoffels(r, theta, M, a_scaled)
+    c2 = kerrnewman_utils.christoffels(r, theta, M, a_scaled, 0.0)
     assert_allclose(c1, c2, rtol=1e-8)
 
 
 def test_electric_magnetic_potential_from_em_potential_vector(test_input):
     c, G, Cc, r, theta, M, a = test_input
     Q = 15.5
-    vec = kerrnewman_utils.em_potential(c, G, Cc, r, theta, 0.0, Q, M)
+    vec = kerrnewman_utils.em_potential(r, theta, 0.0, Q, M)
     cmparr = np.zeros((4,), dtype=float)
     cmparr[0] = (Q / ((c ** 2) * r)) * np.sqrt(G * constant.coulombs_const.value)
     assert_allclose(cmparr, vec, rtol=1e-8)
@@ -92,9 +92,7 @@ def test_compare_kerr_kerrnewman_time_velocity():
     vel_vec = np.array([-0.1, -0.01, 0.05])
     mass = 1e24 * u.kg
     a01 = 0.85
-    a = kerr_utils.scaled_spin_factor(
-        a01, mass.to(u.kg).value, constant.c.value, constant.G.value
-    )
+    a = kerr_utils.scaled_spin_factor(a01, mass.to(u.kg).value)
     t1 = kerr_utils.kerr_time_velocity(pos_vec, vel_vec, mass, a)
     t2 = kerrnewman_utils.kerrnewman_time_velocity(pos_vec, vel_vec, mass, a, 0.0 * u.C)
     assert_allclose(t1.value, t2.value, rtol=1e-10)
@@ -107,7 +105,7 @@ def test_maxwell_tensor_covariant_for_natural_units():
     theta = 3 * np.pi / 5
     Q = 10.0
     a = 0.5
-    m = kerrnewman_utils.maxwell_tensor_covariant(1.0, 1.0, 1.0, r, theta, a, Q, M)
+    m = kerrnewman_utils.maxwell_tensor_covariant(r, theta, a, Q, M, 1.0, 1.0, 1.0)
     for t in range(16):
         i = int(t / 4) % 4
         j = t % 4
@@ -136,7 +134,7 @@ def test_maxwell_tensor_contravariant_for_natural_units():
     theta = 2 * np.pi / 5
     Q = 45.0
     a = 0.7
-    m = kerrnewman_utils.maxwell_tensor_contravariant(1.0, 1.0, 1.0, r, theta, a, Q, M)
+    m = kerrnewman_utils.maxwell_tensor_contravariant(r, theta, a, Q, M, 1.0, 1.0, 1.0)
     for t in range(16):
         i = int(t / 4) % 4
         j = t % 4
diff --git a/src/einsteinpy/tests/test_utils/test_schwarzschild_utils.py b/src/einsteinpy/tests/test_utils/test_schwarzschild_utils.py
index c1da80a..2955af8 100644
--- a/src/einsteinpy/tests/test_utils/test_schwarzschild_utils.py
+++ b/src/einsteinpy/tests/test_utils/test_schwarzschild_utils.py
@@ -13,8 +13,8 @@ _G = constant.G.value
 def test_compare_kerr_and_schwarzschild_metric():
     r = 99.9
     theta = 5 * np.pi / 6
-    Rs = 9e-3
+    M = 6.73317655e26
     # Kerr metric would reduce to Schwarzschild metric under limits a=0
-    mk = kerr_utils.metric(_c, r, theta, Rs, 0.0)
-    ms = schwarzschild_utils.metric(_c, r, theta, Rs)
+    mk = kerr_utils.metric(r, theta, M, 0.0)
+    ms = schwarzschild_utils.metric(r, theta, M)
     assert_allclose(mk, ms, rtol=1e-8)